Videos By: Mosh Hamedani
Link: https://www.bilibili.com/video/BV19J411t7dD
1 Getting Started
1.1 Programming Paradigms
- Procedural
- Functional
- Object-oriented
- Event-driven
- Logic
- Aspect-oriented
Object-oriented
bring Data and Behavior in a single object
Functional
Data and Behavior are different
Problem Solving
Process of defining a problem, identifying and comparing different solutions and picking the one that best solves that problem with respect to the context and constraints.
Choice in paradigms
Depends on the problem, context and budget.
1.2 Benefits of Object-oriented Programming
reduce complexity
easier maintenance
code reuse
faster development
2 Classes
2.1 Classes and Objects
Class
A blueprint for creating objects.
Objects
An instance of a class.
UML
Short for Unified Modeling Language
2.2 Creating Classes
In src folder-> <package> -> create a new class
Using Pascal Naming Convention
1 | package com.ryanhe; |
2.3 Creating Objects
If you do not initialize the reference type, it will be set to null.
1 | package com.ryanhe; |
2.4 Memory Allocation
1 | package com.ryanhe; |
The new TextBox object is stored in the heap.
The textBox1 is stored in the stack and it stores the address of the object.
The textBox2 is referencing the same object.
Deallocation
Deallocation is automatically in Java -> Garbage collection.
2.5 Procedural Programming
1 | package com.ryanhe; |
In this program, the main class is bloated and the method has too many parameters.
So we’ll use object-oriented programming to refactor it.
2.6 Encapsulation
Encapsulation
Encapsulation is to bundle the data and methods that operate on the data in a single unit.
Employee.java
1 | package com.ryanhe; |
Main.java
1 | package com.ryanhe; |
2.7 Getters and Setters
Intro: what if the input salary is a negative integer?
One of the solutions: write a if statement to inspect the input of user. But it will make the main class bloated. So here we use setters and getters.
Main.java
1 | package com.ryanhe; |
Employee.java
1 | package com.ryanhe; |
Automatically add getters and setters
select the variable -> right click -> show context actions -> encapsulate field
2.8 Abstraction
Abstraction
Abstraction means to reduce complexity by hiding unnecessary details.
2.9 Coupling
Coupling
Coupling is about how much a class is dependent upon or coupled to another class.
hide or delete unnecessary coupling point
1 | package com.ryanhe; |
Easy way to create a method
1 | String address; |
Use the context action to create method automatically.
Easy way to create object
new <Class Name>()
and use context action “ Introduce local variable”.
2.10 Constructor
1 | package com.ryanhe; |
2.11 Method Overloading
1 | public int calculateWage(int extraHours){ |
2.12 Constructor Overloading
1 | public Employee(int baseSalary){ |
Easy way to find parameters of a method
ctrl
+ P
2.13 Static Members
Instance members: belongs to instances or objects
Static menbers: belongs to a class
Example: Employee.numberOfEmployees
is does not belongs to any object of Employee.
It’s unable for static method to access the non-static variables or methods unless you declare an object of the class.
Why the main method is declared as static?
Because this is to enable Java runtime to directly call this method without having to create a new object.
3 Refactoring to an Object-oriented Design
Easy way to move methods to new class
Select the method and use “refactor this” -> “Move”
Why the monthlyInterest
is refactored to a method instead of declaring and initializing in the constructor?
If we do so, it’s unchangeable when the annualInterest
is changed.
The Refactoring Result
Structure
4 classes:
- Main
- Console : Interact with users
- MortgageCalculator: Calculate relevant parameters
- MortgageReport: Output the results
Main.java
1 | package com.ryanhe; |
Console.java
1 | package com.ryanhe; |
MortgageCalculator.java
1 | package com.ryanhe; |
MortgageReport.java
1 | package com.ryanhe; |
4 Inheritance
4.1 Inheritance
1 | public class TextBox extends UIControl{ |
4.2 The Object Class
All the classes extends the class Object, which is from Java.lang.
Core methods:
equals()
hashCode()
toString() package it originally is from, followed by an @ sign and finally the hash code, represented as hexadecimal.
Example:
com.ryanhe.TextBox@1b6d3586
getClass()
4.3 Constructor and Inheritance
1 | package com.ryanhe; |
4.4 Access Modifier
private is not inherited by subclasses.
protected and (default) should be avoided.
modifier | Current Class | Classes in the same package | Inheritance | Other classes |
---|---|---|---|---|
private | √ | × | × | × |
(default) | √ | √ | × | × |
protected | √ | √ | √ | × |
public | √ | √ | √ | √ |
4.5 Method Overriding
Pay attention to the difference between overload and override.
Annotation
Annotation is basically a label that we attach to a class member.
Example: @Override
1 | @Override |
1 | // System.out.println(textBox.toString()); |
4.6 Upcasting and Downcasting
Upcasting is casting an object to one of its super types.
Downcasting is casting an object to one of its sub types.
1 | package com.ryanhe; |
instanceof
instanceof is used to judge whether a variable is an instance of a class
Example: control instanceof TextBox
Correction
1 | package com.ryanhe; |
4.7 Comparing Objects
Right Click ->
generate
->Override Methods
Right Click ->
generate
->equals() and hashCode()
Method 1
1 |
|
Method 2
1 |
|
Main.java
1 | package com.ryanhe; |
4.8 Polymorphism
In the UIControl class, define an empty render method. And in its sub classes, override the render method.
4.9 Abstract Classes and Methods
declare the class as abstract
1 | package com.ryanhe; |
4.10 Final Classes and Methods
Final Classes
If a class is declared as final, it cannot be extended.
Final Methods
If a method is declared as final, it cannot be overriden.
4.11 Deep Inheritance Hierarchies
Do not create deep inheritance hierarchies.
Example:
If Entity is modified, all these children and grandchildren should be compiled and redeployed.
NO MORE THAN 3 LEVELS.
4.12 Multiple Inheritance
Diamond Problem
Java does not support Multiple Inheritance.
5 Inferface
5.1 What is Interface
We use interface to build loosely-coupled extensible testable applications.
interface only have method declarations
- Interface tells us what should be done.
- Classes tells us how it should be done.
5.2 Creating an Interface
In the interface, public is not needed when declaring a method.
TaxCalculator.java
1 | package com.ryanhe; |
TaxCalulator2018.java
1 | package com.ryanhe; |
TaxReport.java
1 | package com.ryanhe; |
5.3 Dependency Injection
Our Classes should not instantiate their dependencies.
- Constructor Injection
- Setter Injection
- Method Injection
5.4 Constructor Injection
TaxReport.java
1 | package com.ryanhe; |
Main.java
1 | package com.ryanhe; |
5.5 Setter Injection
TaxReport.java
1 | package com.ryanhe; |
Main.java
1 | package com.ryanhe; |
5.6 Method Injection
TaxReport.java
1 | package com.ryanhe; |
Main.java
1 | package com.ryanhe; |
5.7 Interface Segregation Principle
Divide a big fat interface into a bunch of smaller ones.
Class cannot have multiple parents, but an interface can have multiple parents.
UIWidget.java
1 | package com.ryanhe; |
Though every time we use the drag and resize, we should instantiate an object of UIWidget, the three methods belongs to different interface so, they are independent.
Draggable.java
1 | package com.ryanhe; |
Resizable.java
1 | package com.ryanhe; |
Dragger.java
1 | package com.ryanhe; |
5.8 Bad Features on Interfaces
Fields
Declaring fields in our interfaces.
Fields are final and static.
Fields should be declared in the implementations, so we should avoid using fields in our interfaces.
Static Methods
1
2
3
4
5
6
7
8
9package com.ryanhe;
public interface TaxCalculator {
float minimumTax = 100; // final and static
double calculateTax();
static double getTaxableIncome(double income, double expenses){
return income - expenses;
}
}Here we add a static method into the interface, but it will make our Interface have implementation.
Solution: declare a new abstract method
Private Methods
5.9 Interfaces and Abstract Classes
5.10 When to Use Interface?
Benefits of Interface
- Swap Implementations
- Extend Your Applications
- Test Your Classes in Isolation