继承--抽象类--接口--子类构造方法代码执行顺序

继承的产生场景：
是指多个类如果有共性的属性或者行为，但是这些类之间没有任何关系，可以将所有共性的属性和行为抽取出来，成为一个新的类，这个类称为父类，这些含有父类中属性或者行为的类称为子类，子类只需要继承父类，便不用定义父类拥有的属性或行为，可以直接调用父类的属性和行为；
继承是指子类对象可以直接调用父类对象的所有属性和行为。私有化字段和方法不能被子类直接调用，私有化语句只有在本类才能被调用。

子类实例化过程中细节
任何构造方法，第一行都有一个隐式的super()；方法，用来初始化父类字段，因为子类对象需要调用父类对象字段和方法，所以必须有super()语句放在构造方法中。
super()语句必须放在第一行，因为初始化动作要先执行。
super()语句和this()语句不能同时存在，因为都是初始化语句，都要放在构造方法第一行执行。
SubFu(){
1、super();
2、显示初始化；
3、构造代码块初始化；
}
子类调用父类构造方法初始化示例：

1 2 3 4 5 6

class   Student  extends   Person{   public   Student(String name, int   age){    //直接调用父类构造方法，初始化子类对象    super (name,age);   } }

final关键字
一、final修饰的类，不能被继承
当某个类不想要被其它类继承时，可以加final修饰符修饰
二、final修饰的方法，不能够被覆写
当父类中某个方法中的内容不希望被覆写时，可以使用final关键词修饰
三、final修饰的变量，是常量，只能被赋值一次，常量的常量名最好是大写
某些不需要被修改的变量，可以使用final修饰，变为常量，例如π的值，可以定义为：final int PI=3.14;

抽象类
定义：在描叙事物时，没有足够的信息描叙这个事物，这是我们就说这个事物时抽象事物。
关键词：abstract
被abstract修饰的类是抽象类
被abstract修饰的方法是抽象方法，抽象方法没有方法体。

【抽象类的特点】
1，抽象类和抽象方法都需要被abstract修饰。
抽象方法一定要定义在抽象类中。
2，抽象类不可以创建实例，原因：调用抽象方法没有意义。
3，只有覆盖了抽象类中所有的抽象方法后，其子类才可以实例化。
否则该子类还是一个抽象类。

之所以继承，更多的是在思想，是面对共性类型操作会更简单。

【细节问题】 
1，抽象类一定是个父类？
 是的，因为不断抽取而来的。

2，抽象类是否有构造函数？ 
 有，虽然不能给自己的对象初始化，但是可以给自己的子类对象初始化。
 抽象类和一般类的异同点：
 相同：
  1，它们都是用来描述事物的。
  2，它们之中都可以定义属性和行为。

 不同：
  1，一般类可以具体的描述事物。
   抽象类描述事物的信息不具体
  2，抽象类中可以多定义一个成员：抽象函数。
  3，一般类可以创建对象，而抽象类不能创建对象。

3，抽象类中是否可以不定义抽象方法。
 是可以的，那这个抽象类的存在到底有什么意义呢？仅仅是不让该类创建对象。

4，抽象关键字abstract不可以和哪些关键字共存？
 1，final： 被final修饰的类不能被继承，修饰的方法不能被覆写，抽象类必须被继承，抽象方法必须被覆写才有意义。
 2，private： 被private修饰的方法不能被覆写，抽象方法必须被覆写才有意义。
 3，static：被static 修饰的方法能被类名称.方法名调用，抽象方法没有意义，不能被直接调用。

接口
抽象类中可以定义抽象方法的 。
当一个抽象类中的方法全是抽象的。
这时，可以通过另一种特殊的形式来体现。
用接口来表示。

接口中的成员已经被限定为固定的几种。

【接口的定义格式先介绍两种：】
1，定义变量，但是变量必须有固定的修饰符修饰，public static final 所以接口中的变量也称之为常量。
2，定义方法，方法也有固定的修饰符，public abstract
接口中的成员都是公共的。

【接口的特点】

1，接口不可以创建对象。
2，子类必须覆盖掉接口中所有的抽象方法后，子类才可以实例化。
 否则子类是一个抽象类。

【怎么解决多继承的弊端呢？】

弊端：多继承时，当多个父类中有相同功能时，子类调用会产生不确定性。
其实核心原因就是在于多继承父类中功能有主体，而导致调用运行时，不确定运行哪个主体内容。
为什么多实现就解决了呢？
因为接口中的功能都没有方法体，由子类来明确。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

interface   A {   void   show(); } interface   B {   void   show(); } class   C  implements   A,B // 多实现。同时实现多个接口。 {   public   void   show(); }   C c =  new   C(); c.show();

【基于接口的扩展。】

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

class   Fu {   public   void   show(){} } //子类通过继承父类扩展功能，通过继承扩展的功能都是子类应该具备的基础功能。 //如果子类想要继续扩展其他类中的功能呢？这时通过实现接口来完成。 interface   Inter {   pulbic  void   show1(); } class   Zi  extends   Fu  implements   Inter {   public   void   show1()   {       } }

接口的出现避免了单继承的局限性。
父类中定义的事物的基本功能。
接口中定义的事物的扩展功能。

【接口出现后的一些小细节】

1，类与类之间是继承(is a)关系，类与接口之间是实现(like
a)关系，
 接口与接口之间是继承关系，而且可以多继承。

继承
继承出现后，在代码中的体现

重点在在于成员的体现：
1，成员变量。重点明确原理。
 特殊情况：
  子父类中定义了一模一样的成员变量。
  都存在于子类对象中。
  如何在子类中直接访问同名的父类中的变量呢？
  通过关键字 super来完成。
 
  super和this的用法很相似。

  this：代表的是本类的对象的引用。
  super：代表的是父类的内存空间。

  注意：这种情况开发见不到，因为父类一旦描述完了属性，子类直接使用就可以了。

2，成员函数。
3，构造函数。

重写override
当父类中存在的方法，子类也存在，并且想要更改该方法的方法体，这是就用到了重写。
重写完如何调用父类方法？
super.方法名来调用
【子父类中成员函数的特点】
特殊情况：
子父类中的定义了一模一样的函数。
运行的结果:子类的函数在运行。
这种情况在子父类中，是函数的另一个特性：override(重写，覆盖，复写)

【重写(覆盖)的注意事项】

1，子类覆盖父类，必须保证全要大于或者等于父类的权限。

1 2 3 4

Fu: private   void   show(){} Zi: public   void   show(){}

2，静态覆盖静态。
写法上稍微注意:必须一模一样:函数的返回值类型 函数名 参数列表都要一样。

【总结】

当一个类是另一个类中的一种时，可以通过继承，来扩展功能。
如果从父类具备的功能内容需要子类特殊定义时，使用重写。

注：子类对象构造方法代码执行顺序

1 2 3 4 5 6

Constructor(){ 1 、 super (){}; 2 、显示初始化； 3 、构造代码块中代码执行； 4 、构造方法中代码执行； }