【面向对象】一文了解Java继承（超详细、超有趣）

引子

在具体讲解之前，先看下面两个程序（查看注释可以更加快速地浏览程序）

public class Person {
    private String name;
    private int age;
    private String sex;
	//构造器
	public Person(){}
	public Person(String name, int age, String sex) {
        this.name = name;
        this.age = age;
        this.sex = sex; 
	}
	//name的访问器
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {

        return name;
    }
	//age的访问器
    public void setAge(int age) {
        this.age = age;
    }
    public int getAge() {
        return age;
    }
	//sex的访问器
    public void setSex(String sex) {
        this.sex = sex;
    }
    public String getSex() {
        return sex;
    }
}

public class Student{
    private String name;
    private int age;
    private String sex;
    private double chinese;
    private double math;
    private double english;
	//构造器
	public Student(){}
	public Student(String name, int age, String sex, double chinese, double math, double english) {
        this.name = name;
        this.age = age;
        this.sex = sex;
        this.chinese = chinese;
        this.math = math;
        this.english = english;
    }
	//name的访问器
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
	//age的访问器
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
	//sex的访问器
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
	//Chinese的访问器
    public void setChinese(double chinese) {
        this.chinese = chinese;
    }
    public double getChinese() {
        return chinese;
    }
	//Math的访问器
    public void setMath(double math) {
        this.math = math;
    }
    public double getMath() {
        return math;
    }
	//English的访问器
    public void setEnglish(double english) {
        this.english = english;
    }
    public double getEnglish() {
        return english;
    }
}

看完之后，有没有觉得他们非常的相似？
其实，从封装的角度讲，这两个程序是非常标准的。不论是Person类还是Student类都将自身的属性设置为私有，同时还给予了相应的访问器方法和修改器方法。
但是，这两个类的重合度太高了，而且，位于Person类中的所有属性在Student中被全部重新定义了。这就好像是，在进行自我介绍时，说，我是一个人…

如果每个类都必须这样设计的话，程序的代码将会显得有点累赘，开发效率也不是很高。我们希望写出来的代码更加简洁，复用率较高。
Java通过实现继承来解决这样的问题，下面我们来了解一下继承。

何为继承

继承：一种在已有类的基础上构造新类的机制

继承是面向对象的三种特性之一。它和现实世界中的继承概念大同小异。都表示新生儿（新类）会继承父母（已有类）的一些固有属性（外貌特征、姓氏，甚至一些性格特征），同时，新生儿会对父母现有的生活方式（行为）造成一定的影响，甚至会进入新的领域······所有的这些在Java中都有相应的体现，下面我们来了解了解Java中的继承。

超类和子类

在Java中，常常用超类(superclass)或者父类 表示已有的类，使用子类(subclass) 表示构造的新类。

继承的实现

使用extends关键字定义子类。

class subclass extends superclass{
}

例如，让Student类继承Person类

public class Students extends Person {
    private double chinese;
    private double math;
    private double english;

    public Students() {
    }
	public Student(String name, int age, String sex, double chinese, double math, double english) {
        super(name, age, sex);
        this.chinese = chinese;
        this.math = math;
        this.english = english;
    }
    
    public void setChinese(double chinese) {
        this.chinese = chinese;
    }

    public double getChinese() {
        return chinese;
    }

    public void setMath(double math) {
        this.math = math;
    }

    public double getMath() {
        return math;
    }

    public void setEnglish(double english) {
        this.english = english;
    }

    public double getEnglish() {
        return english;
    }
}

下图表示了这种继承关系：

子承父业

在子类继承父类之后，子类便拥有了父类所有的属性、方法。
在创建子类对象时，编译器也会给父类的所有属性、方法分配内存空间。需要注意的是，子类对象只可以访问父类的非私有属性、非私有方法。毕竟，父母也想要有自己的私人小空间。

类的继承层次

在Java中，一个类只能有一个父类，但是可以有多个子类，用专业术语来讲，Java是一种单继承的程序设计语言。这和现实生活中的家庭关系更加相似，所以，Java中的类继承关系也可以使用树形结构表示。

Object类是所有类的祖先类，如果一个类没有显式地继承某一个类，那么它会默认继承于Object

类的继承路径

某一个类的继承路径是指：从祖先类到该类所经过的所有类

Student类的继承路径：Object->Person->Student

青出于蓝——方法重写

有的时候，父类所提供的方法并不能满足我们的实际需求。为了说明这种情况，举个典型的例子：

在Object类中，有一个equals方法，这个方法用于比较两个对象是否相等，来看一下它的源代码

public boolean equals(Object obj) {
        return (this == obj);    
}

这里，代码直接进行this == obj。因为obj是一个引用变量，所以，这个方法将会比较两个引用值是否相等。引用值相等，说明参与比较的双方是同一个对象。

但有的时候，这并不能满足我们的需求。看下面这个例子：

public class StudentTest {
    public static void main(String[] args) {
        StringBuffer s1 = new StringBuffer("李明");
        StringBuffer s2 = new StringBuffer("李明");
        if(s1.equals(s2)){
            System.out.println("他们是同一个人");
        }else{
            System.out.println("他们不是同一个人");    
        }
    }
}

在这个例子中，我们想看看s1和s2是不是同一个人，因为对象只给出了李明这个信息，所以程序应该认为s1 == s2。但是结果却有些不同：

这是因为StringBuffer直接继承了Object类的equals方法，相等的依据仅仅是引用值，而不对对象中存储的值进行比较。

为了满足我们的需求，我们需要为equals方法赋予新的比较规则，在Java中，把这种行为称为方法重写。

方法重写：在子类中重新定义父类的方法。

方法重写有几个必须遵循的规则：

1. 方法签名（方法名和参数类型、参数个数）一样
2. 返回值需要和父类兼容（简单地说，返回值类型必须是该类的继承路径上的一种类）
3. 重写的方法，访问权限不得低于父类的方法

根据这几个规则，我们对Student类中的equals方法进行重写：

public class Student extends Person {
...
    @Override		//可以判断该方法是否被重写
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return Double.compare(student.chinese, chinese) == 0 &&
                Double.compare(student.math, math) == 0 &&
                Double.compare(student.english, english) == 0;
    }
}

在子类中重写方法之后，父类的方法将会被隐藏。这就是说，当子类重写方法之后，子类对象调用方法时，将会调用子类中的方法。

public class StudentTest {
    public static void main(String[] args) {
        Student s1 = new Student("李明",12,"男",88,99,66);
        Student s2 = new Student("李明",12,"男",88,99,66);
        if(s1.equals(s2)){
            System.out.println(s1.getName() + "和" + s2.getName() + "是同一个人");
        }else {
            System.out.println(s1.getName() + "和" + s2.getName() + "不是同一个人");
        }
    }
}

结果为：

创新驱动发展

除了使用父类中的属性、方法之外，子类还可以定义自己的域、方法。这种现象，称为子类扩展功能。

Person可以做的事有很多，但是学生会更加专注地学习，所以在定义学生类时，我们可以引入study方法，让学生类更有特色。

public class Student extends Person {
	//子类中的自定义属性
    private double chinese;
    private double math;
    private double english;

    public Student() {
    }

    public void setChinese(double chinese) {
        this.chinese = chinese;
    }

    public double getChinese() {
        return chinese;
    }

    public void setMath(double math) {
        this.math = math;
    }

    public double getMath() {
        return math;
    }

    public void setEnglish(double english) {
        this.english = english;
    }

    public double getEnglish() {
        return english;
    }
    //自定义方法
    public void study() {
        System.out.println(getName() + "is studing");
    }
    public void study(String s){
        System.out.println(getName() + "is studing " + s);
    }
    
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return Double.compare(student.chinese, chinese) == 0 &&
                Double.compare(student.math, math) == 0 &&
                Double.compare(student.english, english) == 0;
    }

    @Override
    public int hashCode() {
        return Objects.hash(chinese, math, english);
    }
}

命名冲突

让子类自定义属性和方法可以使得类的功能更加丰富，相应地，我们可以自然而然地遇见一个问题——如果子类中的属性/方法和父类中的属性/方法重名，那么，子类对象会调用哪个属性/方法？

我们从三点进行回答：

1. 如果子类中的方法和父类中的方法重名了，且方法签名一样，那么，就属于方法重写，子类对象将会调用自己的方法
2. 如果子类中的方法和父类中的方法重名，但是方法签名不一样，那么，就属于方法重载。
3. 如果子类中的属性名和父类中的属性名重名，父类的属性将会被隐藏，子类进行调用时，调用的是自己的属性。

可以在子类中使用super关键字调用父类的属性或者方法。

后继无人

使用fianl修饰类，那么该类将不可以被继承。

public final class Student extends Person{
...
}

这里将Student类声明称一个final类，那么你将不能将某一个类声明为它的子类。下面的程序是一个错误示例：

public class Undergraduate extends Student{
...
}

final除了可以修饰类，还可以修饰方法和变量。

1. 如果将某个方法声明为final，那么这个方法将不能允许重写。
2. 如果将某个变量声明为final，那么，这个变量的值将不能被修改。

血脉相连——protected修饰符

我们陆续地接触过三种修饰符：public，缺省，private。他们都有着各自的作用域：

这些作用域有一个特点——他们彼此之间都是独立的，没有依赖性。这是封装的一种很好的体现。但是，对于继承而言，便不是那么的友好。
想象一下，如果，子类和父类不在同一个包里，那么，应该怎么相互访问呢？将属性设置为public的话，数据的安全无法得到保证，如果将属性设置为缺省，那么，由于两个类位于不同的包，所以两者不能相互访问。
为了解决这个问题，Java引入了第四种访问权限修饰符——protected。

protected：在缺省的基础上，允许不同包中的父子类相互访问。