java中的继承

背景

代码中创建的类, 主要是为了抽象现实中的一些事物(包含属性和方法).
有的时候客观事物之间就存在一些关联关系, 那么在表示成类和对象的时候也会存在一定的关联. 例如, 设计一个类表示动物

注意, 我们可以给每个类创建一个单独的 java 文件. 类名必须和 .java 文件名匹配(大小写敏感).

// Animal.java
class Animal {
    public String name;

    public Animal(String name) {
        this.name = name;
    }

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

}

// Cat.java
class Cat {
    public String name;

    public Cat(String name) {
        this.name = name;
    }

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

// Bird.java
class Bird {
    public String name;

    public Bird(String name) {
        this.name = name;
    }

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

    public void fly() {
        System.out.println(this.name + "正在飞 ︿(￣︶￣)︿");
    }
}

这个代码我们发现其中存在了大量的冗余代码.
仔细分析, 我们发现 Animal 和 Cat 以及 Bird 这几个类中存在一定的关联关系:

• 这三个类都具备一个相同的 eat 方法, 而且行为是完全一样的.

• 这三个类都具备一个相同的 name 属性, 而且意义是完全一样的.

• 从逻辑上讲, Cat 和 Bird 都是一种 Animal (is - a 语义).
  此时我们就可以让 Cat 和 Bird 分别继承 Animal 类, 来达到代码重用的效果.

所以继承的意义就在于代码的重复使用.

此时, Animal 这样被继承的类, 我们称为 父类 , 基类 或 超类, 对于像 Cat 和 Bird 这样的类, 我们称为 子类, 派生类和现实中的儿子继承父亲的财产类似, 子类也会继承父类的字段和方法, 以达到代码重用的效果.

语法规则

基本语法

class 子类 extends 父类 {}

}

注意事项

• 使用 extends 指定父类.
• Java 中一个子类只能继承一个父类 (而C++/Python等语言支持多继承,java是单继承的） 当然为了解决单继承的问题，我们引入了接口.
• 子类的实例中, 也包含着父类的实例. 可以使用 super 关键字得到父类实例的引用.

面试问题

子类从父类那里到底继承了什么？

子类会继承父类的所有除构造方法外的东西
本质上子类从父类那里继承了private的字段和方法,但在子类中是无法对其访问的.

所以对于背景中的代码，我们可以使用继承的方式进行改进：
此时我们让 Cat 和 Bird 继承自 Animal 类, 那么 Cat 在定义的时候就不必再写 name 字段和 eat 方法.代码如下所示：

class Animal {
    public String name;

    public Animal(String name) {
        this.name = name;
    }

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

class Cat extends Animal {
    public Cat(String name) {
// 使用 super 调用父类的构造方法.
        super(name);
    }
}

class Bird extends Animal {
    public Bird(String name) {
        super(name);
    }
    public void fly() {
        System.out.println(this.name + "正在飞 ︿(￣︶￣)︿");
    }
}

public class Test {
    public static void main(String[] args) {
        Cat cat = new Cat("小黑");
        cat.eat("猫粮");
        Bird bird = new Bird("圆圆");
        bird.fly();
    }
}

extends 英文原意指 “扩展”. 而我们所写的类的继承, 也可以理解成基于父类进行代码上的 “扩展”.
例如我们写的 Bird 类, 就是在 Animal 的基础上扩展出了 fly 方法.

super关键字

先来看三个问题：

1. 什么是super关键字？

super关键字代表父类对象的引用
当子类继承父类的时候，首先会帮助父类进行构造

2. 怎么帮助构造？

在子类的构造方法内部，调用父类的构造方法
类似于super(）代表显示调用父类的构造方法，所以构造方法不是被继承的，而是在子类被显示调用的.

3. 如果需要在子类内部调用父类方法怎么办?

可以使用super 关键字.

super 表示获取到父类对象的引用. 涉及到三种常见用法.

super关键字常见的三种用法

用法1

使用 super关键字来调用父类的构造器方法

至于为什么要在子类的构造方法中显示调用父类的构造方法，做出如下解释：

如果子类的构造方法中没有显示的调用父类构造方法，则系统默认调用父类无参数的构造方法，此时需要注意：如果子类的构造方法中既没有显示的调用父类构造方法，父类中又没有无参的构造方法，则此时编译出错，所以如果我们在父类中没有定义无参的构造函数，而定义了有参的构造函数时，则子类的构造函数(不管多少个)中都必须显示调用父类的有参构造函数，且这个显式调用必须放在子类的构造函数的第一行，且只能调用一次。

下面来看两个情况：
1：首先假如没有在父类中定义无参的构造函数

1.//当你没有使用父类默认的构造方法时，此时在子类的构造方法中就需要显示的调用父类定义的构造方法。  
2.  class Animal {  
3.      private String name;  
4.  
5.      //如果你定义一个新的构造方法  
6.      public Animal(String name) {  
7.          this.name = name;  
8.      }  
9.  }  
10.  
11.  class Dog extends Animal{
12.  
13.  //这时你就要显示的调用父类的构造方法，因为子类默认调用的是父类的  
14.  //无参构造方法Animal()  
15.  public Dog() {  
16.      super("小狗");  //显示调用父类的有参构造方法  
17.      ....  //子类的构造方法处理  
18.  }  
19.}

2：如果在父类中定义一个无参的构造方法,那么在子类的构造方法中，就可以不用显示的调用父类的构造方法，因为父类有个无参的构造方法，子类在构造方法中会自动调用父类已经定义的无参构造方法。下面来看代码：

1.//当然，如果你在父类里面把无参的构造方法，显示的写出来了，比如：  
2.class Animal {  
3.    private String name;  
4.  
5.    //无参的构造方法  
6.    public Animal() {  
7.    .....  //处理  
8.    }  
9.  
10.    /* 
11.      如果你定义一个新的构造方法,那么在子类的构造方法中，就可以不用显示的调用父类的构造方法，因为父类有个无参的构造方法， 
12.      子类在构造方法中会自动调用父类已经定义的无参构造方法。 
13.    */  
14.    public Animal(String name) {  
15.        this.name = name;  
16.    }  
17.}  
18.  
19.class Dog extends Animal {  
20.    public Dog() {  
21.        .....//子类构造方法的处理  
22.    }  
23.}  

用法2

使用 super 来调用父类的非静态以及非私有的成员方法和访问非静态以及非私有的成员变量
代码实现：

1.class Animal {  
 -    public String name;  
 -    public int age;  
 -    private String sex;  
 -    public static int count;  
 -    //默认权限a  
 -    int a;  
 -  
 -    public Animal(String name) {  
 -        this.name = name;  
 -        System.out.println("父类构造方法");  
 -    }  
 -  
 -    public void eat() {  
 -        System.out.println(this.name + "吃饭");  
 -    }  
 -  
 -    private void fly() {  
 -        System.out.println("this.name" + "会飞");  
 -    }  
 -  
 -    public static void func() {  
 -        System.out.println("静态方法");  
 -    }  
25.}  
 -  
27.//在java中extends关键字只能继承一个类  
28.class Cat extends Animal {  
 -    public void drink() {  
 -        System.out.println(this.name + "喝水");  
 -    }  
 -  
 -    public Cat(String name, int age) {  
 -        //super关键字，并注意与this关键字的对比  
 -        //子类在构造时，要先帮助父类进行构造,  
 -        //此时利用super()语句显示调用父类的构造方法，并且此句必须放在第一行，且此句只能放在构造方法中,且只能调用一次  
 -        //所以父类中的构造方法并不是被继承的，而是在子类的中被显示调用的  
 -        super(name);  
 -        //super访问父类的实例成员变量  
 -        super.name = "宋彪爸爸";  
 -        //super访问父类的实例成员方法  
 -        super.eat();  
 -  
 -     /* super不能访问父类中私有的实例成员变量和调用私有的实例成员方法 
 -        同时也不能访问父类中静态的成员变量和调用静态的成员方法 
 -        super.sex="男"; 
 -        super.fly(); 
 -        super.func(); 
 -        super.count = 10; 
 -     */  
 -    }  
 -  
 -    //不管定义几个构造函数，都必须显示调用父类中的有参构造函数，因为此时父类中没有无参构造函数
 -    public Cat(String name) {  
 -        super(name);  
 -    }  
 -    /* 
 -    super关键字不能用在静态方法中，与this相似，super关键字代表父类对象的引用，而静态是不依赖对象的 
 -    public static void drink1() { 
 -        System.out.println(super.name + "喝水"); 
 -    } 
 -    */  
63.}  

super关键字的总结

• super不能访问父类中私有的实例成员变量和调用私有的实例成员方法 同时也不能访问父类中静态的成员变量和调用静态的成员方法

• super关键字不能用在静态方法中，与this相似，super关键字代表父类对象的引用，而静态是不依赖对象的

• super调用父类构造方法只能用在构造方法中，不能在成员方法中调用父类构造方法，且只能放在第一行，并且只能调用一次
  之前我们还学过this关键字，那么在此我们来做下对比

this和super关键字的对比

四种访问权限(重要)

• private: 类内部能访问, 类外部不能访问
• 默认(也叫包访问权限): 类内部能访问, 同一个包中的类可以访问, 其他类不能访问.
• protected: 类内部能访问, 子类和同一个包中的类可以访问, 其他类不能访问.
• public : 类内部和类的调用者都能访问
  
  大家可能会对上面的表有点陌生，不过没关系，接下来我来带大家理解：
  private访问权限和public访问权限我就不再跟大家仔细赘述了，我就来跟大家详细的讲下默认权限以及protected访问权限：

默认权限

1.同一包中的同一类：
这个较为简单，就不在这里简述了
2.同一包中的不同类：我们来看代码：

1.class Person{  
2.    protected String name;  
3.}  
4.class Person2 extends Person{  
5.    //体现出protected所修饰的实例成员变量name可以在同一个包中的不同类进行访问  
6.    public void print(){  
7.        System.out.println(this.name+"打印物品");  
8.    }  
9.}  

此时Person类和Person类同属于同一个包下的不同类，我们会发现具有默认权限的name是可以在同一个包下的不同类中进行访问的。

同时也可以这么做，如下图所示，LeiHeDuiXiang和TestDemo是同一个包下的不同的两个.java文件，也就是两个不同的public类

在TestDemo文件中有一个默认权限的Animal类，则此时是可以在LeiHeDuiXiang文件中来访问Animal类中的非静态和非私有的成员变量和方法的，如下代码所示：

protected权限

1.同一包中的同一类：
这个较为简单，就不在这里简述了
2.同一包中的不同类，我们来看代码：

此时Person类和Person2类属于同一个包下的同一个.java文件下的不同类，我们会发现具有protected权限的name是可以在同一个包下的不同类中进行访问的。

同时也可以这么做，如下图所示，TestDemo1和TestDemo是同一个包下的不同的两个.java文件，也就是两个不同的public类

在TestDemo文件中有一个默认权限的Person类，则此时是可以在TestDemo1文件中来访问Person类中具有protected权限的方法和成员变量的，如下代码所示：


3.不同包中的子类
这里不同包的子类意思是指一个包中的public类去继承另一个包中的public类，注意这里两头只能是public类
如果不是public类而是默认权限的类，是不能发生包与包间类的继承的
那么此时一个包中的public类便可继承另一个包中的public类中的protected权限的成员变量和方法了，来看代码示例：
首先在两个不同的包中定义两个类TestDemo2和TestDemo3
我们的同学们会直接这样做，在TestDemo2这个类中加入protected修饰的实例成员变量b和实例成员方法eat，当在另一个包中的TestDemo3这个类继承了TestDemo2这个类后，便认为可直接通过TestDemo3这个类的对象的引用访问TestDemo2这个类中的b和eat方法了，此时会发现飘红报错.
很显然不能这样访问父类中的protected修饰的变量和方法，那么该怎么访问呢？此时需要用到super关键字


正确做法如下所示：
首先在两个不同的包中定义两个类TestDemo1和TestDemo2


我们会发现要想访问父类中的protected修饰的变量和方法的话，我们用到了super关键字.
至于最后我们为什么不在static主方法中直接使用super关键字的原因是super是父类对象的引用，而静态是不依赖于对象的.所以只能放在非静态方法里面.

更复杂的继承关系

刚才我们的例子中, 只涉及到 Animal, Cat 和 Bird 三种类. 但是如果情况更复杂一些呢? 针对 Cat 这种情况, 我们可能还需要表示更多种类的猫~

这个时候使用继承方式来表示, 就会涉及到更复杂的体系.

// Animal.java 
public Animal {
...
}

// Cat.java
public Cat extends Animal {
...
}

// ChineseGardenCat.java
public ChineseGardenCat extends Cat {
...
}

// OrangeCat.java
public Orange extends ChineseGardenCat {
...
}
......	

如刚才这样的继承方式称为多层继承, 即子类还可以进一步的再派生出新的子类.

时刻牢记, 我们写的类是现实事物的抽象. 而我们真正在公司中所遇到的项目往往业务比较复杂, 可能会涉及到一系列复杂的概念,
都需要我们使用代码来表示, 所以我们真实项目中所写的类也会有很多. 类之间的关系也会更加复杂.
但是即使如此,我们并不希望类之间的继承层次太复杂. 一般我们不希望出现超过三层的继承关系. 如果继承层次太多, 就需要考虑对代码进行重构了.
如果想从语法上进行限制继承, 就可以使用 final 关键字

final关键字

final关键字的三种用法

用法1：final关键字修饰成员变量

final成员变量表示常量，只能被赋值一次，赋值后值不再改变。

当final修饰一个基本数据类型时，表示该基本数据类型的值一旦在初始化后便不能发生变化；如果final修饰一个引用类型时，则在对其初始化之后便不能再让其指向其他对象了，但该引用所指向的对象的内容是可以发生变化的。本质上是一回事，因为引用的值是一个地址，final要求值，即地址的值不发生变化。
　　final修饰一个成员变量（属性），必须要显示初始化。这里有两种初始化方式，一种是在变量声明的时候初始化；第二种方法是在声明变量的时候不赋初值，但是要在这个变量所在的类的所有的构造函数中对这个变量赋初值。（第二种方法在String类那里见过)
　　当函数的参数类型声明为final时，说明该参数是只读型的。即你可以读取使用该参数，但是无法改变该参数的值。

final int a = 10; 
a = 20;	
// 编译出错，此时final修饰的是基本数据类型

用法2：final关键字修饰类

当用final修饰一个类时，表明这个类不能被继承。也就是说，如果一个类你永远不会让他被继承，就可以用final进行修饰。
在使用final修饰类的时候，要注意谨慎选择，除非这个类真的在以后不会用来继承或者出于安全的考虑，尽量不要将类设计为final类。

final public class Animal {
...
}

public class Bird extends Animal {
...
}

// 编译出错
Error:(3, 27) java: 无法从最终com.bit.Animal进行继承

final 关键字的功能是 限制 类被继承
“限制” 这件事情意味着 “不灵活”. 在编程中, 灵活往往不见得是一件好事. 灵活可能意味着更容易出错.
是用 final 修饰的类被继承的时候, 就会编译报错, 此时就可以提示我们这样的继承是有悖这个类设计的初衷的.

我们平时是用的 String 字符串类, 就是用 final 修饰的, 不能被继承.

用法3：final关键字修饰方法

下面这段话摘自《Java编程思想》第四版第143页：
　 “使用final方法的原因有两个。第一个原因是把方法锁定，以防任何继承类修改它的含义；第二个原因是效率。在早期的Java实现版本中，会将final方法转为内嵌调用。但是如果方法过于庞大，可能看不到内嵌调用带来的任何性能提升。在最近的Java版本中，不需要使用final方法进行这些优化了。“
　　因此，如果只有在想明确禁止 该方法在子类中被覆盖的情况下才将方法设置为final的。即父类的final方法是不能被子类所覆盖的，也就是说子类是不能够存在和父类一模一样的方法的。
final修饰的方法表示此方法已经是“最后的、最终的”含义，亦即此方法不能被重写（可以重载多个final修饰的方法）。此处需要注意的一点是：因为重写的前提是子类可以从父类中继承此方法，如果父类中final修饰的方法同时访问控制权限为private，将会导致子类中不能直接继承到此方法，因此，此时可以在子类中定义相同的方法名和参数，此时不再产生重写与final的矛盾，而是在子类中重新定义了新的方法。（注：类的private方法会隐式地被指定为final方法。）