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

继承的产生场景：

是指多个类如果有共性的属性或者行为，但是这些类之间没有任何关系，可以将所有共性的属性和行为抽取出来，成为一个新的类，这个类称为父类，这些含有父类中属性或者行为的类称为子类，子类只需要继承父类，便不用定义父类拥有的属性或行为，可以直接调用父类的属性和行为；

继承是指子类对象可以直接调用父类对象的所有属性和行为。私有化字段和方法不能被子类直接调用，私有化语句只有在本类才能被调用。

子类实例化过程中细节

任何构造方法，第一行都有一个隐式的super()；方法，用来初始化父类字段，因为子类对象需要调用父类对象字段和方法，所以必须有super()语句放在构造方法中。

super()语句必须放在第一行，因为初始化动作要先执行。

super()语句和this()语句不能同时存在，因为都是初始化语句，都要放在构造方法第一行执行。

SubFu(){

1、super();

2、显示初始化；

3、构造代码块初始化；

}
子类调用父类构造方法初始化示例：

1 2 3 4 5 6

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

final关键字

一、final修饰的类，不能被继承

当某个类不想要被其它类继承时，可以加final修饰符修饰

二、final修饰的方法，不能够被覆写

当父类中某个方法中的内容不希望被覆写时，可以使用final关键词修饰

三、final修饰的变量，是常量，只能被赋值一次，常量的常量名最好是大写

某些不需要被修改的变量，可以使用final修饰，变为常量，例如π的值，可以定义为：finalintPI=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，定义变量，但是变量必须有固定的修饰符修饰，publicstaticfinal所以接口中的变量也称之为常量。

2，定义方法，方法也有固定的修饰符，publicabstract

接口中的成员都是公共的。

【接口的特点】

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(); } Cc= 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，类与类之间是继承(isa)关系，类与接口之间是实现(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 、构造方法中代码执行； }