JAVA—继承

继承性：

1.发现问题：

首先我们定义两个描述人与学生的类：
人：

class Person {
    private String name ;
    private int age ;
    public void setName(String name) {
        this.name = name ;
    }
    public void setAge(int age) {
        this.age = age ;
    }
    public String getName() {
        return this.name ;
    }
    public int getAge() {
        return this.age ;
    }

学生：

class Student {
    private String name ;
    private int age ;
    private String school ;
    public void setName(String name) {
        this.name = name ;
    }
    public void setAge(int age) {
        this.age = age ;
    }

    public void setSchool(String school) {
        this.school = school;
    }
    public String getSchool() {
        return this.school
    }

    public String getName() {
        return this.name ;
    }
    public int getAge() {
        return this.age ;
    }

然后我们就会发现其中有很多重复的部分，因为学生本来就属于人，但是学生所表示范围要比人表示的范围小。

继承的实现：

语法：class 子类 extends 父类 {}

说明：
1.对于extends而言，应该翻译为扩充，但为了理解方便，将其称为继承。
2.子类又被称为派生类。
3.父类又被成为超类。
继承的实现：

class Person {
    private String name;
    private int age;

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return this.name;
    }

    public int getAge() {
        return this.age;
    }
}
class Student extends Person {
    private String schoolc;
    public void setSchool(String school) {
        this.school = school;
    }
    public String getSchool() {
        return this.school
    }
    
}

从上述代码中，我们可以看出子类对父类的功能进行了扩充，即子类实际上是将父类定义的更加具体化的一种手段。父类表示的范围大，子类表示的范围小。

继承的限制：

1.java中不允许多重继承，但是允许多层继承。
错误：

class A {}
class B {}
class C extends A,B {}

本程序是希望C同时继承A，B，但java并不允许存在这样多重继承。
但我们可以利用多层继承：

class A {}
class B extends A {}
class C extends B {}

2.在子类对象构造前一定会默认调用父类的构造（默认使用无参构造），以保证父类的对象先实例化，子类对象后实例化。

class A {
    public A() {
        System.out.println("A.A类的构造方法！");
    }
}
class B extends A {
    public B() {
        System.out.println("B.B类的构造方法！");
    }
}
public class Demo{
    public static void main(String args[]) {
        new B();
    }
}
	

new B()的：实例化子类对象。
程序执行结果：

A.A类的构造方法！
B.B类的构造方法！

本程序虽然实例化的是子类对象，但是发现它会默认先执行父类构造。这时，对于子类的构造而言，相当于隐含了super()语句的调用。
子类隐含语句：

class B extends A {
    public B() {
    	super() ;
        System.out.println("B.B类的构造方法！");
    }
}

当父类提供有无参构造方法时，是否编写super()没有区别。但如果，父类中没有无参构造方法，则必须明确地使用super()调用父类指定参数地构造方法。
代码如下：

class A {
    public A(String title) {
        System.out.println("A.A类的构造方法！title=" + title);
    }
    
}
class B extends A {
    public B(String title) {
        super(title)
        System.out.println("B.B类的构造方法！");
    }
}
public class Demo{
    public static void main(String args[]) {
        new B("Hello") ;
    }
}

程序执行结果：

A.A类的构造方法！title=Hello
B.B类的构造方法！