java——继承

一.继承

1.1继承的概念

继承(inheritance)机制：是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加新功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构， 体现了由简单到复杂的认知过程。继承主要解决的问题是：共性的抽取，实现代码复用。
从继承的概念可以看出继承的最大作用是：实现代码复用，以及下一篇博客要讲的多态。

1.2继承的语法

在java中表示类之间的继承关系，需要记住extends关键字

class Animal{
    public int age;
    public String name;

    public void eat(){
        System.out.println(this.name+"正在吃饭");
    }
}

class Cat extends Animal{//Cat继承Animal类
    void mew(){
        System.out.println(this.name+"喵喵喵");
    }
}

class Dog extends Animal{//Dog继承Animal类
    void barks(){
        System.out.println(this.name+"汪汪汪");
    }
}
public class Demo {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.name="大白";//name是从Animal中继承来的
        cat.eat();//eat方法是从Animal中继承来的
        cat.mew();//Cat类中新增的mew方法

        Dog dog = new Dog();
        dog.name="大黄";//name是从Animal中继承来的
        dog.eat();//eat方法是从Animal中继承来的
        dog.barks();//Dog类中新增的barks方法

    }
}

此时Cat和Dog 就继承了Animal的age name变量和eat方法
注意：子类继承父类之后，必须添加新的自己特有的成员，否则没有必要继承。

1.3父类成员的访问

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

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.子类和父类成员变量重名

public class Base {
  int a;
  int b;
  int c;
  int d;
}
/
public class Derived extends Base{
  int a;        // 与父类中成员a同名，且类型相同
  char b;       // 与父类中成员b同名，但类型不同
  String d;
  public void method(){
    a = 100;     // 访问子类的a
    b = 101;     // 访问子类的b
    c = 102;     // 子类没有c，访问的肯定是从父类继承下来的c
    //d=103;     //报错，子类的d为String类型，无法赋值int型数字
 }
}

在子类方法中 或者 通过子类对象访问成员时：
1.如果访问的成员变量子类中有，优先访问自己的成员变量。
2.如果访问的成员变量子类中无，则访问父类继承下来的，如果父类也没有定义，则编译报错。
3.如果访问的成员变量与父类中成员变量同名，则优先访问自己的，即：子类将父类同名成员隐藏了。（可见上述代码的d）

成员变量访问遵循就近原则，自己有优先自己的，如果没有则向父类中找。

1.3.2子类访问父类的成员方法

1.成员方法名字不同

public class Base {
public void methodA(){
  System.out.println("Base中的methodA()");
}
}
public class Derived extends Base{
  public void methodB(){
    System.out.println("Derived中的methodB()方法");
 }
 
  public void methodC(){
    methodB();     // 访问子类自己的methodB()
    methodA();     // 访问父类继承的methodA()
 }
}

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

2.成员方法名字相同

public class Base {
public void methodA(){
  System.out.println("Base中的methodA()");
}
public void methodB(){
  System.out.println("Base中的methodB()");
}
}
public class Derived extends Base{
  public void methodA(int a) {
    System.out.println("Derived中的method(int)方法");
 }
  public void methodB(){
    System.out.println("Derived中的methodB()方法");
 }
  public void methodC(){
    methodA();    // 没有传参，访问父类中的methodA()
    methodA(20);   // 传递int参数，访问子类中的methodA(int)
    methodB();    // 直接访问，则永远访问到的都是子类中的methodB()，基类的无法访问到
 }
}

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

2.通过派生类对象访问父类与子类同名方法时，如果父类和子类同名方法的参数列表不同(重载)，根据调用方法适传递的参数选择合适的方法访问，如果没有则报错；如果父类和子类同名方法的原型一致(重写——下一篇多态会讲)，则只能访问到子类的，父类的无法通过派生类对象直接访问到。

1.4super关键字

子类和父类中可能会存在相同名称的成员，如果要在子类方法中访问父类同名成员时，直接访问是无法做到的，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. 在子类方法中，访问父类的成员变量和方法

1.5子类构造方法

先有父再有子，子类对象构造时，要先调用父类的构造方法，在执行子类的构造方法。

public class Base {
public Base(){
    System.out.println("Base()");
}
}
public class Derived extends Base{
 public Derived(){
   // super();  // 注意子类构造方法中默认会调用基类的无参构造方法：super(),
   // 用户没有写时,编译器会自动添加，而且super()必须是子类构造方法中第一条语句，
   // 并且只能出现一次
   System.out.println("Derived()");
 }
}
public class Test {
  public static void main(String[] args) {
    Derived d = new Derived();
 }
}
结果打印：
Base()
Derived()

在子类构造方法中，并没有写任何关于基类构造的代码，但是在构造子类对象时，先执行基类的构造方法，然后执行子类的构造方法，因为：子类对象中成员是有两部分组成的，基类继承下来的以及子类新增加的部分 。父子父子肯定是先有父再有子，所以在构造子类对象时候 ，先要调用基类的构造方法，将从基类继承下来的成员构造完整，然后再调用子类自己的构造方法，将子类自己新增加的成员初始化完整 。

注:
1.若父类是无参的构造方法或默认的构造方法，则子类构造方法第一行有默认隐含的super()调用构造方法.
2.如果父类的构造方法有参数，则此时编译器不会给子类生成默认的的构造方法，此时需要用户显示定义子类的构造方法，并在子类构造方法中选则合适的父类构造方法调用，否则定义失败。
3.在子类构造方法中，super(…)调用父类构造方法，必须在子类构造方法第一行。
4.super(…)在子类构造方法中只能出现一次，并且不能和this(…)同时出现。

1.6super和this

相同点：
1.都是java的关键字
2.都只能在非静态方法中使用，用来访问非静态成员方法和字段
3.在构造方法调用时，都必须时构造方法的第一句，且不能同时出现。

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

1.7 谈谈初始化

来看一下实例代码块和静态代码块在继承中的执行顺序。

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.第二次实例化子类对象时，父类和子类的静态代码块都将不会再执行

1.8protected关键字

多余的不做赘述，见图即可。
注：父类的private变量在子类无法访问，但也被继承到子类了。

1.9继承方式

java不支持多继承，即一个子类有多个父类。

1.9 final关键字

final关键字可以用来修饰 变量 方法 类
1.final 修饰 变量，表示常量（不能修改）

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

2.final 修饰方法，表示方法不能重写
3.final修饰类，表示类不能被继承

2.0 继承和组合

先简单描述一下：
继承表示对象之间是is-a的关系，比如：狗是动物，猫是动物
组合表示对象之间是has-a的关系，比如：汽车