Java基础提升9

经过这些天知识的总结，发现，对于知识而言，我需要反复地翻阅。因为，即便感觉自己已经掌握，但随着时间的推移，这些知识在脑海的印象越来越模糊，只有不断反复，达到一定的程度，才能真正的融会贯通，理解深刻的含义。
今天的内容是关于Java中继承的一些知识点，通过总结，加深自己的理解。

Java的继承

Java中的继承，大家都不陌生，是面向对象编程的重要特征之一。下面先写出继承较为官方的定义

继承是Java面向对象编程技术的一块基石，因为它允许创建分等级层次的类。
继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的属性和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

看完这段概念，呵呵，可能依旧不知所云。我们可以换个角度看待这个问题。毕竟这些编程语言也是人类设计的，必定和人类社会有着千丝万缕的联系。举个例子，在肯德基餐厅，肯定有很多种类的汉堡，但是有木有想过，KFC家的汉堡一开始就这么多吗？显然不是这么回事。最开始可能只有一种，但是随着KFC的扩张，不同地区，人们口味也会不同。于是KFC就开始改良自己家的汉堡，于是不同口味的汉堡就产生了。这个过程和继承大致一个意思。

public class HamburgA {
    /** 汉堡的口味 */
    private String taste;

    /** 汉堡的大小 */
    private String size;
}

public class HamburgB {
    /** 汉堡的口味 */
    private String taste;

    /** 汉堡的大小 */
    private String size;
}

在上面的代码中，有两种汉堡，显然它们有相同的属性字段。如果有新的汉堡，是不是也要这样写呢？这时候就会考虑继承了。

public class Hamburg {
    /** 汉堡的口味 */
    private String taste;

    /** 汉堡的大小 */
    private String size;
}

public class HamburgA extends Hamburg {

    private HamburgA hamburgA;
}

public class HamburgB extends Hamburg {
    private HamburgB hamburgB;
}

通过对比，再看继承的概念，继承是使用已存在类的定义作为基础，建立新类的技术，新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类。通过使用继承我们能够非常方便地复用以前的代码，能够大大的提高开发的效率。

继承的几个原则

1. 子类继承了其父类中不是私有的（private）成员变量和成员方法，作为自己的成员变量和方法。
2. 子类中定义的成员变量和父类中定义的成员变量相同时，则父类中的成员变量被隐藏。
3. 子类中定义的成员方法，并且这个成员方法的名字，返回类型，以及参数个数和类型与父类的某个成员方法完全相同，则父类的成员方法被覆盖。（也就是说，子类可以用自己的方式实现父类的方法）
4. 子类可以有自己的成员变量和成员方法，即子类可以对父类进行扩展。

下面举几个例子，加深理解。
栗子1：

public class Test {
    public int num = 1;

    public void getNum() {
        System.out.println(this.num);
    }
}
public class TestA extends Test {

    public int num = 2;

}
public class TestDemo {

    public static void main(String[] args) {
        TestA a = new TestA();
        a.getNum();
    }
}
=============
结果
=============
1

TestA继承Test类，在创建TestA的实例对象 a 时，会先创建父类 Test 的实例，因此 Test 中的成员变量会被初始化并且赋值，接着初始化并赋值 a 中的成员变量，在调用getNum()方法时，因为实例 a 没有getNum()方法，仅仅继承该方法，因此会在父类的实例对象中调用该方法，但是父类实例对象的 num 值是1，因此，a.getNum()的值是1。
下面通过截图展示大致过程

创建TestA的实例对象

先创建父类实例对象

调用父类getNum()

栗子2
添加子类TestB，其他不变

public class Test {
    public int num = 1;
    public void getNum() {
        System.out.println(num);
    }
}

public class TestB extends Test {
    public int num = 2;

    @Override
    public void getNum() {
        super.getNum();
        System.out.println(this.num);
    }
}
public class TestDemo {

    public static void main(String[] args) {
        TestA a = new TestA();
        a.getNum();
        System.out.println("===============");
        TestB b = new TestB();
        b.getNum();
    }
}
=============
结果
=============
1
===============
1
2

上述代码中，在执行 b.getNum(); 时，由于 TestB 重写了 父类的 getNum() 方法，因此 b.getNum(); 调用的是自己的方法，之所以出现 1，是因为 实例 b 在执行自己的方法前，调用了父类的方法，即 super.getNum(); 注意 super 必须写在最前面。
此外，对于继承而言，子类会默认调用父类的构造器，但是如果没有默认的父类构造器，子类必须要显式的指定父类构造器，而且必须是在子类构造器中的第一行代码。

栗子3
添加子类TestC，其他不变

public class Test {
    public int num = 1;

    public void getNum() {
        System.out.println(this.num);
    }
}

public class TestC extends Test {
    public TestC() {
        num = 2;
    }
}
public class TestDemo {

    public static void main(String[] args) {
        TestC c = new TestC();
        System.out.println(c.num);
        c.getNum();
    }
}
=============
结果
=============
2
2

子类TestC 继承了 父类 Test 的变量 num，同时也继承了父类的 getNum() 方法，所以 TestC() 的构造函数对 num 的赋值，实际上是对继承自父类的 num 的赋值。由于没有覆盖，c.getNum() 调用的就是父类的方法。因此输出结果就是2。

栗子4
添加子类TestD，其他不变

public class Test {
    public int num = 1;
    public void getNum() {
        System.out.println(num);
    }
}

public class TestD extends Test {
    int num = 8;
    public TestD() {
        num = 88;
    }
}

public class TestDemo {

    public static void main(String[] args) {
        TestD d = new TestD();
        System.out.println(d.num);
        d.getNum();
    }
}
=============
结果
=============
88
1

子类 TestD 重新定义了变量 num， 根据栗子2，父类的变量 num，将会被隐藏，所以 TestD 的构造函数初始化的是自己的变量 num， 但是由于没有继承父类的 getNum() 方法，所以，d.getNum() 调用的仍是父类的方法，父类的 getNum() 的方法返回的是父类的变量 num，也就是1，因此，结果为1。

小结

1. 如果调用父类方法，则父类方法中引用的变量一定是父类中的变量。
2. 如果调用子类方法，那么，如果子类中没有继承父类中的某个变量，而在子类方法中引用了，则调用的是父类的变量，如果在子类中继承了那个变量，则引用的是子类本身的变量。

总之，如果子类继承了父类的变量或者重写了父类的方法，调用时则使用子类自己的，否则就是父类的变量或者方法。可以简单理解为，自己有就用自己的，没有就用别人的（父类）

protected关键字

private访问修饰符，对于封装而言，是最好的选择，但是这只是基于理想的世界，有时候需要这样的要求：我们需要将某个事物尽可能地对这个世界隐藏，但是任然允许子类的成员来访问它们。这个时候就需要用到protected。

对于protected而言，它指明就类用户而言，它是private，但是对于任何继承于此类的子类而言或者其他任何位于同一个包的类而言，它却是可以访问的。

尽管可以使用protected访问修饰符来限制父类属性和方法的访问权限，但是最好的方式还是将属性保持为private(我们应当一致保留更改底层实现)，通过protected方法来控制类的继承者的访问权限。

向上转型

继承是is-a的相互关系，猫继承与动物，所以我们可以说猫是动物，或者说猫是动物的一种。这样将猫看做动物就是向上转型。如下：

public class Person {

    public void display(){
        System.out.println("Play Person...");
    }

    static void display(Person person){
        person.display();
    }
}
public class Husband extends Person{
    public static void main(String[] args) {
        Husband husband = new Husband();
        //向上转型
        Person.display(husband);
    }
}

将子类转换成父类，在继承关系上面是向上移动的，所以一般称之为向上转型。由于向上转型是从一个叫专用类型向较通用类型转换，所以它总是安全的，唯一发生变化的可能就是属性和方法的丢失。

谨慎继承

1. 父类变，则子类必须变。
2. 继承破坏了封装，对于父类而言，它的实现细节对于子类来说是透明的。
3. 继承是一种强耦合关系

深层继承

由于Java语法规定，子类只能有一个父类，因此，在调用父类构造函数时，总是一级一级向上，找到最顶层的父类，使用其构造函数，然后依次调用子类构造函数，最终返回本类的构造函数。

下面举一个普通方法的继承。

public class AA {

    public int aa = 1;

    public void getAA() {
        System.out.println(aa);
    }
}
public class BB extends AA{

    public int bb = 1;

    public AA aa1;

    public void showBB() {
        System.out.println(bb);
    }
}
public class CC extends BB {

    public int cc = 3;

    public void c() {
        System.out.println("this is CC");
    }
}
public class TestDemo1 {

    public static void main(String[] args) {
        AA a = new AA();
        a.getAA();
        System.out.println("--------------");
        BB b = new BB();
        b.getAA();
        b.showBB();
        System.out.println("--------------");
        CC c = new CC();
        c.c();
        c.getAA();
        c.showBB();

    }
}
==========
结果
==========
1
--------------
1
1
--------------
this is CC
1
1

AA

BB

CC

下面举一个构造函数的深层调用的栗子。

public class A {
    public A() {
        System.out.println("A");
    }
    public A(int a) {
        System.out.println(a);
    }
    public A(int a, int b) {
        System.out.println(a+b);
    }
}

public class B extends A {
    public B(A a) {
    }
    public B(int i) {
        super(2, 3);
        System.out.println("B.a: " + i);
    }
    public B(int a, int b) {
        super(3);
        System.out.println("B.a + B.b" + (a + b));
    }
}

public class C extends B {

    public C() {
        super(new A(1, 2));
    }
    public C(int a) {
        super(2, 3);
        System.out.println("B.a: " + a);
    }
    public C(int a, int b) {
        super(3);
        System.out.println("B.a + B.b" + (a + b));
    }
    
    public static void main(String[] args) {
        C c = new C();  
        System.out.println("=======");
        C c1 = new C(1);    
    }
}
===============
结果
===============
3
A
=======
3
B.a + B.b5
B.a: 1

说句题外话，本人能力有限，有不足的地方，欢迎大家指出，我会虚心接受，毕竟思想的交流，十分重要，期待自己早日能成为大佬。

参考链接

深入理解java继承——java继承中容易犯的错误

Java：类与继承