Java基础继承、抽象、接口

继 承（面向对象特征之一）

继承的好处特点：
1.提高了代码的复用性。
2.让类与类之间产生了关系。
3.给第三特征—多态 ，提供了前提。

继承的缺点：继承只能单继承不能多继承。
原因：因为当一个类同时继承两个父类时，两个父类中有相同的功能，那么子类对象调用该功能时，运行哪一个呢？因为父类中的方法中存在方法体。
但是java支持多重继承。A继承B B继承C C继承D。
多重继承的出现，就有了继承体系。体系中的顶层父类是通过不断向上抽取而来的。它里面定义的该体系最基本最共性内容的功能。
所以，一个体系要想被使用，直接查阅该系统中的父类的功能即可知道该体系的基本用法。那么想要使用一个体系时，需要建立对象。建议建立最子类对象，因为最子类不仅可以使用父类中的功能。还可以使用子类特有的一些功能。

当要使用一个继承体系时要注意的：
1.查阅顶层父类中的内容，了解该体系的基本功能
2.创建最底层子类的对象，完成功能的使用
3.使用继承中：A不能因为需要B重的某种内容，而去继承B，这样，A在获取的到了需要内容的同时还获取到了不必要的内容，对于需要的内容，可以选择抽取然后继承。
4.子类继承父类，子类可以直接使用父类的构造函数，而子类创建的对象，则不可以使用子类的父类的构造函数。

当类中有继承关系，其成员的特点:
当子父类中出现一样的属性时，子类类型的对象，调用该属性，值是子类的属性值。
成员变量：
如果想要调用父类中的属性值，需要使用一个关键字：super
This：代表是本类类型的对象引用。
Super：代表是子类所属的父类中的内存空间引用。
注意：子父类中通常是不会出现同名成员变量的，因为父类中只要定义了，子类就不用在定义了，直接继承过来用就可以了。
this、super的用法示例：

class Fu{    int num = 4;}//字符类中共同定义的成员变量（num）相同class Zi extends Fu{    int num = 5;    void show(){        System.out.println(this.num+"..."+super.num);    }}class ExtendsDemo{public static void main(String[] args) { Zi z = new Zi(); z.show(); }}

输出结果为：

4...5

成员函数。
当子父类中出现了一模一样的方法时，建立子类对象会运行子类中的方法。父类中的方法被子类覆盖掉。
代码示例：

    class Fu{        void show(){            System.out.println("Fu show");        }    }    class Zi extends Fu{        void show(){            System.out.println("Zi show");        }    }    class ExtendsDemo{        public static void main(String[] args) {            Zi z  = new Zi();            z.show();        }    }

输出结果为：

Zi show

覆盖之一事项：
1.子类覆盖父类方法时。子类的方法权限必须大于父类方法的权限(子类只能扩大父类方法的权限，不可以缩小)
2.static静态只能覆盖静态，或者被静态覆盖
3.覆盖只能对于方法，成员变量不可。

覆盖操作的优势：提高了代码的可维护性，因为这样一来就不需要修改原来的代码，利于扩展，比如手机：原来只有来点显示，现在需要增加姓名，大头贴什么的，那么只需要覆盖一下就好了。

什么时候使用覆盖操作：当对一个雷进行子类的扩展时，子类需要保留父类的功能声明，但是定义子类中该功能的特有功能时，就使用覆盖操作完成。

发现子类构造函数运行时，先运行了父类的构造函数。为什么?
原因：子类的所有构造函数中的第一行，其实都有一条隐身的语句super();
super():表示父类的构造函数，并会调用于参数相对应的父类中的构造函数。而super():是在调用父类中空参数的构造函数。

为什么子类对象初始化时，都需要调用父类中的函数？(为什么要在子类构造函数的第一行加入这个super()?)
因为子类继承父类，会继承到父类中的数据，所以必须要看父类是如何对自己的数据进行初始化的。所以子类在进行对象初始化时，先调用父类的构造函数，这就是子类的实例化过程。

注意：子类中所有的构造函数都会默认访问父类中的空参数的构造函数，因为每一个子类构造内第一行都有默认的语句super();
如果父类中没有空参数的构造函数，那么子类的构造函数内，必须通过super语句指定要访问的父类中的构造函数。
如果子类构造函数中用this来指定调用子类自己的构造函数，那么被调用的构造函数也一样会访问父类中的构造函数。

super()和this()是否可以同时出现的构造函数中？
super()和this()都必须定义在构造函数的第一行，而两个语句只能有一个定义在第一行，所以只能出现其中一个。

super()或者this():为什么一定要定义在第一行？
因为super()或者this()都是调用构造函数，构造函数用于初始化，所以初始化的动作要最先完成。

注意：在顶类的构造函数中，第一行也有默认的super，虽然已经没有类了，但是在java中，所以场景的类都可以默认继承Object。

final关键字：
final的特点：
1：这个关键字是一个修饰符，可以修饰类，方法，变量。
2：被final修饰的类是一个最终类，不可以被继承。
3：被final修饰的方法是一个最终方法，不可以被覆盖。
4：被final修饰的变量是一个常量，只能赋值一次。

关于final修饰的变量，注意：

final int x；//这种方式是错误的，final int x = 7；//这种方式是正确的。//总结：final固化的是显示初始化值，而不是初始化默认初始化值。（成员被final后一般都会加static设置为静态）

抽象类: abstract

抽象类的特点：
1：抽象方法只能定义在抽象类中，抽象类和抽象方法必须由abstract关键字修饰（可以描述类和方法，不可以描述变量）。
2：抽象方法只定义方法声明，并不定义方法实现。
3：抽象类不可以被创建对象(实例化)。
4：只有通过子类继承抽象类并覆盖了抽象类中的所有抽象方法后，该子类才可以实例化。否则，该子类还是一个抽象类。

抽象类中是否有构造函数？
有，用于给子类对象进行初始化。

抽象类中是可以定义抽象方法吗？
可以，但是很少见，目的就是为了不让该类创建对象。AWT的适配器对象就是这种类，通常这个类中的方法有方法体，但是却没有内容。

抽象关键字abstract和哪些不可以共存？
final （固化了抽象方法，子类无法进行覆盖）
private （子类访问不到）
static （类名可以直接调用而失去了意义）

模板方法设计模式：
解决的问题：当功能内部一部分实现时确定，一部分实现是不确定的。这时可以把不确定的部分暴露出去，让子类去实现。
abstract class Fu{
public final void show1(){
System.out.println(“我是已经实现的方法”);
}
public abstract void show2(); //抽象不确定的功能，让子类复写实现
}
class Sub extends Fu{
public void show2(){ //子类复写功能方法

        System.out.println("我实现了父类没有实现的方法");}

}

接 口：interface

接口中所具备的成员：全局常量、抽象方法。

接口中的成员都有固定的修饰符：
1：全局变量：public static final
2.抽象方法：public abstract
注意：在敲打吗过程中如果没有添加固定修饰符，系统会默认添加，但在开发中为提高阅读性，一般固定修饰符都全部书写

接口、类的关系：
1.类与类之间存在着继承关系，类与接口中间存在的是实现关系

2.接口和类不一样的地方，就是，接口可以被多实现，这就是多继承改良后的结果。java将多继承机制通过多现实来体现。

3.一个类在继承另一个类的同时，还可以实现多个接口。所以接口的出现避免了单继承的局限性。还可以将类进行功能的扩展。

其实java中是有多继承的。接口与接口之间存在着继承关系，接口可以多继承接口。

接口的特点：
1：接口是对外提供的规则。
2：接口是功能的扩展。
3：接口的出现降低了耦合性。

抽象类与接口：
抽象类：一般用于描述一个体系单元，将一组共性内容进行抽取，特点：可以在类中定义抽象内容让子类实现，可以定义非抽象内容让子类直接使用。它里面定义的都是一些体系中的基本内容。
接口：一般用于定义对象的扩展功能，是在继承之外还需这个对象具备的一些功能。

抽象类和接口的区别：
1：抽象类只能被继承，而且只能单继承。
接口需要被实现，而且可以多实现。
2：抽象类中可以定义非抽象方法，子类可以直接继承使用。
接口中都有抽象方法，需要子类去实现。
3：抽象类的成员修饰符可以自定义。
接口中的成员修饰符是固定的。全都是public的。

4：抽象类定义的是该体系的基本内容
接口中添加的是额外功能