(1)是最终的意思，可以修饰类，方法，变量。
(2)特点：
A:它修饰的类，不能被继承。
B:它修饰的方法，不能被重写。
C:它修饰的变量，是一个常量。
A:局部变量 a:基本类型 值不能发生改变 b:引用类型 地址值不能发生改变，但是对象的内容是可以改变的 B:初始化时机 a:只能初始化一次。 b:在构造方法完毕前。(非静态的常量) c:常见的给值 定义的时候。(推荐) final int num = 30; 构造方法中。
2:多态
(1)同一个对象在不同时刻体现出来的不同状态。
(2)多态的前提：
A:有继承或者实现关系。
B:有方法重写。
C:有父类或者父接口引用指向子类对象。
多态的分类： a:具体类多态 class Fu {} class Zi extends Fu {} Fu f = new Zi(); b:抽象类多态 abstract class Fu {} class Zi extends Fu {} Fu f = new Zi(); c:接口多态 interface Fu {} class Zi implements Fu {} Fu f = new Zi();
(3)多态中的成员访问特点
A:成员变量 编译看左边，运行看左边 B:构造方法 子类的构造都会默认访问父类构造 C:成员方法 编译看左边，运行看右边 D:静态方法 编译看左边，运行看左边 (静态和类相关，算不上重写，所以，访问还是左边的) 为什么? 因为成员方法有重写。
(4)多态的好处：
A:提高代码的维护性(继承体现)
B:提高代码的扩展性(多态体现)
(5)多态的弊端： 父不能使用子的特有功能。 现象： 子可以当作父使用，父不能当作子使用。
(6)多态中的转型
A:向上转型 从子到父 Fu f = new Zi();
B:向下转型 从父到子 Zi z = (Zi) f;
多态继承中的内存图解
多态中的对象变化内存图解
(8)多态的练习
A:猫狗案例
1 /*
2 多态练习：猫狗案例
3 */
4 class Animal {
5 public void eat(){
6 System.out.println("吃饭");
7 }
8 }
9
10 class Dog extends Animal {
11 public void eat() {
12 System.out.println("狗吃肉");
13 }
14
15 public void lookDoor() {
16 System.out.println("狗看门");
17 }
18 }
19
20 class Cat extends Animal {
21 public void eat() {
22 System.out.println("猫吃鱼");
23 }
24
25 public void playGame() {
26 System.out.println("猫捉迷藏");
27 }
28 }
29
30 class DuoTaiTest {
31 public static void main(String[] args) {
32 //定义为狗
33 Animal a = new Dog();
34 a.eat();
35 System.out.println("--------------");
36 //还原成狗
37 Dog d = (Dog)a;
38 d.eat();
39 d.lookDoor();
40 System.out.println("--------------");
41 //变成猫
42 a = new Cat();
43 a.eat();
44 System.out.println("--------------");
45 //还原成猫
46 Cat c = (Cat)a;
47 c.eat();
48 c.playGame();
49 System.out.println("--------------");
50
51 //演示错误的内容
52 //Dog dd = new Animal();
53 //Dog ddd = new Cat();
54 //ClassCastException
55 //Dog dd = (Dog)a;
56 }
57 }
3:抽象类
(1)把多个共性的东西提取到一个类中，这是继承的做法。
但是呢，这多个共性的东西，在有些时候，方法声明一样，但是方法体。 也就是说，方法声明一样，但是每个具体的对象在具体实现的时候内容不一样。 所以，我们在定义这些共性的方法的时候，就不能给出具体的方法体。 而一个没有具体的方法体的方法是抽象的方法。 在一个类中如果有抽象方法，该类必须定义为抽象类
(2)抽象类的特点
A:抽象类和抽象方法必须用关键字abstract修饰
B:抽象类中不一定有抽象方法,但是有抽象方法的类一定是抽象类
C:抽象类不能实例化
D:抽象类的子类
a:是一个抽象类。
b:是一个具体类。这个类必须重写抽象类中的所有抽象方法。
(3)抽象类的成员特点：
A:成员变量 有变量，有常量
B:构造方法 有构造方法
C:成员方法 有抽象，有非抽象
(5)抽象类的几个小问题
A:抽象类有构造方法，不能实例化，那么构造方法有什么用? 用于子类访问父类数据的初始化
B:一个类如果没有抽象方法,却定义为了抽象类，有什么用? 为了不让创建对象
C:abstract不能和哪些关键字共存
a:final 冲突 final表示最终方法不能被修改，抽象方法必须要重写（冲突）
b:private 冲突 private私有化，不能被子类访问无法重写 （冲突）
c:static 无意义 因为一个abstract方法没有方法体。静态方法需要对方法体执行内容分配空间 所以不能同static共存；（abstract是没有实现的，不能产生对象，而是static是属于类的，类本身是已经存在的对象）
4:接口
(1)回顾猫狗案例，它们仅仅提供一些基本功能。 比如：猫钻火圈，狗跳高等功能，不是动物本身就具备的， 是在后面的培养中训练出来的，这种额外的功能，java提供了接口表示。
(2)接口的特点：
A:接口用关键字interface修饰 interface 接口名 {}
B:类实现接口用implements修饰 class 类名 implements 接口名 {}
C:接口不能实例化 D:接口的实现类
a:是一个抽象类。
b:是一个具体类，这个类必须重写接口中的所有抽象方法。
(3)接口的成员特点：
A:成员变量 只能是常量 默认修饰符：public static final
B:构造方法 没有构造方法
C:成员方法 只能是抽象的 默认修饰符：public abstract
(4)类与类,类与接口,接口与接口
A:类与类 继承关系，只能单继承，可以多层继承
B:类与接口 实现关系，可以单实现，也可以多实现。 还可以在继承一个类的同时，实现多个接口
C:接口与接口 继承关系，可以单继承，也可以多继承
(5)抽象类和接口的区别(自己补齐)?
A:成员区别 抽象类： 成员变量：可以变量，也可以常量 构造方法：有 成员方法：可以抽象，也可以非抽象 接口： 成员变量：只可以常量 成员方法：只可以抽象
构造方法：没有
B:关系区别:
a:类与类 继承关系，只能单继承，可以多层继承
b:类与接口 实现关系，可以单实现，也可以多实现。 还可以在继承一个类的同时，实现多个接口
c:接口与接口 继承关系，可以单继承，也可以多继承
C:设计理念不同 抽象类：is a，抽象类中定义的是共性功能。 接口：like a，接口中定义的是扩展功能。
来源：https://www.cnblogs.com/zun-/p/9304014.html