【JavaSE】-- 继承

1. 为什么需要继承

Dog类：

public class Dog {public String name;public  int age;public String color;public void eat(){System.out.println(this.age + "正在吃饭......");}public void bark(){System.out.println(this.name + "正在汪汪叫.....");}public Dog(String name, int age, String color) {this.name = name;this.age = age;this.color = color;}@Overridepublic String toString() {return "Dog{" +"name='" + name + '\'' +", age=" + age +", color='" + color + '\'' +'}';}
}

Bird类：

public class Bird {public String name;public int age;public String color;public void eat(){System.out.println(this.name + "正在吃饭.....");}public void fly(){System.out.println(this.name + "正在飞.....");}public Bird(String name, int age, String color) {this.name = name;this.age = age;this.color = color;}@Overridepublic String toString() {return "Bird{" +"name='" + name + '\'' +", age=" + age +", color='" + color + '\'' +'}';}
}

可以看到这两个类有很多共同的属性，name、age、color、eat()。

这个时候就提出了继承的概念，专门用来进行共性抽取，实现代码的复用。

2. 继承的概念

上述图示中，Dog和Cat都继承了Animal类，其中：Animal类称为父类/基类或超类，Dog和Cat可以称为Animal的子类/派生类，继承之后，子类可以复用父类中成员，子类在实现时只需关心自己新增加的成员即可。

从继承概念中可以看出继承最大的作用就是：实现代码复用，还有就是来实现多态。

3. 继承的语法

修饰符 class 子类 extends 父类 {
// ... 
}

---

使用继承后的代码：

Animal类：

public class Animal {public String name;public int age;public String color;public void eat(){System.out.println(this.name + "正在吃饭.....");}
}

Bird类：

public class Bird extends Animal{public void fly(){System.out.println(this.name + "正在飞.....");}public Bird(String name, int age, String color) {this.name = name;this.age = age;this.color = color;}@Overridepublic String toString() {return "Bird{" +"name='" + name + '\'' +", age=" + age +", color='" + color + '\'' +'}';}
}

Dog类：

public class Dog extends Animal{public void bark(){System.out.println(this.name + "正在汪汪叫.....");}public Dog(String name, int age, String color) {this.name = name;this.age = age;this.color = color;}@Overridepublic String toString() {return "Dog{" +"name='" + name + '\'' +", age=" + age +", color='" + color + '\'' +'}';}
}

4. 父类成员访问

---

4.1 子类中访问父类的成员变量

1. 子类和父类不存在同名成员变量

Base类：

public class Base {public int a;public int b;
}

Derived类：

public class Derived extends Base{public int c;public void method(){System.out.println(a + " ," + b + " ," + c);}
}

2. 子类和父类成员变量同名

Base类：

public class Base {public int a = 100;public int b = 200;
}

Derived类：

public class Derived extends Base{public int a = 101;public int c = 201;public void method(){System.out.println(a + " ," + b + " ," + c);}
}

Test类：

public class Test {public static void main(String[] args) {Derived derived = new Derived();derived.method();System.out.println(derived.a);}
}

输出结果：111 ,333 ,100111

当在继承关系中，父类 和 子类出现了同名的成员变量的时候，在子类当中，如果不做指定，默认访问的是子类自己的。当子类不存在该成员变量时，才去父类找，如果父类也没有，则编译报错。（体现子类优先被访问）

4.2 子类中访问父类的成员方法

1. 成员方法名字不同

Base类：

public class Base {public int a = 110;public int b = 333;public void method(){System.out.println("父类method()方法........");}
}

Derived类：

public class Derived extends Base{public int a = 111;public int c = 100;public void method1(){System.out.println("子类method1()方法........");}
}

Test类：

public class Test {public static void main(String[] args) {Derived derived = new Derived();derived.method1();derived.method();}
}

输出结果：子类method1()方法........父类method()方法........

总结：成员方法没有同名时，在子类方法中或者通过子类对象访问方法时，则优先访问自己的，自己没有时
再到父类中找，如果父类中也没有则报错。
2. 成员方法名字相同

Base类：

public class Base {public int a = 110;public int b = 333;public void method(){System.out.println("父类method()方法........");}
}

Derived类：

public class Derived extends Base{public int a = 111;public int c = 100;public void method1(){System.out.println(a + " ," + b + " ," + c);}public void method(){System.out.println("子类method()方法........");}
}

Test类：

public class Test {public static void main(String[] args) {Derived derived = new Derived();derived.method();}
}

  输出结果：子类method()方法........

【说明】

• 通过子类对象访问父类与子类中不同名方法时，优先在子类中找，找到则访问，否则在父类中找，找到则访问，否则编译报错。

• 通过派生类对象访问父类与子类同名方法时，如果父类和子类同名方法的参数列表不同(重载)，根据调用方法适传递的参数选择合适的方法访问，如果没有则报错；

问题：如果子类中存在与父类中相同的成员时，那如何在子类中访问父类相同名称的成员呢？

5. super关键字

由于设计不好，或者因场景需要，子类和父类中可能会存在相同名称的成员，如果要在子类方法中访问父类同名成员时，该如何操作？直接访问是无法做到的，Java提供了 super关键字，该关键字主要作用：在子类方法中访问父类的成员。

public class Base {int a;int b;public void methodA(){System.out.println("Base中的methodA()");}public void methodB(){System.out.println("Base中的methodB()");}
}public class Derived extends Base{int a; // 与父类中成员变量同名且类型相同char b; // 与父类中成员变量同名但类型不同// 与父类中methodA()构成重载public void methodA(int a) {System.out.println("Derived中的method()方法");}// 与基类中methodB()构成重写(即原型一致，重写后序详细介绍)public void methodB(){System.out.println("Derived中的methodB()方法");}public void methodC(){
// 对于同名的成员变量，直接访问时，访问的都是子类的a = 100; // 等价于： this.a = 100;b = 101; // 等价于： this.b = 101;
// 注意：this是当前对象的引用
// 访问父类的成员变量时，需要借助super关键字
// super是获取到子类对象中从基类继承下来的部分super.a = 200;super.b = 201;
// 父类和子类中构成重载的方法，直接可以通过参数列表区分清访问父类还是子类方法methodA(); // 没有传参，访问父类中的methodA()methodA(20); // 传递int参数，访问子类中的methodA(int)
// 如果在子类中要访问重写的基类方法，则需要借助super关键字methodB(); // 直接访问，则永远访问到的都是子类中的methodA()，基类的无法访问到super.methodB(); // 访问基类的methodB()}
}

【注意事项】

1. 只能在非静态方法中使用
2. 在子类方法中，访问父类的成员变量和方法

---

super只能指代当前类的父类，不能指代父类的父类，甚至更“远”。

6. 子类的构造方法

父子父子，先有父再有子，即：子类对象构造时，需要先调用父类构造方法，然后执行子类的构造方法。

Animal类:

public class Animal {public String name;public int age;public void eat(){System.out.println(this.name + "正在吃饭...");}public Animal(String name, int age) {this.name = name;this.age = age;}
}

Dog类：

public class Dog extends Animal{//当子类继承父类以后，将来一定会构造子类对象，构造子类对象一定会调用子类的构造方法.//当在构造子类对象时，从父类继承过来的name,age要进行初始化，//怎么对父类继承过来的成员变量进行初始化呢？//下面这样不初始化吗？//不算！！！！
//    public Dog(String name, int age){
//        this.name = name;
//        this.age = age;
//    }public Dog(String name, int age) {super(name, age);}public void bark(){System.out.println(this.name + "正在汪汪叫......");}}

Test类：

public class Test {public static void main(String[] args) {Dog dog = new Dog("辣条", 1);}
}

• 子类构造方法中会默认调用父类的无参构造方法：super（）；用户没有写构造方法时，编译器会自动生成一个无参的构造方法，而且super（）必须是子类构造方法中的第一条语句，并且只能出现一次。
• 在子类构造方法中，并没有写任何关于基类构造的代码，但是在构造子类对象时，先执行基类的构造方法，然后执行子类的构造方法，因为：子类对象中成员是有两部分组成的，基类继承下来的以及子类新增加的部分 。父子父子肯定是先有父再有子，所以在构造子类对象时候 ，先要调用基类的构造方法，将从基类继承下来的成员构造完整，然后再调用子类自己的构造方法，将子类自己新增加的成员初始化完整 。

注意：

1. 若父类显式定义无参或者默认的构造方法，在子类构造方法第一行默认有隐含的super()调用，即调用基类构造方法.
2. 如果父类构造方法是带有参数的，此时需要用户为子类显式定义构造方法，并在子类构造方法中选择合适的父类构造方法调用，否则编译失败。
3. 在子类构造方法中，super(…)调用父类构造时，必须是子类构造函数中第一条语句。
4. super(…)只能在子类构造方法中出现一次，并且不能和this同时出现.

7. super和this

1. this是当前对象的引用，当前对象即调用实例方法的对象，super相当于是子类对象中从父类继承下来部分成员的引用.
2. 在非静态成员方法中，this用来访问本类的方法和属性，super用来访问父类继承下来的方法和属性.
3. 在构造方法中：this(…)用于调用本类构造方法，super(…)用于调用父类构造方法，两种调用不能同时在构造方法中出现.
4. 构造方法中一定会存在super(…)的调用，用户没有写编译器也会增加，但是this(…)用户不写则没有.

8. 再谈初始化

Animal类：

public class Animal {public String name;public int age;static{System.out.println("父类静态代码块执行了.......");}{System.out.println("父类实例代码块执行了.......");}public void eat(){System.out.println(this.name + "正在吃饭...");}public Animal(String name, int age) {this.name = name;this.age = age;System.out.println("父类构造方法执行了.......");}
}

Dog类：

public class Dog extends Animal{static{System.out.println("子类静态代码块执行了.......");}{System.out.println("子类实例代码块执行了.......");}public Dog(String name, int age) {super(name, age);System.out.println("子类构造方法执行了......");}public void bark(){System.out.println(this.name + "正在汪汪叫......");}
}

Test类：

public class Test {public static void main(String[] args) {Dog dog = new Dog("辣条", 1);System.out.println("===========================");Dog dog1 = new Dog("土豆", 6);}
}

输出结果：父类静态代码块执行了.......子类静态代码块执行了.......父类实例代码块执行了.......父类构造方法执行了.......子类实例代码块执行了.......子类构造方法执行了......===========================父类实例代码块执行了.......父类构造方法执行了.......子类实例代码块执行了.......子类构造方法执行了......

通过分析执行结果，得出以下结论：

1. 静态代码块先执行，并且只执行一次，在类加载阶段执行
2. 当有对象创建时，才会执行实例代码块，实例代码块执行完成后，最后构造方法执行

1、父类静态代码块优先于子类静态代码块执行，且是最早执行
2、父类实例代码块和父类构造方法紧接着执行
3、子类的实例代码块和子类构造方法紧接着再执行
4、第二次实例化子类对象时，父类和子类的静态代码块都将不会再执行

9. protected 关键字

No	范围	private	default	protected	public
1	同一个包的同一类	√	√	√	√
2	同一个包中的不同类		√	√	√
3	不同包中的子类			√	√
4	不同包中的非子类				√

10. 继承方式

Java支持单继承、多层继承和不同类继承同一个类这三种继承方式，不支持多继承，但是我们可以通过接口来实现多继承。

一般我们不希望出现超过三层的继承关系. 如果继承层次太多, 就需要考虑对代码进行重构了.如果想从语法上进行限制继承, 就可以使用 final 关键字。

11. final 关键字

final关键可以用来修饰变量、成员方法以及类。

1. 修饰变量或字段，表示常量(即不能修改)

final int a = 10;
a = 20; // 编译出错

2. 修饰类：表示此类不能被继承

final public class Animal {
...
}
public class Bird extends Animal {
...
}// 编译出错
Error:(3, 27) java: 无法从最终com.bit.Animal进行继承。

3. 修饰方法：表示该方法不能被重写

12. 继承与组合

继承表示对象之间是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{
// 将汽车中包含的：轮胎、发送机、车载系统全部继承下来
}

一般建议：能用组合尽量用组合。