Java的继承性

继承的概述

在现实生活中就存在着很多关于继承的现象，我们以下面的动物关系图为例，图中很清楚的表明了每种动物和类型之间的关系：兔子和羊属于食草动物类，狮子和豹属于食肉动物类。食草动物和食肉动物又是属于动物类。

虽然食草动物和食肉动物都是属于动物，但是两者的属性和行为上有差别，所以子类会具有父类的一般特性也会具有自身的特性。所以继承需要符合的关系是：is-a，父类更通用，子类更具体。子类继承了父类，就继承了父类的方法和属性。

多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。所以继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

 

类的继承格式

在Java 中，继承的关键字用的是“extends”，用来申明一个类是从另外一个类继承而来的。即子类不是父类的子集，而是对父类的“扩展”。

class 父类 {
}
class 子类 extends 父类 {
    // 在子类中，可以使用父类中定义的方法和属性，也可以创建新的数据和方法。
}

Java中所有的类都是继承于 java.lang.Object，当一个类没有继承的两个关键字，则默认继承object（这个类在 java.lang 包中，所以不需要 import）祖先类。

 

为什么要有继承？

多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。继承是 Java 中实现软件重用的重要手段，避免重复，易于维护，易于理解。比如开发动物类，其中动物包括兔子和羊，如果不使用继承我们可能会像下面这样去写：

兔子：属性（姓名，id），方法（吃，睡，自我介绍）

public class Rabbit{ 
    private String name; 
    private int id; 
    public Rabbit(String myName, int  myid) { 
        name = myName; 
        id = myid; 
    } 
    public void eat(){ 
        System.out.println(name+"正在吃"); 
    }
    public void sleep(){
        System.out.println(name+"正在睡");
    }
    public void introduction() { 
        System.out.println("大家好！我是" + id + "号" + name + "."); 
    } 
}

羊：属性（姓名，id），方法（吃，睡，自我介绍）

public class Sheep{ 
    private String name; 
    private int id; 
    public Sheep(String myName, int  myid) { 
        name = myName; 
        id = myid; 
    } 
    public void eat(){ 
        System.out.println(name+"正在吃"); 
    }
    public void sleep(){
        System.out.println(name+"正在睡");
    }
    public void introduction() { 
        System.out.println("大家好！我是" + id + "号" + name + "."); 
    } 
}

从这两段代码可以看出来，代码存在重复了，导致后果就是代码量大且臃肿，而且维护性不高(维护性主要是后期需要修改的时候，就需要修改很多的代码，容易出错)，所以要从根本上解决这两段代码的问题，就需要继承，将两段代码中相同的部分提取出来组成 一个父类：

public class Animal { 
    private String name;  
    private int id; 
    public Animal(String myName, int myid) { 
        name = myName; 
        id = myid;
    } 
    public void eat(){ 
        System.out.println(name+"正在吃"); 
    }
    public void sleep(){
        System.out.println(name+"正在睡");
    }
    public void introduction() { 
        System.out.println("大家好！我是" + id + "号" + name + "."); 
    } 
}

这个Animal类就可以作为一个父类，然后兔子类和羊类继承这个类之后，就具有父类当中的属性和方法，子类就不会存在重复的代码，维护性也提高，代码也更加简洁，提高代码的复用性（复用性主要是可以多次使用，不用再多次写同样的代码） 继承之后的代码：

public class Rabbit extends Animal { 
    public Rabbit(String myName, int myid) { 
        super(myName, myid); 
    } 
}

public class Sheep extends Animal { 
    public Sheep(String myName, int myid) { 
        super(myName, myid); 
    } 
}

继承的出现提高了代码的复用性。但不要仅为了获取其他类中某个功能而去继承。由上也可以知道父类其实是由多个类不断向上抽取共性内容而来的。

 

Java的继承类型

上图中列出了Java支持的继承类型，Java 不支持多继承，也就是说每个类都只能直接继承一个类，但支持多重（多层）继承。

为什么不支持多继承呢？因为当一个类同时继承两个父类时，两个父类中有相同的功能，那么子类对象调用该功能时，运行哪一个呢？因为父类中的方法中存在方法体。

多重继承的出现，就有了继承体系。体系中的顶层父类是通过不断向上抽取而来的。它里面定义的该体系最基本最共性内容的功能。所以，一个体系要想被使用，直接查阅该系统中的父类的功能即可知道该体系的基本用法。那么想要使用一个体系时，需要建立对象。建议建立最子类对象，因为最子类不仅可以使用父类中的功能。还可以使用子类特有的一些功能。

简单说：对于一个继承体系的使用，查阅顶层父类中的内容，创建最底层子类的对象。

 

什么时候使用继承呢？

当类与类之间存在着所属关系时，才具备了继承的前提。a是b中的一种，a继承b。狼是犬科中的一种。

继承需要符合的关系是：is-a

注意：不要仅仅为了获取其他类中的已有成员进行继承。

 

继承的特性

1）子类拥有父类非私有的(private)的属性和方法，不能直接访问父类中私有的属性和方法。

2）子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。

3）子类可以用自己的方式实现父类的方法。

4）Java的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，多重继承就是，例如A类继承B类，B类继承C类，所以按照关系就是C类是B类的父类，B类是A类的父类，这是java继承区别于C++继承的一个特性。

5）提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系越紧密，代码独立性越差）。

 

super关键字

super(参数列表)：表示父类的构造方法，并会调用与参数相对应的父类中的构造方法。而super()是在调用父类中空参数的构造方法。

在Java类中使用super来调用父类中的指定操作：

1）super可用于访问父类中定义的属性（可以这样用但没有必要这样用）

2）super可用于调用父类中定义的成员方法（子类覆盖了父类的方法时）

3）super可用于在子类构造方法中调用父类的构造器

 

调用父类的构造器

子类不能继承父类的构造器（构造方法或者构造函数），但子类中所有的构造器默认都会访问父类中空参数的构造器。

当父类中没有空参数的构造器时，子类的构造器必须通过this(参数列表)或者super(参数列表)语句指定调用本类或者父类中相应的构造器，且必须放在构造器的第一行。

如果子类构造器中既未显式调用父类或本类的构造器，且父类中又没有无参的构造器，则编译出错。

 

为什么子类对象初始化时，都需要调用父类中的构造方法？即为什么要在子类构造函数的第一行加入这个super()?

因为子类继承父类，会继承到父类中的数据，所以必须要看父类是如何对自己的数据进行初始化的。所以子类在进行对象初始化时，先调用父类的构造方法，这就是子类的实例化过程。

 

this和super的区别

区别点	this	super
访问属性	访问本类中的属性，如果本类没有此属性则从父类中继续查找	访问父类中的属性
调用方法	访问本类中的方法	直接访问父类中的方法
调用构造器	调用本类构造器，必须放在构造器的首行	调用父类构造器，必须放在子类构造器的首行
特殊	表示当前对象	无此概念

 

注意：    

1）子父类中通常是不会出现同名成员变量的，因为父类中只要定义了，子类就不用定义了，直接继承过来用就可以了。

2）子类构造方法运行时，会先运行父类的构造方法。因为子类的所有构造方法中的第一行，其实都有一条隐身的语句super()。

3）如果父类中没有空参数的构造方法，那么子类的构造方法内，必须通过super语句指定要访问的父类中的构造方法。

4）如果子类的构造方法中用this来指定调用子类自己的构造方法数，那么被调用的构造方法也一样会访问父类中的构造方法。

5）super()和this()是不可以同时出现的构造方法中。因为两个语句只能有一个定义在第一行，所以只能出现其中一个。

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

7）尤其当子父类出现同名成员时，可以用super进行区分。

8）super的追溯不仅限于直接父类。

9）super和this的用法相像，this代表本类对象的引用，super代表父类的内存空间的标识。

 

方法的重写（覆盖）

在子类中可以根据需要对从父类中继承来的方法进行改造，也称方法的重置、覆盖。在程序执行时，子类的方法将覆盖父类的方法。

什么时候使用覆盖呢？当一个类的功能内容需要修改时，可以通过覆盖来实现。

重写的要求：

1）重写方法必须和被重写方法具有相同的方法名称、参数列表和返回值类型。

2）重写方法不能使用比被重写方法更严格的访问权限。

3）重写和被重写的方法须同时为static的，或同时为非static的

4）子类方法抛出的异常不能大于父类被重写方法的异常

 

Java 中的方法重写(Overriding)和方法重载(Overloading)是什么意思？ 

1）Java 中的方法重载发生在同一个类里面两个或者是多个方法的方法名相同但是参数（参数的个数或者参数的类型）不同的情况。

2）与此相对，方法重写是说子类重新定义了父类的方法。方法重写必须有相同的方法名，参数列表和返回类型。覆盖者可能不会限制它所覆盖的方法的访问。

 

final类和方法

final 关键字声明类可以把类定义为不能继承的，即最终类；或者用于修饰方法，该方法不能被子类重写。

// 声明类，该类不能被继承
final class 类名 { 类体 }  

// 声明方法，该方法不能被重写
修饰符 (public/private/default/protected) final 返回值类型 方法名(){ 方法体 }

实例变量也可以被定义为 final，被定义为 final 的变量不能被修改。被声明为 final 类的方法自动地声明为 final，但是实例变量并不是 final。