4.Java面向对象相关知识总结

一、static关键字

1. static修饰的特点

1.1 被类的所有对象共享，是我们判断是否使用静态关键字的条件。
1.2 随着类的加载而加载，优先于对象存在（即使没有创建对象，也可以通过类名来使用静态成员变量），对象需要被类加载后才能创建。
1.3 可以通过类名调用，也可以通过对象名调用。

2. static关键字注意事项

2.1 静态方法只能访问静态成员变量（因为静态随着类的加载而加载，优先于对象存在，而非静态成员变量需要在创建对象之后，才可以进行使用，所以在静态方法出现时，非静态成员变量可能还没有创建）
2.2 非静态方法可以访问静态的成员，也可以访问非静态的成员
2.3 静态方法中没有this关键字（因为this表示当前对象的引用，只有在对象创建了之后才可以使用，静态存在的时候，对象可能还没有被创建）

二、继承

1. 继承的概念
继承是面向对象三大特征之一，可以使得子类具有父类的属性和方法，还可以在子类中重新定义，以及追加属性和方法。

2. 继承带来的好处
2.1 继承可以让类与类之间产生关系，子父类关系；产生子父类关系后，子类可以使用父类中非私有的成员。
2.2 继承提高了代码的复用性（多个类相同的成员可以放在同一个类中）
2.3 提高了代码的维护性（如果方法的代码需要修改，修改一处即可）

3. 继承带来的弊端
继承让类与类之间产生了关系，类的耦合性增强了，当父类发生变化时，子类实现不得不跟着变化，削弱了子类的独立性

4. Java中继承的特点
4.1 Java中类只支持单继承，不支持多继承。错误范例：class A extends B, C { }
4.2 Java中支持多层继承。

5. 继承中变量的访问特点
在子类方法中访问一个变量，采用的是就近原则。首先在子类局部范围找，其次是从子类成员范围找，最后从父类成员范围找，如果都没有就报错（不考虑父亲的父亲）

三、super关键字

1. this && super关键字：
this代表的是本类对象的引用，而super代表的是父类存储空间的表示（可以理解为父类对象的引用）

2. this和super的使用
this.成员变量—访问本类成员变量
super.成员变量----访问父类成员变量
this.成员方法—访问本类成员变量
super.成员方法----访问父类成员方法
this(…)----访问本类构造方法
super(…)----访问父类构造方法

四、继承中构造方法的访问特点

注意：子类中所有的构造方法默认都会访问父类中无参的构造方法
子类会继承父类中的数据，可能还会使用父类的数据。所以，子类初始化之前，一定要先完成父类数据的初始化，原因在于，每一个子类构造方法的第一条语句默认都是super().

问题：如果父类中没有无参构造方法，只有带参构造方法，该怎么办呢？
1.通过使用super关键字去显示的调用父类的带参构造方法
2.子类通过this去调用本类的其他构造方法，本类其他构造方法再通过super去手动调用父类的带参的构造方法。

注意：this(…)super(…) 必须放在构造方法的第一行有效语句，并且二者不能共存

五、方法重写

1、方法重写概念 子类出现了和父类中一模一样的方法声明（方法名一样，参数列表也必须一样）
2、方法重写的应用场景 当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法，这样，即沿袭了 父类的功能，又定义了子类特有的内容
3、Override注解 用来检测当前的方法，是否是重写的方法，起到【校验】的作用

六、方法重写的注意事项

1.私有方法不能被重写（父类私有成员子类是不能被继承的）
2.子类方法访问权限不能更低(public > 默认 > 私有)。
3.静态方法不能被重写，如果子类也有相同的方法，并不是重写父类的方法。

七、权限修饰符

八、抽象类

1.抽象类的概述
当我们在做子类共性功能抽取时，有些方法在父类中并没有具体的体现，这个时候就需要抽象类了！！
在Java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类就必须定义为抽象类。

2.抽象类的特点
2.1 抽象类和抽象方法必须使用abstract关键字修饰

2.2 抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类
2.3 抽象类不能实例化
2.4 抽象类可以有构造方法
2.5 抽象类的子类要么重写抽象类中的所有抽象方法，要么是抽象类

九、模板设计模式

1.设计模式
设计模式是一套被反复使用、多数人知晓的、经过分类、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性、程序的重用性。

2.模板设计模式
把抽象类整体就可以看做成一个模板，模板中不能决定的东西定义成抽象方法。让使用模板的类（继承抽象类的类）去重写抽象方法实现需求。

3.模板设计模式的优势
模板已经定义了通用结构，使用者只需要关心自己需要实现的功能即可。

十、final关键字

1.final关键字的作用
final代表最终的意思，可以修饰成员方法、成员变量和类。

2.final修饰类、方法、变量的效果
2.1 final修饰类：该类不能被继承（不能有子类，但是可以有父类）。
2.2 final修饰方法：该方法不能被重写。
2.3 final修饰变量：表明该变量是一个常量，不能再次赋值。
注意：变量是基本类型，不能改变的是值；变量是引用数据类型，不能改变的是地址值，但地址里面的内容是可以改变的。

十一、代码块

1. 代码块概述
在Java中，使用{}括起来的代码被称为代码块

2.代码块分类
2.1 局部代码块
位置：方法中定义
作用：限定变量的生命周期，及早释放，提高内存利用率

2.2 构造代码块
位置：类中方法外定义
特点：每次构造方法执行时，都会执行该代码块中的代码，并且在构造方法执行前执行。
作用：将多个构造方法中相同的代码，抽取到构造代码块中，提高代码的复用性。

2.3 静态代码块
位置：类中方法外定义
特点：需要通过static关键字修饰，随着类的加载而加载，并且只执行一次
作用：在类假造的时候做一些数据初始化的操作

十二、接口的特点

2. 接口的成员特点
2.1 成员特点
成员变量：只能是常量，默认修饰符是：public static final
构造方法：没有，因为接口主要是扩展功能的，而没有具体存在
成员方法：只能是抽象方法，默认修饰符是：public abstract

3. 类和接口的关系

十三、Java8以后接口中一些方法的更新

1. 接口中默认方法（应用）
格式：public default 返回值类型 方法名（参数列表）{ }
作用：解决接口升级的问题
范例：public default void show3() { }
注意事项：
1.1 默认方法不是抽象方法，所以不强制被重写，但是可以被重写，重写的时候去掉default关键字
1.2 public可以省略，default不能省略
1.3 如果实现了多个接口，多个接口中存在相同的方法申明，子类就必须对该方法进行重写

2. 接口中的静态方法
格式：public static 返回值类型 方法名(参数列表) { }
范例：public static void show() { }
注意事项：
静态方法只能通过接口名调用，不能通过实现类名或者对象名调用
public可以省略，static不能省略

3. 接口中的私有方法

3.1 私有方法产生原因
Java9中新增了带方法体的私有方法，这其实在Java8中就埋下了伏笔；Java8允许在接口中定义带方法体的默认方法和静态方法。这样可能就会引发一个问题：当两个默认方法或者静态方法中包含一段相同的代码实现时，程序必然考虑将这段实现代码抽取成一个共性方法，而这个共性方法是不需要让别人使用的，因此用私有给隐藏起来，这就是Java9增加私有方法的必然性。

注意事项：
默认方法可以调用私有的静态方法和非静态方法。
默认方法只能调用私有的静态方法。

十四、多态

1. 多态的概念
什么是多态：同一个对象在不同时刻变现出来不同的形态。
多态的前提：
要有继承或实现关系
要有方法的重写
要有父类引用指向子类对象

2. 多态中成员访问特点
成员访问特点：
成员变量：编译看父类，运行看父类
成员方法：编译看父类，运行看子类

3. 多态的好处和弊端
好处：提高了程序的扩展性。定义方法的时候，只用父类型作为参数，在使用的时候，使用具体子类的类型参与操作。
弊端：不能使用子类的特有成员

4. 多态中的转型
向上转型：父类引用指向子类对象就是向上转型
向下转型：子类型 对象名 = （子类型）父类引用

5. 多态中转型存在的风险和解决方法
风险：如果被转的应用类型变量对应的实际类型和目标类型不是同一种类型，那么在转换的时候就会出现ClassCastException。
解决方案：
关键字：instanceof
使用格式：变量名 instanceof 类型
通俗的理解：判断关键字左边的变量，是否是右边的类型，返回boolean类型结果

十五、内部类的基本使用

1.内部类的基本使用
内部类概念：在一个类中定义一个类。举例：在一个类A的内部定义一个类B，类B就被称为内部类。
内部类的定义格式：

内部类的访问特点：
内部列可以直接访问外部类的成员，包括私有。
外部类要访问内部类的成员，必须创建对象。

2. 成员内部类
成员内部类的定义位置：在类中方法，跟成员变量是一个位置
外界创建成员内部类格式：
格式：外部类名.内部类名 对象名 = 外部类对象.内部类对象;
举例：Outer.Inner oi = new Outer().new Inner();
私有成员内部类：
将一个类，设计为内部类的目的是，大多数都是不想让外界去访问，所以内部类的定义应该私有化，私有化之后，再提供一个可以让外界调用的方法，方法内创建内部类对象并调用。

3. 静态成员内部类
静态成员内部类访问格式：外部类名.内部类名 对象名 = new 外部类名.内部类名();
静态成员内部类中的静态方法：外部类名.内部类名.方法名();

4. 局部内部类
局部内部类定义位置：局部内部类是在方法中定义的类
局部内部类的方式方法：
局部内部类，外界是无法直接使用的，需要在方法内部创建对象并使用
该类可以直接访问外部类的成员，也可以访问方法内的局部变量。

5. 匿名内部类
匿名内部类的前提：存在一个类或者接口，这里的类可以是具体类
匿名内部类的格式：
格式：new 类名 ( ) { 重写方法 } 或者 new 接口名 ( ) { 重写方法 }
举例：new Inter(){ @Override public void method(){} }
匿名内部类的实质：是一个继承了该类或者实现了该接口的子类匿名对象。

6. 匿名内部类在开发中的使用
匿名类在开发中的使用：当发现某个方法需要接口或者抽象类的子对象，我们就可以传递一个匿名内部类过去，来简化传统的代码。

十六、Lambda表达式

1. 代码演示

函数式编程思想概述
在数学中，函数就是有输入量，输出量的一套计算方案，也就是“拿数据做操作”。面向对象思想强调的是“必须通过对象的形式来做事情”。
函数式编程思想则尽量忽略面向对象的复杂语法：强调做什么，而不是以什么形式去做。而我们要学习的Lambda表达式就是函数式思想的体现。

2. Lambda表达式的标准格式
2.1 格式：（形式参数）->（代码块）
形式参数：如果有多个参数，参数之间使用逗号隔开；如果没有参数，留空即可
-> ：由英文中画线和大于符号组成，固定写法。代表指向动作
代码块：是我们具体要做到事情，也就是以前我们写的方法体内容
2.2 组成Lambda表达式的三要素：形式参数、箭头和代码块

3. Lambda表达式使用前提
有一个接口并且接口中有且仅有一个抽象方法

4. 练习描述：无参数无返回值的抽象方法的联系

操作步骤定义一个接口(Eatable)，里面定义一个抽象方法：void eat(); 定义一个测试类(EatableDemo)，在测试类中提供两个方法 一个方法是：useEatable(Eatable e) 一个方法是主方法，在主方法中调用useEatable方法

5. Lambda表达式练习2

练习描述 有参无返回值抽象方法的练习

操作步骤定义一个接口(Flyable)，里面定义一个抽象方法：void fly(String s); 定义一个测试类(FlyableDemo)，在测试类中提供两个方法 一个方法是：useFlyable(Flyable f) 一个方法是主方法，在主方法中调用useFlyable方法

6. Lambda表达式练习3

练习描述 有参有返回值抽象方法的练习

操作步骤定义一个接口(Addable)，里面定义一个抽象方法：int add(int x,int y); 定义一个测试类(AddableDemo)，在测试类中提供两个方法 一个方法是：useAddable(Addable a) 一个方法是主方法，在主方法中调用useAddable方法

7. Lambda表达式的省略模式

省略的规则：
参数类型可以省略；但是在有多个参数的情况下，不能只省略一个
如果参数有且仅有一个，那么小括号可以省略
如果代码块的语句只有一条，可以省略大括号和分号，以及return语句

十七、Lambda表达式和匿名内部类的区别

1. 所需类型不同
匿名内部类：可以是接口，也可以是抽象类，还可以是具体类
Lambda表达式：只能是接口

2. 使用限制不同
如果接口中有且仅有一个抽象方法，可以使用Lambda表达式，也可以使用匿名内部类。
如果接口中多于一个抽象方法，只能使用匿名内部类，而不能使用Lambda表达式。

3. 实现原理不同
匿名内部类：编译之后，产生一个单独的.class 字节码文件
Lambda表达式：编译之后，没有一个单独的.class字节码文件，对应的字节码会在运行的时候动态生成。