面向过程：关注的是过程——步骤。
站在一个执行者的角度考虑问题，做事情。
面相对向：关注的是对象——。
站在一个指挥者的角度。
是一种编程思想，不是一种编程语言。
如何使用面向对象的思维方式思考问题？
- A：思考问题域中涉及到了哪些对象。
- B：设计这些对象。(构建类)
- C：对象和对象之间的关系。
- 继承关系：is - a
- 实现关系：实现类，实现接口。
- 依赖关系：一个类作为另一个类的方法的参数。
- 关联关系：一个类作为另一个类的属性。
概念：类，就是类别。同一类事物的抽象描述。
- 类的属性：成员变量，描述类的外部的特征的。选"名词"。
- 类的功能：成员方法，描述类的行为功能的。选"动词"。
示例代码：
public class Person{
String name;
int age;
public void eat(){
}
}
概念：类中的一个具体的实例。
- 对象就是可以访问类中的数据：赋值，取值
- 对象还可以执行类中的方法：将方法进行调用。
就是通过调用类的构造方法，进行创建对象，就得到了该类的实例。
Person p1 = new Person();
类和对象的关系：
构造方法，又叫构造器，构造函数。Constructor。
就是一个特殊的方法。
1、作用：专门用于创建对象的。
2、声明：要区别于普通的方法。
修饰符：只允许访问权限修饰符。
返回值：没有，不能写void。
方法名：必须和类名一致。
参数列表：无参，有参
3、调用：必须通过new关键字来调用，开辟内存，创建对象。
注意点：
如果一个类中，没有显示的构造方法，那么由编译器自动添加一个，无参构造方法。
如果类中，有了自己写的构造方法，那么编译器不会再给添加任何的构造方法。
示例代码：
public class Person{
String name;
int age;
public void Person(){}
public void Person(String name,int age){}
public void eat(){
}
}
编码习惯：
只有对象的创建，没有对象的声明。就是没有名字的对象：就是没有一个引用持有它的地址。
//正常的对象：=左边做对象的声明，就是个引用， =右边在创建对象，创建完对象之后，会将对象的内存地址给p1。p1叫做引用，叫做对象。
Person p1 = new Person();//引用类型
//匿名对象：
new Person().eat();
"一次性的"。随着对象的创建而使用一次。
概念："打包"的概念。保护数据安全。隐藏类的实现细节，对外提供统一的操作。
体现：
1、类的封装。
2、方法的封装。
3、属性的封装
step1：使用private修饰属性，限于本类中使用
step2：提供getter和setter方法，用于给属性赋值和取值。
注意点：boolean类型，isXXX();
1、private：限于类的内部能够访问
2、默认的：啥都不写就是默认的(缺省),限于同包下能够访问
3、protected：受保护的，限于同包下能够访问，不同包需要子类中才能够使用。
4、public：公共的， 没有限制。
示例代码：
public class Person{
private String name;
private int age;
public void setName(String name){//就近原则
this.name = name;
}
public void eat(){
System.out.println(name+"，吃东西啦。。");
}
}
词义：这个，
用法一：指代本类的对象。
? 可以访问本类的属性和方法。在本类中使用的时候，this可以省略。编译器会自动添加。
? 但是，当局部变量名和成员变量，命名冲突时，可以使用this来进行区分。
用法二：指代本类的构造方法。
? this()，就表示构造方法。当前类的。
? 如果类中有多个构造方法，那么靠参数来区分：this()-->无参构造，this(参数)-->有参构造
? 要位于首行。
概念：描述两个类的关系。一个类(子类)继承了另一个类(父类)。
满足 子类 is - a 父类 范式，两个类才可以使用继承。
父类：基类，超类，SuperClass
子类：派生类，SubClass
- 子类中可以直接访问父类的非私有化的属性和方法。
- 子类可以新增自己的属性和方法。
- 子类还可以重写父类的方法。
1、降低程序的冗余，避免重复的代码。
2、子类扩展父类的功能。
3、模拟现实世界的关系。
extends：词义，扩展
class SuperClass{}
class SubClass extends SuperClass{}
意味着：子类的构造方法，第一行一定是调用了父类的构造方法。默认调用父类的无参构造方法。如果子类的构造方法，没有显示的调用父类的构造方法， 那么由编译器自动添加super()，表示调用父类的无参构造。
注意和this关键字的对比。
概念：继承中，子类将父类已有的方法，重新实现。(重新提供一个方法体)
规则：
1、继承结构中
2、重写方法声明必须和父类的一致：返回值类型，方法名，参数列表。
3、访问权限，不能比父类更加严格：private-默认的-protected-public
4、重写方法不能抛出比父类更大的异常。
概念：事物的多种形态。
方法的多态：一个方法的多种形态--->方法的重载(overload)。
? 概念：同一个功能方法，根据参数不同，执行的具体的方法也不同。
class A{
public void add(int i,int j){//1
}
public void add(double d1,double d2){//2
}
}
? 规则：
对象的多态：结合方法的重写。
子类对象的向上转型和向下转型。
父类：Animal，子类：Cat，Dog
class Aniaml{
String name;
int age;
public void eat(){}
public void sleep(){}
}
class Cat{
String color;
@override
public void eat(){
}
//新增
public void catchMouse(){
}
}
1、向上转型：子类对象向上转型后，会失去子类新增。可以访问的是父类的属性和方法，以及子类重写。
2、向下转型：以向上转型为前提，将子类对象，由父类类型，再转为子类类型。可以重新获访问子类新增。
继承结构中，子类是一个特殊的父类类型。
父类类型，指向一个父类对象。
Animal a1 = new Aniaml();
也可以指向一个子类对象。子类对象的向上转型。
Animal a2 = new Cat();//向上转型，name，age，重写eat()，sleep()
Cat c1 = new Cat();
Cat c2 = (Cat)a2;//向下转型,name,age,color,重写eat()，sleep()，catchMouse()
instanceof关键字：
来判断某个引用指向的对象，是否属于某个类(包含父类)。
向下转型前：先使用instanceof关键字，判断是否是该类型，否则会失败：ClassCastException
语法：
引用 instanceof 类名
--->boolean的结果：true，false
Animal a1 = new Animal();
Cat c1 = new Cat();
a1 instanceof Animal ---> true
c1 instanceof Cat --->true
c1 instanceof Animal ---> true
a1 instanceof Cat ---> false
3、结合方法的重写
总结：
如果想知道一个引用，能够访问哪些？看=左边是什么类型的。
? 如果=左边声明的是父类类型，那么就调用父类中声明。
? 如果=左边声明的是子类子类，那么就调用父类中的，以及子类新增的。
如果想知道一个引用，执行的方法是否重载？看=右边真正创建的是哪个对象
? 如果=右边创建的是父类对象，那么调用父类中。
? 如果=右边创建的是子类对象，那么调用子类重写的方法。
对象多态性结合方法的重写：如何体现多态的？
Animal a1 = new Aniaml();//调用父类的方法，不是子重写的。
Animal a2 = new Cat();//调用父类中声明的，但是是子类重写的方法。
a1,a2---->Animal
根据new的对象不同，可能调用重写的(子类对象)，也可能调用不重写(父类对象)。
4、对象多态性的应用
将父类的类型作为参数，可以传入任意的子类对象。传参：向上转型。
将父类的类型作为返回值，可以返回任意的子类对象。
public static void test(Animal a){
}
public Animal getAnimal(){
//......
return new Cat();
}
public static void main(String[] args){
Animal a1 = new Animal();
Cat c1 = new Cat();
test(a1);
test(c1);
}
含义："静态的"，属于类。由类直接访问。
由static修饰的方法，就叫做静态方法。由类直接调用。对象也可以调用，但是不建议。
静态方法：可以有静态的属性以及调用其他的静态方法。
静态方法：不能直接访问非静态的属性和方法，以及不能出现this和super关键字。
应用：如果一个方法中不涉及对象的内容，就可以设计为静态方法。由类直接调用，不需要创建对象。比较简洁。
工具类：往往都是静态方法，由类直接调用。
局部代码块：
也叫普通代码块。就是方法中的一块代码。if，for，while。。。{}
注意作用域
构造代码块：
静态代码块：
同步代码块：
词义："最终的，最后的"
含义："抽象的"
修饰方法：抽象方法
该方法只有方法的声明(功能描述)，没有方法体，{}也没有，直接；结束了。
目的：将功能的声明和实现分离开。强制子类必须重写
所在的类，必须是抽象的。
修饰类：抽象类——>"做爸爸"
抽象方法所在的类，必须抽。
抽象类中不一定非要包含抽象方法。
接口就是一个协议，一种规则，一个标准，一个功能声明。
? USB，Type-C。。。。
//声明一个接口
interface A{
//静态常量
//抽象方法
}
//接口更不允许实例化，需要有实现类来实现接口中的方法。
class A1 implements A{
//此处实现接口A中的所有抽象方法。
}
接口中：
一个接口A，和它的实现类，在另一个类B中，持有了接口A的引用，调用接口中的方法，就是接口回调。
原文：https://www.cnblogs.com/raising/p/13069731.html