面向对象三大特征之二：继承

1.继承是什么：

2.继承的好处

继承概述的总结

1.什么是继承？继承有什么好处？

2.继承的格式是什么样的？

3.继承后子类的特点是什么？

3.继承的设计规范

例子：继承的设计规范：

继承设计规范总结

继承需要满足什么样的设计规范？

4.继承的特点

仔细探索

1.子类是否可以继承父类的构造器？

2.子类是否可以继承父类的私有成员？

3、子类是否可以继承父类的静态成员？

继承的特点总结

继承有哪些特点？

5、继承后：成员访问的特点

就近原则

成员访问特点总结

6.继承后：子类重写方法

方法重写是什么？

方法重写的应用场景：

案例演示

方法重写总结

1.方法重写是什么样的？

2.方法重写建议加上哪个注解，有什么好处？

3.重写方法有哪些基本要求？

7.继承后：子类构造器的特点

子类是如何调用父类构造器的？

特点总结：

8.继承后：子类构造器访问父类有参数构造器

super调用父类有参数构造器的作用：

总结

9、this、super使用总结

1.继承是什么：

Java中提供了一个关键字：extends，用这个关键字，我们可以让一个类和另一个类建立起父子关系。

public class Stuent extends People {

}

以上代码中，Student称作子类（派生类），People称为父类（基类或超类）。

作用：当子类继承父类后，就可以直接使用父类公共的属性和方法了

例子：

//父类：定义了一个公用方法ports
public class People {
    public void ports(){
        System.out.println("父类方法被调用！");
    }
}

//子类：使用extends继承了来自父类的people类
public class Student extends People{

}

public class ExtendsTest01 {
    public static void main(String[] args) {
        Student s = new Student();      //创建student子类对象
        s.ports();              //由于student类继承了people类，所以子类可以调用父类的公用方法
    }
}

控制台输出结果：

2.继承的好处

案例导学：请阅读以下代码存在的问题，并使用继承这个技术进行优化

可以看到，一个是学生类，一个是老师类；他们之间都有着相同的特征：成员变量、方法；
这样的话，重复代码又多了，是一种很不好的现象。

解决：继承（extends）关系；好处：提高代码的复用性。

继承概述的总结

1.什么是继承？继承有什么好处？

继承就是Java允许我们用extends关键字，让一个类与另一个类建立起一种父子关系；

好处是减少代码冗余，提高了代码的复用性，增强类的功能扩展性。

2.继承的格式是什么样的？

子类extends父类

3.继承后子类的特点是什么？

子类继承父类后，子类可以得到父类的属性和方法，子类可以使用；

Java中子类更强大：因为子类不仅得到父类的属性和方法，还能不断扩展。

3.继承的设计规范

子类们相同的特征（共性属性，方法）放在父类中定义，子类独有的属性和方法应该定义在子类自己里面

为什么？
如果子类的独有属性，方法定义在父类中，会导致其他子类也会得到这些属性和方法；这不符合面向对象逻辑。

例子：继承的设计规范：

需求：在bilibili教育的tlias教学资源管理系统中，存在学生、老师角色会进入系统。

分析：学生信息和行为（姓名，年龄，所在班级，查看课表，填写听课反馈）；

老师信息和行为（姓名，年龄，部门名称，查看课表，发布问题）；

定义角色类作为父类包含学生和老师相同的属性（姓名，年龄），行为（查看课表）；

定义学生类（子类）：包含属性（所在班级），行为（填写听课反馈）；

定义老师类（子类）：包含属性（部门名称），行为（发布问题）。

定义角色类，作为父类

父类：

//人类：父类
// 包含了子类相同的属性和行为
public class People02 {
//    1.定义需求中子类们相同的属性
    private String name;
    private int age;
//    2.提供属性对应的getter，setter方法，暴露其取值和赋值
    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
//    3.定义子类们相同的行为方法：查看课表
    public void queryCourse(){
        System.out.println(name+"查看了课表");
    }
}

定义学生子类，继承父类：

//学生类：子类继承People02父类得到属性和行为
public class Student02 extends People02{
//    1.定义学生子类自己独有的属性
    private String className;

//    2.提供属性的getter和setter方法，暴露其取值和赋值
    public String getClassName() {
        return className;
    }

    public void setClassName(String className) {
        this.className = className;
    }
//    3.定义子类自己独有的行为方法：填写听课反馈
    public void writeInfo(){
        System.out.println(className+"的"+getName()+"对老师给出极高的评价！");
    }
}

定义教师子类，继承父类：

//教师类：子类 继承父类得到属性和行为
public class Teacher02 extends People02{
//    1.定义子类自己的独有属性
    private String departmentName;

//    2.提供属性对应的getter，setter方法，暴露其取值和赋值
    public String getDepartmentName() {
        return departmentName;
    }

    public void setDepartmentName(String departmentName) {
        this.departmentName = departmentName;
    }
//    3.定义子类自己独有的行为方法：发布问题
    public void problem(){
        System.out.println(departmentName+"的"+getName()+"老师问：这节课教的怎么样？");
    }
}

定义一个测试类：

/**
 需求：
 在bilibili教育的tlias教学资源管理系统中，存在学生、老师角色会进入系统。
 分析：
 学生信息和行为（姓名，年龄，所在班级，查看课表，填写听课反馈）；
 老师信息和行为（姓名，年龄，部门名称，查看课表，发布问题）；
 定义角色类作为父类包含学生和老师相同的属性（姓名，年龄），行为（查看课表）；
 定义学生类（子类）：包含属性（所在班级），行为（填写听课反馈）；
 定义老师类（子类）：包含属性（部门名称），行为（发布问题）。
 定义角色类，作为父类
 **/
//继承测试类
public class ExtendsTest02 {
    public static void main(String[] args) {
//        1.创建学生对象
        Student02 s = new Student02();
//        1.1调用父类行为方法写入学生信息
        s.setName("海绵宝宝");
        s.setAge(36);
//        1.2调用学生类自己的方法写入所在班级
        s.setClassName("19级比奇堡驾校一班");
//        1.3调用父类的行为方法：查看课表
        s.queryCourse();
        System.out.println("---------------");

//        2.创建教师对象
        Teacher02 t = new Teacher02();
//        2.1调用父类行为写入教师信息
        t.setName("泡芙");
        t.setAge(55);
//        2.2调用教师类自己的方法写入部门名称
        t.setDepartmentName("比奇堡驾校金牌教练组");
//        2.3调用父类的行为方法：查看课表
        t.queryCourse();
        System.out.println("---------------");

//        3.调用教师子类自己独有的方法：problem 发布问题
        t.problem();
//        4.调用学生子类自己独有的方法：writeInfo 填写反馈
        s.writeInfo();

    }
}

控制台输出结果：

继承设计规范总结

继承需要满足什么样的设计规范？

子类们相同特征：共性属性，共性方法；都放在父类中定义；

子类独有的属性，方法；应该定义在子类自己里面。

4.继承的特点

子类可以继承父类的属性和行为，但是子类不能继承父类的构造器；

Java是单继承模式：一个类只能继承一个直接父类；

就是你只能有一个亲爸，不可能隔壁的老王叔、老杨叔 … 都是你的亲爸吧？
那从伦理角度看，肯定是不支持，但是从Java的角度呢？

为何不支持多继承，请看如下反证法：

Java不支持多继承，但是支持多层继承；

就是你不可以继承多个爸爸；但是你可以继承你爸的，你爸可以继承你爷爷的，多层继承；

比如：子类A 继承父类B；父类B 可以继承父类 C。

Java中所有的类都是Object类的子类。

Java中所有的类，要么是直接继承了Object类，要么默认继承了Object类，要么间接继承了Object类；

所以说，Object是祖宗类。

仔细探索

1.子类是否可以继承父类的构造器？

不可以的，子类有自己的构造器，父类构造器用于初始化父类对象。

2.子类是否可以继承父类的私有成员？

这是个有争议的知识点！！
我个人认为是可以的，只是不能直接访问：
- 就好比，你爸给了你一个保险柜，你是不是已经继承了这个保险柜？
- 然后你忘记保险柜密码了，难道你说你没有继承你爸的保险柜？
- 那忘记密码了，当然也有暴力手段来打开这个保险柜；
- 所以呢，后续我也会带着大家去打开这个保险柜的。

3、子类是否可以继承父类的静态成员？

这是个有争议的知识点！！
子类可以访问到父类的静态成员，但是我个人认为这不算继承，只是属于共享：
- 就好比，你爸有辆车，他给你开了一下，但是你能说继承你爸的车了吗？
- 所以，子类不能继承父类的静态成员，共享并非继承。

/**
 继承测试类
 目标：理解继承的特点
 **/
public class ExtendsTest03 {
    public static void main(String[] args) {
        // 1、子类可以继承父类的属性和行为，但是子类不能继承父类的构造器；
        // 2、子类是否可以继承父类的私有成员？ 我认为是可以继承父类私有成员的，只是不能直接访问。
        Tiger t = new Tiger();
//        t.eat();
        // 3、子类是否可以继承父类的静态成员？ 子类可以访问到父类的静态成员，但我认为这是共享，不算继承，共享并非继承。
        System.out.println(Tiger.location);
    }

}
/**
 动物类：作为父类
 **/
class Animal{
    private void eat(){
        System.out.println("动物要吃东西");
    }
    public static String location = "长隆动物园";
}
/**
 老虎类：作为子类继承父类
 **/
class Tiger extends Animal{
}

继承的特点总结

继承有哪些特点？

子类可以继承父类的属性和方法，但是子类不能继承父类的构造器；
Java是单继承模式：一个类只能继承一个直接父类；
Java不支持多继承，但是支持多层继承；
Java中所有的类都是Object类的子类，Object是祖宗类。

5、继承后：成员访问的特点

就近原则

在子类方法中访问成员（成员变量、方法）满足：就近原则。
- 先在子类局部范围找；
- 然后在子类成员范围找；
- 然后在父类成员范围找，如果父类范围还没有找到则报错。

如果子父类中，出现重名的成员，会优先使用子类的，此时如果一定要在子类中使用父类的成员怎么办？

可以通过super关键字，指定访问父类的成员。

格式：

super.父类成员变量/方法

package extendsTest;

public class ExtendsTest04 {
    /**
     继承测试类
     目标：理解继承后成员的访问特点：就近原则
     */
        public static void main(String[] args) {
            // 创建狗对象
            Dog dog = new Dog();

            dog.eat();          // 在子类中找不到此方法，在父类中找到了，所以是父类的
            dog.lookDoor();     // 在子类中找到了，就近原则，所以是子类的
            dog.showName();     // 在子类中找到了，就近原则，所以是子类的
            //dog.go();         // 在子类中找不到，在父类中依旧找不到，无此成员，报错！！
        }
    }


    /**
     定义父类：动物类
     */
    class Animal{
        public String name = "动物名";

        public void eat() {
            System.out.println("动物要吃东西！！！");
        }

        public void run() {
            System.out.println("动物可以跑~~~");
        }
    }


    /**
     定义子类：狗类 继承父类Animal
     */
    class Dog extends Animal{
        public String name = "狗名";


        public void run() {
            System.out.println("狗跑得贼快~~~");
        }

        public void lookDoor() {
            System.out.println("狗可以看门~~~");
        }


        public void showName() {
            String name = "局部名";

            // 在子类局部范围中找到了name，就近原则，所以不会去子类成员范围和父类成员范围找
            System.out.println(name);

            // this.name: 代表找当前子类成员范围的name
            System.out.println(this.name);

            // super.name: 代表找父类成员范围的name
            System.out.println(super.name);

            run();          // 子类成员范围的run()
            super.run();    // 父类成员范围的run()
        }
    }

成员访问特点总结

1.在子类方法中访问成员（成员变量、方法）需要满足什么？

就近原则，子类局部没有找子类，子类没有找父类，父类没有就报错！

2.如果子类和父类中出现了重复的成员，此时如果一定要在子类中使用父类的成员该如何？

使用：super.父类的成员变量/方法。

6.继承后：子类重写方法

方法重写是什么？

在继承体系中，子类出现了和父类中一模一样的方法申明，我们就称子类的这个方法是重写的方法。

方法重写的应用场景：

当子类需要父类的方法，但父类的该方法功能不能满足自己的需求时，需要重写方法来改变成能满足自己需求的功能。

子类可以重写父类中的方法。

案例演示

旧手机的功能只能是基本的打电话，发信息；
新手机的功能需要能够：基本的打电话下支持视频通话。基本的发信息下支持发送语音和图片。

/**
 继承测试类
 目标：理解重写方法
 **/
public class PhoneExtendsTest {
    public static void main(String[] args) {
        NewPhone sj = new NewPhone();           //创建手机对象
        //新手机功能
        sj.callUp();
        System.out.println();
        sj.sendMessage();
    }
}
//旧手机：父类
class Phone{
    public void callUp(){
        System.out.println("打电话~~~");
    }
    public void sendMessage(){
        System.out.println("发短信~~~");
    }
}
//新手机：子类，继承了父类
class NewPhone extends Phone{
    //重写的方法
    public void callUp(){
        super.callUp();
        //在子类爸爸原本的功能的基础上开发新功能
        System.out.println("开始视频通话~~~");
    }
    //重写的方法
    public void sendMessage(){
        //先用子类爸爸的功能
        super.sendMessage();
        //在子类爸爸原本功能的基础上开发新功能
        System.out.println("发送语音~~~");
        System.out.println("发送图片~~~");
    }
}

控制台输出结果：

@Override重写注解

@Override是放在重写后的方法上，作为重写是否正确的校验注解。
加上该注解后如果重写错误，编译阶段会出现错误提示。
以后重写父类的方法都建议加上 @Override注解，代码可读性好、更安全、优雅。

方法重写的注意事项和要求

重写方法的名称、形参列表必须与被重写方法的名称和形参列表一致；

私有方法不能被重写；

子类重写父类方法时，访问权限必须大于或者等于父类（暂时了解：缺省 < protected < public）

语法了解一下，认识一下。
因为在实际开发中，子类重写的方法和父类方法是一模一样的，所以权限是等于父类的，不用乱改。

子类不能重写父类的静态方法，如果重写会报错的。

方法重写总结

1.方法重写是什么样的？

子类中写一个与父类申明一样的方法覆盖父类的方法。

2.方法重写建议加上哪个注解，有什么好处？

建议加上：@Override重写方法检验注解；

可以校验重写方法是否正确，好处：可读性好、更安全、优雅

3.重写方法有哪些基本要求？

重写方法的名称和形参列表必须与被重写方法一致；

私有方法不能被重写；

子类重写父类方法时，访问权限必须大于或者等于父类被重写方法的访问权限；

子类不能重写父类的静态方法，否则会报错。

7.继承后：子类构造器的特点

子类中所有的构造器默认都会访问父类中的无参数构造器，再执行自己。

//动物类：父类
public class Animal {
    public Animal(){
        System.out.println("父类Animal无参数构造器被执行");
    }
}

//狗类：子类
public class Dog extends Animal{
    public Dog(){
        System.out.println("子类Dog无参数构造器被执行----");
    }
    public Dog(String name){
        System.out.println("子类dog有参数构造器被执行-----");
    }
}

/**
 继承测试类
 目标：理解继承后，子类构造器的特点
 特点：子类中所有的构造器默认都会先访问父类的无参数构造器后，再执行自己
 */
public class ExtendsTest {
    public static void main(String[] args) {
        Dog d1 = new Dog();
        System.out.println(d1);
        System.out.println("------------");
        Dog d2 = new Dog("小鸡毛");
        System.out.println(d2);
    }
}

控制台输出结果：

为什么？

子类在初始化的时候，有可能会使用到父类中的数据，如果父类没有完成初始化，子类将无法使用父类的数据；

子类在初始化之前，一定要调用父类构造器先完成父类数据的初始化；

通俗点讲：儿子想出生，得先有个爸爸才能出生。

子类是如何调用父类构造器的？

子类构造器的第一行语句默认是：super()，不写也是默认的存在。

特点总结：

子类继承父类后构造器的特点是什么样的？

子类中所有的构造器默认都会先访问父类的无参数构造器，再执行自己。

8.继承后：子类构造器访问父类有参数构造器

super调用父类有参数构造器的作用：

初始化继承自父类的数据。

//人类：父类
public class SuperPeople {
    private String name;
    private int age;

    public SuperPeople() {
    }

    public SuperPeople(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

//老师类：子类
public class SuperTeacher extends SuperPeople {
    public SuperTeacher(String name,int age){
        super(name, age);
    }
}

//    继承测试类
//    目标：学习子类构造器如何去访问父类有参数构造器，还要清楚其作用！
//    作用：提高代码的复用性、编程更简洁
public class SuperExtendsTest {
    public static void main(String[] args) {
        SuperTeacher t = new SuperTeacher("泡芙阿姨", 55);
        System.out.println(t.getName());
        System.out.println(t.getAge());
    }
}

控制台输出结果：

如果父类中没有无参构造器，只有有参构造器，会出现什么现象？

会报错。因为子类默认是调用父类中的无参数构造器的。

如何解决？

子类构造器中可以通过书写super(…)，手动调用父类的有参构造器；
也可以手动将父类的无参数构造器写出来。

总结

super调用父类构造器的作用是什么？

通过调用父类中的有参数构造器来初始化继承自父类的数据。

9、this、super使用总结

this代表本类对象的引用；super代表父类存储空间的标识。

关键字	访问成员变量	访问成员方法	访问构造方法
this	this.成员变量访问本类成员变量	this.成员方法(...) 访问本类成员方法	this(...) 访问本类构造器
super	super.成员变量访问父类成员变量	super.成员方法(...) 访问父类成员方法	super(...)

关键字

访问成员变量

访问成员方法

访问构造方法

this

this.成员变量

访问本类成员变量

this.成员方法(...)

访问本类成员方法

this(...)

访问本类构造器

super

super.成员变量

访问父类成员变量

super.成员方法(...)

访问父类成员方法

super(...)

实际上，唯独只有this调用本类其他构造器我们是没有接触过的。

案例需求：

在学员信息登记系统中，后台创建对象封装数据的时候如果用户没有输入学校，则默认使用 “bilibili培训中心”。
如果用户输入了学校则使用输入的学校信息。

public class ThisStudent {
    private String name;
    private String schoolName;

    public ThisStudent() {
    }

    public ThisStudent(String name, String schoolName) {
        this.name = name;
        this.schoolName = schoolName;
    }

    public String getName() {
        return name;
    }

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

    public String getSchoolName() {
        return schoolName;
    }

    public void setSchoolName(String schoolName) {
        this.schoolName = schoolName;
    }

    /**
     当学生只输入姓名，不输入学校名称的时候，默认选择 "bilibili培训中心"
     */
    public ThisStudent(String name) {
        this(name,"bilibili大学");
    }

}

/**
 测试类
 目标：理解this(...)的作用：本类构造器中访问其他构造器
 */
public class ThisTest {
    public static void main(String[] args) {

        ThisStudent ts1 = new ThisStudent("章鱼哥", "蟹堡王");
        System.out.println(ts1.getName());
        System.out.println(ts1.getSchoolName());
        System.out.println("-------------------");

        //实例2.如果学生不填写学校名称，默认这个学生填写的学校是:bilibili培训中心
        ThisStudent ts2 = new ThisStudent("派大星");
        System.out.println(ts2.getName());
        System.out.println(ts2.getSchoolName());
    }
}

控制台输出结果：

this(…) 和 super(…) 使用的注意点
子类通过 this(…) 去调用本类的其他构造器，本类其他构造器会通过 super 去手动调用父类的构造器，最终还是会调用父类的构造器的。
注意：this(…) 和 super(…) 都只能放在构造器的第一行，所以二者不能存在同一构造器中。