Java继承

1.Java语言中只支持单继承，不支持多继承，但可以多实现

一个类只能有一个父类，因为当一个类同时继承两个类的时候，两个父类中恰好有两个相同的方法，那么子类对象调用该对象的时候就不明确到底调用是哪个方法，有安全隐患。但是Java保留了这种机制，用另一种表现形式，就是多实现。而且Java语言支持多层继承，A继承B,B继承C，C继承D，A类就有了B，C，D类的功能。所以一个体系要想被使用，通过查阅该系统中的父类的功能就可以知道这个体系的基本用法，使用体系需要创建对象，那么最好就是创建最子类对象，因为不仅可以使用父类的功能，又有子类的特有方法。简单一句话：查阅父类功能，创建子类对象使用功能。

2.继承的特点：

1)提高了代码的复用性；

2)让类与类之间产生关系，有了继承，所以有了多态的特性；

3.子父类出现后，类中的成员的特点：

1)成员变量：

如果子类中出现非私有的同名成员变量，子类要访问本类中的变量，用this，子类要访问父类中的变量，用super。

this 和super用法一样，this代表本类对象的引用，super代表父类对象的引用。

2)函数：

当子父类中出现一模一样的函数时，当子类对象调用该方法的时候，会运行子类函数的内容，就好像父类的函数被覆盖了一样，这种情况是函数的另一个特性，覆盖(重写,复写)

子类要覆盖父类，子类的权限必须要大于等于父类的权限才可以覆盖，否则会编译失败，静态只能覆盖静态。

3)构造函数：

子类对象在初始化的时候，先运行了父类的构造函数，这是因为子类的构造函数在第一行有一条隐式的语句：super();

super()：会访问父类中空参数的构造函数，而且子类对象构造函数的第一行默认的都是super();

子类对象一定要访问父类的构造函数，因为子类继承父类，可以直接调用父类的数据，所以子类对象在创建时，需要查看父类是如何对数据进行初始化的所以子类对象在初始化的时候，先调用父类的构造函数，这就是子类的实例化过程。如果父类中没有空参数的构造函数，那么子类在构造函数内必须通过super语句指定要访问的父类中的构造函数，如果子类构造函数中用this来指定调用子类自己的构造函数，那么被调用的构造函数也一样会访问父类中的构造函数。子类中至少有一个会调用父类的构造函数。

例如：

class Fu {
Fu(){
System.out.println("Fu ...run");
}
int num = 5;
public int show(){
return num;
}
public void run(){
System.out.println("Fu method run");
}
}
class Zi extends Fu {
Zi(){
System.out.println("Zi ... run");
}
public String name;
Zi(String name){
this();//等同于Zi();super()就不存在了，但是会在别的构造函数
this.name = name;
}
//子类的特有方法
public void method(){
System.out.println("Zi method run");
}

Int num = 10;
//调用父类的方法
public int show(){
return super.num;
}//覆盖父类方法
public void run(){
System.out.println("Zi method_1 run");
}
}

public class Test{

public static void main(String[] args) {
Zi zi = new Zi();
zi.method();
/*
* 会打印：Fu ...run
*   Zi ... run
*/
System.out.println(zi.show());//打印 5；
zi.run();

}
}

4.继承的弊端：

继承打破了封装性，如果类或者类中的功能不想被继承，或者复写，那么可以用final关键字修饰。

final 特点:

1.可以修饰类，方法，变量

2.被 final修饰的类是一个最终类，不可以被继承

3.被final修饰的方法是一个最终方法，不可以被覆盖

4.被 final 修饰的变量是一个常亮，只能被赋值一次

5.当描述事物时，常常给一些固定的数据起个阅读性较强的名称，而这些数据不要被改变，就可以用 final修饰。例如 “π” 。

6.内部类定义在类中的局部位置时，只能访问该局部被 final 修饰的局部变量。

抽象类：abstract

抽象：顾名思义，就是不具体，看不明白。

抽象类的概述：

多个类中出现功能相同，但是主体不同的情况，这时候将共性内容向上抽取，这时抽取到的方法并不具体，需要被指定关键字abstract 

修饰，声明为抽象方法。

抽象类的特点：

1.抽象方法只能定义在抽象中，抽象类和抽象方法必须由 abstract 关键字修饰(可以描述类和方法，不能描述变量)

2.抽象方法只定义方法声明，而不具体实现

3.抽象类不能被实例化，因为调用抽象方法没有意义

4.子类继承抽象类并覆盖了抽象类中的所有抽象方法才能被实例化，否则该子类还是抽象类

抽象类的细节：

1.抽象类有构造函数吗？有 ，用于给子类进行初始化

2.抽象类中是否可以定义非抽象方法？ 可以，抽象类和一般类差不多，都是在描述实物，只是抽象类在一些功能定义上不具体，抽象类比

    一般类多了一个抽象函数，而且比一般类少了一个创建对象的部分。

3.抽象类中可以不定义抽象方法吗？ 可以，抽象方法仅仅是为了不让该类创建对象。

4.抽象类不能与 private , final static等关键字共存

接口：Interface

1.是用 Interface 关键字定义的

2.接口中包含的成员，最常见的有全局变量，抽象方法。接口中的成员都有固定的修饰符

成员变量：public static final

成员方法：abstract

3.接口中有抽象方法，说明接口不能被实例化，子类只有覆盖了所有抽象方法才能被实例化，不然该子类还是抽象类

4.类和类中存在着继承关系，类与接口存在着实现关系

继承：extends     实现：Implements

5.接口可以被多实现，这是多继承改良后的结果，一个类在继承另一个类的同时，还可以实现多个接口，打破了单继承的局限性，而且接口还可以多继承。

接口的特点:

1.接口是对外暴露的规则

2.接口是功能的扩展

3.接口的出现降低了耦合性

接口和抽象类的异同点：

共同点：都是通过不断向上抽取而来的

不同点：

1.抽象类只能被继承，而且只能是单继承

 接口需要被实现，而且是多实现

  2.抽象类中可以定义抽象方法和非抽象方法。子类继承父类后可以直接使用非抽象方法

接口中都是抽象方法，必须由子类实现

3.抽象类使用的是 is a 关系

接口使用的是 like a关系

4.抽象类的成员可以自定义

接口中的成员修饰符是固定的，全是 public