面向对象的三大特性（封装、继承、多态）

一、封装

1. 修饰符：private ,代表私有的，被private 修饰的内容只能在本类中使用。

   ​ public ,代表公开的，公共的

2. 封装的要求：

   (1) 属性私有化：属性被 private修饰

   (2) 为私有属性提供公开的get和set方法

   ​ a. get 方法：获取私有化属性的值

   ​ public 数据类型 get属性名(){

   ​ return this.属性名;

   ​ }

   ​ 注意：返回值的数据类型取决于 获取属性的数据类型

   ​ 方法名 ： get + 属性名 首字母大写

   ​ b. set 方法：为私有化属性赋值

   ​ public void set属性名(数据类型 变量名){

   ​ this.属性名 = 变量名;

   ​ }

   ​ 注意：形式参数的数据类型取决于 赋值的属性的数据类型

   ​ 方法名： set + 属性名 -》首字母大写

3. 使用:

   (1) 获取私有化的属性值：通过 get方法

   (2) 为私有化的属性赋值：通过 set方法

二、继承

​

1. 概念：【理解+应用】

   ​ 水杯 是一种 容器

   ​ 铅笔 是一种 笔

   ​ 狗 是一种 动物

   ​ A is - a B

   ​ A 继承 B

   (1) 继承 体现的类与类之间的 一种 "is - a"关系

   ​ A is a B

   ​ A 继承 B

   ​ A extends B

   ​ 子类 父类

   ​ 语法： class 子类名 extends 父类名{} 【开发应用】

   (2) 继承是一种机制，通过继承可以让子类使用父类中的属性和方法

   (3) 开发时不能强制使用 继承(extends)，继承机制本身存在一种 "is-a"关系，不能人为、刻意的创造使用。

2. 继承的好处：提高代码的可复用性、可扩展性。

3. 方法的覆盖(override)（又称为方法的 重写）【重点：开发+面试】

   (1) 概念：在子类中定义和父类同名的方法。(发生在父子类之间)

   (2) 覆盖的要求：

   ​ a. 子类的 方法名、形参列表、返回值类型 和 父类 相同

   ​ b. 子类的访问修饰符 和 父类相同或是 比父类更宽

   (3) 使用：一旦子类覆盖了父类中方法，子类覆盖后的方法优先被使用(用子类型的引用调用)。

   (4) 注意：

   ​ a. 如果 子类的方法名、形参列表和父类相同，但是返回值类型不同，编译报错。

   ​ b. 如果 子类的方法名、返回值类型和父类相同，但是形式参数列表不同，编译通过，运行通过。—》重载

   ​ 写出 方法 覆盖 和 方法重载 各自特点。

   ​ 写出 override 和 overload 的 各自特点。

   (5) 应用场景：当子类从父类继承的方法不足以满足自身需求时，可以将继承到方法进行覆盖。

4. 父类中属性和方法是将每一个子类的共性进行提取，决定父类中属性和方法。 【理解】

   (1)父类中信息是 一般的、抽象的

   (2) 子类中信息是特殊的、具体的

5. Java继承的特点：Java中的类之间是单继承关系，一个类只能有一个直接的父类， 【理解】

   ​ 但是可以有多个间接的父类(多级继承)

   ​ 注意：Java中类之间的单继承关系，体现Java语言的简单性的特点。

6. 子类可以从父类中继承哪些内容？构造方法、属性和成员方法来思考。

   (1) 构造方法不能被子类继承 【理解】

   ​ a. 构造方法的方法名必须和类名一样，子类和父类各有不同类名，所以子类继承父类的构造方法不满足

   ​ 构造方法的语法要求，所以不能继承

   ​ b. 子类的属性 和方法要比父类更复杂，所以子类的构造方法需要完成更多的赋值内容，所以父类的构造

   ​ 方法不满足子类构造需求，子类需要定义自身构造方法。

   (2) 属性和成员方法取决于访问修饰符(访问权限) 【面试+开发重点】

   ​ a. Java中的4个访问修饰符

   ​ 本类 同包(同包子类+非子类) 不同包的子类 其他(不同的非子类)

   ​ private(私有的)： ok

   ​ default(默认)： ok ok

   ​ protected(受保护的)： ok ok ok

   ​ public(公开的、公共的)： ok ok ok ok

   ​ b. 修饰符可以修饰符的内容：

   ​ I. 4个访问修饰符都可以用于修饰符属性、成员方法、构造方法

   ​ II. public 和 default 可以用于修饰类

   ​ c. 访问修饰符修饰属性和成员方法的继承性如下：

   ​ private (私有的) 不能被继承

   ​ default(默认的) 同包下的子类可以被继承

   ​ protected(受保护的)：可以被子类继承的 (同包下的子类+不同下子类)

   ​ public (公开的) ： 可以被继承

7. 创建对象的过程：继承 (先完成父类对象的创建，再完成子类对象的创建) 【理解】

   (1) 分配空间：子类+所有的父类空间 —》给属性赋默认值

   (2) 递归的创建父类对象：

   ​ a. 初始化父类的属性：父类属性第二次赋值机会

   ​ b.执行父类的构造方法：父类属性第三次赋值的机会

   (3) 完成子类对象的创建：

   ​ a. 初始化子类的属性：子类属性第二次赋值的机会

   ​ b. 执行子类的构造方法：子类属性第三次赋值的机会

8. super的应用: super()/super. 【面试+开发重点】

   (1) 第一种应用：

   ​ a. super() /super(实参) ：用在子类的构造方法中，指示创建子类对象时，JVM先去完成父类对象对象创

   ​ 建时，调用父类哪一个构造方法

   ​ b. super(): 调用父类无参数的构造方法

   ​ super(实参)：调用父类有参数的构造方法

   ​ c. 注意：I .super()/super(实参) 必须定义在构造方法中第一行有效语句；

   ​ II. 子类的构造方法方法第一行如果没有 super()/super(实参)/ … 的应用，

   ​ 则JVM默认添加super() ;

   ​ III. this()/this(实参) 和 super()/super(实参) 不能同时定义在一个构造方法中

   ​ Iv. 如果子类的构造方法的第一行语句为 this()/this(实参)，则JVM完成父类创建时不在当前的子类

   ​ 的构造方法第一行语句查找 super()/super(实参) ，而是转向 this()/this(实参)指向的构造方法

   ​ 的第一行查找super()/super(实参)。

   (2) 第二种应用：

   ​ a. super. 用在子类的构造方法或是成员方法中 ，代表调用当前父类对象属性和成员方法

   ​ b. super.属性名 ： 调用父类的属性

   ​ super.成员方法： 调用父类的成员方法

   ​ 面试题目：写出 this 和 super 的区别。

   ​ 总结： 当前JVM默认添加的代码？

   ​ (1) 在一个类的成员方法中访问本类的其他成员方法或是 属性，默认 添加 this.

   ​ (2) 如果一个类中没有定义构造方法，则JVM默认添加公开、无参数的构造方法

   ​ (3) 如果子类的构造方法第一行没有使用 this()/this(实参) 或是 super(实参) ，则JVM默认在构造方

   ​ 法第一行添加 super();

   ​ (4) java.lang 包中类如果被使用，则JVM默认添加 import java.lang. 类名; 语句

   ​

三、多态

1. 概念：【理解+应用】

   (1) 多态：父类型的引用 指向 子类型对象。

   ​ 语法： 父类类名 引用名 = new 子类类名(实参);

   ​ 引用 对象

   ​ 父类型 子类型

   ​ 主观类型 实际类型

   (2) 用父类型的引用调用属性或是成员方法，只能调用父类中定义的属性和方法。(编译的时候检测)

   (3) 运行的时候，JVM会自动的检测子类是否覆盖了父类中方法，如果子类覆盖父类中方法，则执行

   ​ 子类覆盖后的方法，否则，直接执行的是父类中方法。

2. 引用之间的转换：【开发应用重点】

   (1) 父类型的引用 赋值 给 子类型的引用 ，通过强制类型转换

   ​ 大类型 小类型

   ​ a. 语法： 子类类名 引用名 = (子类类名)父类型的引用名;

   ​ b. 案例：Animal a= new Dog();

   ​ Dog d = (Dog)a;

   ​ c. 结果：将父类型引用 通过强制类型转换 赋值给子类型的引用，编译一定通过,运行分为以下两种情况：

   ​ i. 如果 实际存储对象类型 和 要转换的类型一致，则编译通过，运行也通过。

   ​ Animal a= new Dog();

   ​ Dog d = (Dog)a;

   ​ ii. 如果 实际存储对象类型和要转换的类型不一致，则编译通过，运行报错，错误如下：

   ​ java.lang.ClassCastException(类型转换异常)

   ​ 例如： Animal a = new Cat(); // 实际存储对象类型是 ： Cat

   ​ Dog d = (Dog)a; // 要转换的类型 Dog

   ​ 注意：引用中实际存储的对象类型不变。

   ​ d. 如何避免类型转换异常( java.lang.ClassCastException)？

   ​ i. 利用 instanceof关键字避免 类型转换异常。

   ​ ii. 语法：引用名 instanceof 类名

   ​ iii. 作用：将引用中存储的实际对象类型 和 instanceof后面的类型相比较，如果实际对象类型

   ​ 兼容后面的类型，结果-true,不兼容-结果为false.

   ​ Iv. 应用场景：父类型的引用利用强制类型转换为子类型时，可以利用 instanceof判断。

   Animal a = new Dog();
   if(a instanceof Cat){Cat c = (Cat)a;System.out.println("~~~转换成功...");
   }               	       
   

   (2) 子类型 的引用 赋值 父类型的引用 ，可以直接赋值 —》多态

   ​ 小类型 大类型

   ​ a. 语法： 父类类名 引用名 = 子类型的引用名;

   ​ b. 案例：Dog d = new Dog();

   ​ Animal a = d;

   (3) 不存在继承关系的双方，不允许转换，强制类型转换也不能通过，编译直接报错。

   ​ Animal a = new Dog();

   ​ Person p = (Person)a; // 编译报错

3. 多态的实际开发应用【开发应用重点】

   (1) 多态用在数组上：本类型+所有的子类型的对象都可以作为数组元素进行存储。

   (2) 多态用在形式参数上：本类型+所有子类型的对象都可以作为实际参数进行传递。

   (3) 多态用在返回值上：本类型+所有的子类型的对象都可以作为返回值返回。

4. 多态体现的好处【理解】

   (1) 屏蔽不同子类之间差异性，进行统一管理

   (2) 让程序更加灵活和通用