Java面向对象编程10 继承的定义与使用

继承的定义与使用

继承问题引出

面向对象的第二大特征就是继承性，继承性的主要特点在于:可以扩充已有类的功能。
所谓的良好的代码指的是结构性合理、适合于维护、可重用性很高，但是如果只是安装之前的程序设计，不可避免会面临重复问题：以人类和学生类为例

public 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;
    }
}

public 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 getName(){
        return this.name;
    }
    public int getAge(){
        return this.age;
    }
    public String getSchool(){
        return this.school;
    }
}

这个时候可以发现虽然类的概念可以解决结构性的问题，但是对于之前的开发的程序代码总能够发现有一些重复的代码出现在程序之中，并且可以观察得出：学生是一个人，人是一个更加广泛的定义范畴，而学生是一个相对狭小的定义范畴。那么学生就应该包含所有人的所有特点，如果想进行代码的重用，那么就必须使用继承的概念，所谓的继承的本质:在已有类的功能上继续进行功能的扩充。

继承的实现

class 子类 extends 父类{}
特别需要注意的是，很多情况下会把子类称为派生类，把父类称为超类(SuperClass)

public 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;
    }
}

public class Student extends Person{//Student是子类
    //子类中不定义任何的功能
}
​
public class JavaDemo{
    public static void main(String[] args){
        Student stu = new Student();
        stu.setName("张三");
        stu.setAge(68);
        System.out.println("姓名："+stu.getName()+"、年龄："+stu.getAge());
    }
}

所以此时的子类即便没有定义任何的操作，那么也可以直接通过父类继承而来的方法实现。
继承实现的主要目的是在于子类可以重用父类中的结构，并且也可以实现功能的扩充
同时强调：子类可以定义更多的内容，并且描述的范围更小。

public class Student extends Person{//Student是子类
   private String school;
    public void setSchool(String school){
        this.school = school;
    }
    public String getSchool(){
        return this.school;
    }
}
​
public class JavaDemo{
    public static void main(String[] args){
        Student stu = new Student();
        stu.setName("张三");
        stu.setAge(68);
        stu.setSchool("清华大学");
        System.out.println("姓名："+stu.getName()+"、年龄："+stu.getAge()+"、学校"+stu.getSchool());
    }
}

子类对象实例化流程

现在已经成功的实现了继承关系，并且也已经发现了继承主要特点,但是一旦程序之中提供有继承逻辑，那么对于子类对象的实例化定义是由要求的。

class Person{
    public Person(){
        System.out.println("[父类]");
    }
}
class Student extends Person{//Student是子类
    public Student(){//构造器
        System.out.println("[子类]");
    }
}
​
public class JavaDemo{
    public static void main(String[] args){
        new Student();//实例化子类对象
    }
}
程序执行结果===================================
    [父类]
    [子类]

现在即使没有进行父类对象实例化，也会由系统自动调用父类的构造方法(实例化父类对象），默认情况下的子类对象实例化流程会自动创建父类对象。实际上这个时候就相当于子类的构造方法里面隐含了一个“super()”的形式。

class Person{
    public Person(){
        System.out.println("[父类]");
    }
}
class Student extends Person{//Student是子类
    public Student(){//构造器
        super();//写不写效果一样
        System.out.println("[子类]");
    }
}
​
public class JavaDemo{
    public static void main(String[] args){
        new Student();//实例化子类对象
    }
}
程序执行结果===================================
    [父类]
    [子类]

super()表示的就是子类构造调用父类构造的语句，该语句只允许放在子类构造方法的首行。在默认情况下的实例化处理，子类只会调用父类中的无参构造方法，所以写与不写“super()”区别不大，但是如果说你的父类里面没有提供无.参构造，这个时候必须利用super（）明确调用父类的构造器

class Person{
    private String name;
    private int age;
    public Person(String name,int age){
		this.name = name;
        this.age = age;
    }
}
class Student extends Person{//Student是子类
    private String school;
    public Student(String name , int age ,String school){//构造器
        super(name,age);//明确父类构造
        this.school = school;
    }
}

public class JavaDemo{
	public static void main(String[] args){
		new Student("张三",28,"家里蹲大学");//实例化子类对象
    }
}

结论：无论如何调用，在实例化子类对象的同时一定会实例化父类对象。目的是为了所有的属性可以进行空间分配。

继承定义限制

1. Java之中不允许多重继承，只允许多层继承

//错误的继承：
class A{}
class B{}
class C extends A,B{}//多重继承

继承的主要目的是扩展已有类的功能，多层继承的目的是希望可以同时继承多个类中的方法，而面对多继承的要求应该将范围限定在同一类中，虽然Java中不限制继承的层数，但是在实际操作过程中不会超过3层。

class A{}
class B extends A{}
class C extends B{}//多层继承

2. 在进行继承关系定义的时候，实际上子类可以继承父类中的所有的操作结构。但是对于私有操作属于隐式继承，而所有的非私有操作属于显式继承。

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

class Student extends Person{
    public Student(String name){
        setName(name);//设置name属性
    }
    public void fun(){
        //System.out.println(name);//直接访问不可能，因为属性私有
        System.out.println(getName());//间接访问
    }
}
public class JavaDemo{
    public static void main(String args[]){
        Student stu = new Student("张三");
        stu.fun();
    }
}