继承和多态（1）(继承部分)

继承

继承的概念 

                                                上文就是继承的概念。

                     必须记住父类也可以称为基类，超类。 子类也可以称为派生类。 

继承的语法

在Java中如果要表示类之间的继承关系，需要借助extends关键字，具体如下：

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

注意：

1. 子类会将父类中的成员变量或者成员方法继承到子类中了

2. 子类继承父类之后，必须要新添加自己特有的成员，体现出与基类的不同，否则就没有必要继承了 

在子类中访问成员变量

在子类方法中或者通过子类对象访问成员变量时：

如果访问的成员变量子类本身就有（不带继承的父类，是自己本身），优先访问子类自己本身的成员变量。

如果访问的成员变量子类中无，则访问父类继承下来的。如果父类也没有定义，则编译报错。

那么说如果访问的子类自己本身的成员变量与父类中成员变量同名，则优先访问自己的。

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

 在子类中访问成员方法

 跟访问成员变量一样。

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

当子类和父类有相同的成员方法时（这里的成员方法相同是指方法签名完全相同，方法重载这种只有方法名相同的不算），访问该成员方法，则优先访问子类的成员方法。

super关键字 

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

Java提供了super关键字，该关键字主要作用：在子类方法中访问父类的成员。（注意只能在子类中使用）  

注意你可以将super看作是一个引用变量，跟this差不多，不过不像this一样在非静态方法中就自带this（this都隐藏起来了）。

它只能出现在非静态方法中，所以它像this一样都代表着创建出的对象的地址，只不过this是引用全部，super是引用父类部分。

 在子类方法中，如果想要明确访问父类中成员时，借助super关键字即可。

【注意事项】

1. 只能在非静态方法中使用

2. 用在子类方法中，访问父类的成员变量和方法。

其他的事项在后文中介绍。

 子类构造方法

 子类对象构造时，需要先调用基类构造方法，然后执行子类的构造方法。原理如下。

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()

在子类构造方法中，使用super（）或super（参数）能访问父类中的构造方法。

但它只能在第一行使用  ，并且 super(...)只能在子类构造方法中出现一次，还不能和this同时出现。

如果在子类的构造方法第一行没有用super调用，就会在子类构造方法第一行默认有隐含的super()调用。（当有this调用在第一行时，其super也不会出现默认的隐藏调用）

当子类没有构造方法时，默认有隐含的无参数构造方法并且其内部存在super（）。

当父类没有构造方法时，默认有隐含的无参数构造方法并且其内部为空语句。

对于父类的构造方法，里面隐藏的依然是this. ,并不是super  

super和this  

 super和this都可以在成员方法中用来访问成员变量和调用其他的成员函数，都可以作为构造方法的第一条语句，那他们之间有什么区别呢？

【相同点】

1. 都是Java中的关键字

2. 它们都只能在类的非静态方法中使用。在静态方法中都用不了。

3. 在构造方法中调用时，必须是构造方法中的第一条语句，并且不能同时存在  

【不同点】

1. this是当前对象的引用，当前对象即调用实例方法的对象，super相当于是子类对象中从父类继承下来部分成员的引用

2. 在非静态成员方法中，this用来访问本类的方法和属性，super用来访问父类继承下来的方法和属性

3. 在构造方法中：this(...)用于调用本类另外的构造方法，super(...)用于调用父类构造方法，两种调用不能同时在构造方法中出现

4. 构造方法中一定会存在super(...)的调用，用户没有写编译器也会增加，但是this(...)用户不写则没有  

 

再谈初始化 （跟代码块相关）

 在没继承关系时，顺序是先执行静态代码块，然后是实例代码块，然后是构造方法执行。

当有了继承关系时 

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

1、父类静态代码块优先于子类静态代码块执行，且它们都是最早执行

2、然后执行父类实例代码块，再执行父类构造方法

3、紧接着执行子类的实例代码块，然后是子类构造方法

4、第二次实例化子类对象时，父类和子类的静态代码块都将不会再执行。除此之外其他的跟第一次实例化对象一模一样。

初始化的进阶版（重点） 

这里涉及了构造方法和成员变量以及代码块的初始化先后顺序。

首先说下类的加载会导致静态成员变量先初始化（父类的静态变量先初始化，子类的静态变量后初始化），而后是静态代码块初始化（父类的静态代码块先执行，子类的静态代码块再执行），因为类的加载只有一次，所以它们只能执行一次。

然后如果我们用一个类创建一个实例对象（类在这之前就被加载过了），先执行实例成员变量初始化，然后再是实例代码块初始化，最后是构造方法初始化。（如果在有继承关系的前提下，先执行父类的实例变量初始化，再执行父类的实例代码块初始化，然后执行父类构造方法，执行完后子类的实例变量初始化，然后同理依次执行子类的实例代码块初始化，子类的构造方法）所以这就是其创建一个实例对象的顺序。

如果在用该类创建实例对象之前类没被加载，那么不管如何，因为类的加载都在创建对象之前，所以同理即可，先静态成员变量初始化，静态代码块初始化，实例成员变量初始化，实例代码块初始化，构造方法初始化（有继承关系的前提下的顺序我就不说了，自己推可以推出来）

这个很重要，之后做题目会应用到。

 protected 关键字

在类和对象章节中，为了实现封装特性，Java中引入了访问限定符，主要限定：类或者类中成员能否在类外或者其他包中被访问。 

如果有时我们想要一个变量能在一个包之外去使用，但又不会像public范围那么大，这时就出现了protected这个修饰符。允许变量还能在另一个包的所属子类中去使用 

例如下面一个例子。

package cot;
public class Data1 {
        protected  int a=30;
    }

package com;
import cot.Data1;
class Date2 extends Data1 {
    public void a(){



        System.out.println(super.a);
        Date2 date3  =new Date2();
        System.out.println(date3.a);
        System.out.println(super.a);
    }
    public static void main(String[] args) {
        Date2 date2  =new Date2();
        Data1 date1  =new Data1();
        System.out.println(date2.a);

        date2.a();

    }
}

将cot包中的Data1类当作父类继承到com包中的Date2类时，因为a是protected修饰的，所以能在另一个包的所属子类中使用。

注意一个很关键的点，如果子类和父类在不同的包中，在另一个包中的子类中用父类创建一个对象，用该对象去访问被protected修饰的成员变量，是不支持的。

我们支持用子类去创建对象通过子类创建的对象去访问被protected修饰的变量，这可行。（同理当super，this代表子类创建的对象的地址时也可以访问）

而当子类和父类在同一个包时，之前在不同包时的不支持的行为到相同包后可以发生。（在同一个包中，没有特别需要注意的点）

 

这里还有一些例子 ：

除此之外我们还说下private，父类中private成员变量虽然在子类中不能直接访问，但是也继承到子类中了，只是直接访问不了，子类中是含有private成员变量的。

 继承方式

在java中有以下继承方式 

 必须记住java不支持多继承。

时刻牢记,我们写的类是现实事物的抽象. 而我们真正在公司中所遇到的项目往往业务比较复杂, 可能会涉及到 一系列复杂的概念, 都需要我们使用代码来表示, 所以我们真实项目中所写的类也会有很多. 类之间的关系也会 更加复杂.

但是即使如此, 我们并不希望类之间的继承层次太复杂. 一般我们不希望出现超过三层的继承关系. 如果继承层次太多, 就需要考虑对代码进行重构了.

如果想从语法上进行限制继承, 就可以使用final关键字

 final关键字

其有三个作用：

1.修饰局部变量或者成员变量：

修饰成员变量时必须在定义成员变量的同时给它初始化，否则会报错。

修饰局部变量时定义好局部变量后可以不立即进行初始化，但之后依然必须得初始化，且必须在使用这个局部变量前初始化好，否则会报错。

注意初始化必须用一次且只能用一次，在这之后它表示常量(即不能修改)，不能再进行赋值，否则会报错。

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

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

3.修饰方法：表示该方法不能被重写(后序介绍)  

继承与组合 

和继承类似, 组合也是一种表达类之间关系的方式, 也是能够达到代码重用的效果。组合并没有涉及到特殊的语法 (诸如 extends 这样的关键字) ， 仅仅是将一个类的实例作为另外一个类的成员变量。

 由这可知，将一个类创建的变量当作另一个类的成员变量就是我们口中的组合了。

组合和继承都可以实现代码复用，应该使用继承还是组合，需要根据应用场景来选择，一般建议：能用组合尽量用组合，因为组合更安全，更简单，更灵活，更高效  。

这里有个讲解继承和组合的文章。 深入理解Java中的组合和继承-HollisChuang's Blog

所以到这里我们的继承与多态的继承部分就讲完了，此外还讲了个组合。 这篇文章制作不易，希望各位大佬们能互关互三，求赞求评论，实在感谢！你们的支持是我最大的动力！