目录
一.继承
1.定义：
2.继承的语法：
3.子类访问父类
4.子类构造方法
5.super与this
6.继承方法
7.final关键字
（1）.变量不变
（2）.方法不变
（3）.类不可继承
8.继承与组合
二.多态
1.概念：
2.实现条件
3.重写
4.向上转移和向下转型
（1）.向上转移
（2）.向下转型（不安全没必要用，因为一个儿子可以推出一个父亲，而父亲不一定只有一个儿子）
一.继承
1.定义：
面向对象思想中提出了继承的概念，专门用来进行共性抽取，实现代码复用（作用简化代码） 。其中子类/派生类（继承者）还可以在父类/基类/超类（被继承者）的基础上进行添加。
2.继承的语法：
修饰符 class 子类 extends 父类 {
// ...
}
注意：
（1）. 子类会将父类中的成员变量或者成员方法继承到子类中了
（2）. 子类继承父类之后，必须要新添加自己特有的成员，体现出与基类的不同，否则就没有必要继承了
3.子类访问父类
在继承体系中，子类将父类中的方法和字段继承下来了
（1）.子父类无相同的成员变量可直接访问
public class Base {
int a;
int b;
}
public class Derived extends Base{
int c;
public void method(){
a = 10; // 访问从父类中继承下来的a
b = 20; // 访问从父类中继承下来的b
c = 30; // 访问子类自己的c
}
}（2）.具有相同成员变量名字且变量类型相同，使用子类优先访问子类成员变量。倘若只是变量类型不同则报错。
（3）.子类访问父类且具有相同成员变量名字且变量类型相同，此时需要super关键字。在子类中当使用父类变量时在变量前面加上super。
总结：
在子类方法中 或者 通过子类对象访问成员时 ：
如果访问的成员变量子类中有，优先访问自己的成员变量。
如果访问的成员变量子类中无，则访问父类继承下来的，如果父类也没有定义，则编译报错。
如果访问的成员变量与父类中成员变量同名，则优先访问自己的。
成员变量访问遵循就近原则，自己有优先自己的，如果没有则向父类中找。
4.子类构造方法
子类对象构造时， 需要先调用基类构造方法 ，然后执行子类的构造方法。
public class Base {
public Base(){
System.out.println("Base()");
}
}
public class Derived extends Base{
public Derived(){
// super();
System.out.println("Derived()");
}
}
public class Test {
public static void main(String[] args) {
Derived d = new Derived();
}
}
结果打印：
Base()
Derived()注意子类构造方法中默认会调用基类的无参构造方法：super(),用户没有写时,编译器会自动添加，而且super()必须是子类构造方法中第一条语句，并且只能出现一次
5.super与this
this用于当前对象的构造方法，也代表当前成员变量与方法的引用
super用于当前对象父类的构造方法，也代表当前成员父类变量与方法的引用
当进行子类构造方法时第一行必须时先调用父类构造，也就意味着子类构造方法第一行写super（），所以super与this不能同时存在（因为两者都是要写在第一行的）。
两者只能在类的非静态方法中使用，用来访问非静态成员方法和字段
6.初始化时代码执行顺序
优先父类+优先静态再实例再普通代码块=夫静态--子静态--夫实例--子实例--普通代码块。
（静态代码块只执行一次）
class Person {
public String name;
public int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
System.out.println("Person：构造方法执行");
}
{
System.out.println("Person：实例代码块执行");
}
static {
System.out.println("Person：静态代码块执行");
}
}
class Student extends Person{
public Student(String name,int age) {
super(name,age);
System.out.println("Student：构造方法执行");
}
{
System.out.println("Student：实例代码块执行");
}
static {
System.out.println("Student：静态代码块执行");
}
}
public class TestDemo4 {
public static void main(String[] args) {
Student student1 = new Student("张三",19);
System.out.println("===========================");
Student student2 = new Student("gaobo",20);
}
public static void main1(String[] args) {
Person person1 = new Person("bit",10);
System.out.println("============================");
Person person2 = new Person("gaobo",20);
}
}
结果：
Person ：静态代码块执行
Student ：静态代码块执行
Person ：实例代码块执行
Person ：构造方法执行
Student ：实例代码块执行
Student ：构造方法执行
===========================
Person ：实例代码块执行
Person ：构造方法执行
Student ：实例代码块执行
Student ：构造方法执行
总结：
结论：
1 、父类静态代码块优先于子类静态代码块执行，且是最早执行
2 、父类实例代码块和父类构造方法紧接着执行
3 、子类的实例代码块和子类构造方法紧接着再执行
4 、第二次实例化子类对象时，父类和子类的静态代码块都将不会再执行
6.继承方法
一般有 单层继承（一父一子），多层继承（一父多子），不同类继承同一个类。
但是不存在多继承（多父一子）。一般三层继承始终。
7.final关键字
用于修饰成员变量和方法与类使其变成常量与不能改变方法和不能继承类
（1）.变量不变
final int a = 10;
a = 20; // 编译出错（2）.方法不变
方法不可被重写
（3）.类不可继承
final public class Animal {
...
}
public class Bird extends Animal {
...
}
// 编译出错
Error:(3, 27) java: 无法从最终com.bit.Animal进行继8.继承与组合
定义：和继承类似, 组合也是一种表达类之间关系的方式, 也是能够达到代码重用的效果。组合并没有涉及到特殊的语法 (诸如 extends 这样的关键字), 仅仅是将一个类的实例作为另外一个类的字段。
举例：继承表示对象之间是is-a的关系，比如：狗是动物，猫是动物 组合表示对象之间是has-a的关系，比如：汽车
列举使用：
// 轮胎类
class Tire{
// ...
}
// 发动机类
class Engine{
// ...
}
// 车载系统类
class VehicleSystem{
// ...
}
class Car{
private Tire tire; // 可以复用轮胎中的属性和方法
private Engine engine; // 可以复用发动机中的属性和方法
private VehicleSystem vs; // 可以复用车载系统中的属性和方法
// ...
}
// 奔驰是汽车
class Benz extend Car{
// 将汽车中包含的：轮胎、发送机、车载系统全部继承下来
} 建议：组合和继承都可以实现代码复用，应该使用继承还是组合，需要根据应用场景来选择，一般能用组合尽量用组合。
二.多态
1.概念：
具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态。
2.实现条件
1. 必须在继承体系下
2. 子类必须要对父类中方法进行重写
3. 通过父类的引用调用重写的方法
3.重写
重写(override)：也称为覆盖。重写是子类对父类非静态、非private修饰，非final修饰，非构造方法等的实现过程 进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。
【 方法重写的规则 】
（1）.子类在重写父类的方法时，一般必须与父类方法原型一致： 返回值类型 方法名 ( 参数列表 ) 要完全一致
（2）.被重写的方法返回值类型可以不同，但是必须是具有父子关系的
（3）.访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类方法被public 修饰，则子类中重写该方法就不能声明为 protected
（4）.父类被static 、 private 修饰的方法、构造方法都不能被重写。
（5）.重写的方法, 可以使用 @Override 注解来显式指定 . 有了这个注解能帮我们进行一些合法性校验 . 例如不小心
（6）.将方法名字拼写错了 ( 比如写成 aet), 那么此时编译器就会发现父类中没有 aet 方法 , 就会编译报错 , 提示无法 构成重写
总结：
object是所有类的父类。
4.向上转移和向下转型
（1）.向上转移
向上转型：实际就是创建一个子类对象，将其当成父类对象来使用。
语法格式：父类类型 对象名 = new 子类类型 ()
使用场景：
直接使用
Animal animal = new Cat ( " 元宝 " , 2 );
animal 是父类类型，但可以引用一个子类对象，因为是从小范围向大范围的转换。
方法传参
方法返回
public class TestAnimal {
// 2. 方法传参：形参为父类型引用，可以接收任意子类的对象
public static void eatFood(Animal a){
a.eat();
}
// 3. 作返回值：返回任意子类对象
public static Animal buyAnimal(String var){
if("狗".equals(var) ){
return new Dog("狗狗",1);
}else if("猫" .equals(var)){
return new Cat("猫猫", 1);
}else{
return null;
}
}
public static void main(String[] args) {
Animal cat = new Cat("元宝",2); // 1. 直接赋值：子类对象赋值给父类对象
Dog dog = new Dog("小七", 1);
eatFood(cat);
eatFood(dog);
Animal animal = buyAnimal("狗");
animal.eat();
animal = buyAnimal("猫");
animal.eat();
}
}优点:代码实现灵活。
缺点：不能调用子类特有的方法只能用重写方法。
（2）.向下转型（不安全没必要用，因为一个儿子可以推出一个父亲，而父亲不一定只有一个儿子）
将父类引用强转再还原为子类对象即可，即向下转换。
如果判断向下转型中父类引用的子类对象是否为我们向下转型的子类对象（如果不是报上述图片错）时用关键字instanceof
if (parent instanceof Child) {Child child2 = (Child) parent;// 现在可以安全地使用 child2 引用来访问 Child 类的方法和属性
}
