面向对象--三大特征--继承

1.继承:继承是面向对象三大特征之一,可以让类与类之间产生子父的关系.

2.继承的格式:Java中提供一个关键字extends,用这个关键字,我们可以让一个类和另一个类建立继承关系.

public class Student extends Person{}

Studnet称为子类(派生类),Person称为父类(基类或者超类).

3.使用继承的好处:

a.可以把多个子类中重复的代码抽取到父类中,提高代码的复用性;

b.子类可以在父类的基础上,增加其他的功能,是子类更加实用,强大.

4.什么时候使用继承:

当类与类之间,存在相同或者共性的内容,并满足子类是父类的一种,就可以考虑使用继承,来优化代码.

public class Animals {
    //定义一个名字变量
    private String name;
    //构造方法，不带参，带参的构造方法在下面
    public Animals(){};
    //带参的构造方法
    public Animals(String name){
        //将传入的字符串赋值给名字变量
        this.name = name;
    }
    //设置名字的方法
    public void setName(String name){
        //将传入的字符串赋值给名字变量
        this.name = name;
    }
    //获取名字的方法
    public String getName(){
        //返回名字变量
        return name;
    }
    //吃的方法
    public void eat(){
        //输出动物名字+"在吃饭!!"
        System.out.println(name + "在吃饭!!");
    }
    //喝的方法
    public void drink(){
        //输出动物名字+"在喝水!!"
        System.out.println(name + "在喝水!!!");
    }

}
class Dog extends Animals{
    public Dog(){};
    public void LookHome(){
        System.out.println("看家");
    }
    public void dismantleHome(){
        System.out.println("拆家");
    }
}
class Cat extends Animals  {
    public Cat(){};
    public void catchMouse(){
        System.out.println("抓老鼠");
    }
}

5.继承后子类的特点:

a.子类可以得到父类的属性和行为,子类可以使用;

b.子类可以在父类的基础上新增其他功能,子类更加强大;

6.继承的特点:Java只支持单继承,不支持多继承,但是支持多层继承.

a.多层继承:子类A继承父类B,父类B可以继承父类C;

b.子类B是子类A的直接父类,父类C是子类A的间接父类,只有间接父类和直接父类两种关系;

c.每个类都直接或间接的继承于Object;

d.子类只能访问父类中非私有的成员.

7.子类继承父类的哪些内容:

只有父类中的虚方法才能被子类继承,虚方法表由非private,非static,非final组成;

8.继承中成员变量的访问特点:就近原则(谁离我近,我用谁)

a.先在局部位置找,本类成员位置找,父类成员位置找,逐级往上;

b.super关键字:调用父类的成员变量,只能使用一次,不能叠加使用

public class Text {
    public static void main(String[] args){
        Zi z = new Zi();
        z.show();
    }
}
class Fu{
    String name = "Fu";
    String hobby = "喝茶";
    
}
class Zi extends Fu{
    String name = "Zi";
    String hobby = "打游戏";
    
    public void show(){
        System.out.println(name) //从局部变量位置开始往上找
        // 打印子类姓名
        System.out.println(this.name); //从本类成员变量位置开始往上找
        // 打印父类姓名
        System.out.println(super.name);  //从父类成员变量位置开始往上找
        // 打印子类爱好
        System.out.println(this.hobby);
        // 打印父类爱好
        System.out.println(super.hobby);
    }
}

9.继承中成员方法的访问特点:

a.this调用:就近原则;

b.super调用:直接找父类.

10.方法的重写:在继承体系中,子类出现类和父类一摸一样的方法声明,我们就称子类这个方法是重写的方法;

a.使用场景:当父类的方法不能满足子类现在的需求时,需要进行方法重写;

b.@Override是放在重写的方法上,校验子类重写时语法是否正确;

c.加上注解后如果有红色波浪线,表示语法错误;

d.建议重写方法都加上@Override注解,代码安全!

11.方法重写的注意事项:

a.重写方法的名称,形参列表必须和父类中的一致;

b.子类重写方法时,访问权限子类必须大于等于父类(空着不写 < protected < public);

c.子类重写方法时,返回值类型子类必须小于等于父类;

d.建议:重写的方法尽量和父类保持一致;

e.只有被添加到虚方法表中的方法才能被重写(私有方法,静态方法不能重写);

f.方法重写的本质:覆盖虚方法表中方法.

public class Text {
    public static void main(String[] args){
        Zi z = new Zi();
        z.show();
        z.lunch();
    }
}
class Fu{
    String name = "Fu";
    String hobby = "喝茶";
    // 定义一个名为eat的 void 方法，功能是输出 "吃米饭"

    public void eat(){
        System.out.println("吃米饭");
    }
    // 定义一个名为drink的 void 方法，功能是输出 "喝水"
    public void drink(){
        System.out.println("喝水");
    }
}
class Zi extends Fu{
    String name = "Zi";
    String hobby = "打游戏";

    @Override
    public void eat(){
        System.out.println("吃面条");
    }
    @Override
    public void drink(){
        System.out.println("喝可乐");
    }
    public void show(){
        // 打印子类姓名
        System.out.println(this.name);
        // 打印父类姓名
        System.out.println(super.name);
        // 打印子类爱好
        System.out.println(this.hobby);
        // 打印父类爱好
        System.out.println(super.hobby);
    }

    public void lunch(){
        //先从本类中查看eat和drink方法,有的话就调用子类的
        //如果没有,就会调用从父类中继承下来的虚方法
        this.eat();
        this.drink();

        super.eat();
        super.drink();
    }
}

12.继承中构造方法的访问特点:

a.父类中的构造方法不会被子类继承,但是可以通过super调用;

b.子类中所有的构造方法默认先访问父类中的无参构造,再执行自己;

原因:

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

子类初始化之前,一定要调用父类构造方法先完成父类数据空间的初始化

c.怎么调用父类构造方法:

子类构造方法(有参构造和无参构造)的第一行语句默认都是:super(),不写也存在,且必须是第一行;

如果想调用父类有参构造,必须手动写super进行调用;

public class Text {
    public static void main(String[] args){
        StudentText s = new StudentText("zhangsan" , 18);
        System.out.println(s.name + "  " + s.age);
    }
}
class PersonText{
    String name;
    int age;
    public PersonText(){
        System.out.println("父类的无参构造");
    };
    public PersonText(String name ,int age){
        this.name = name;
        this.age = age;
    }
}
class StudentText extends PersonText{
    public StudentText(){
        //子类构造方法中隐藏的super()去访问父类的无参构造
        super();
        System.out.println("父类的无参构造");
    }
    public StudentText(String name ,int age){
        //调用父类的构造函数
        super(name,age);
    }


}

13.this,super使用总结:

a.this:理解为一个变量.表示当前方法调用的地址值;

b.super:代表父类储存空间

class PersonText{
    String name;
    int age;
    String school;
    public PersonText(){
//表示调用本类其他构造方法
//细节:在这之后,虚拟机不会添加super();
        this(noll,0,"科技大学");//必须在第一行
    }
    public PersonText(String name ,int age,String school){
        //隐藏的super();
        super()
        this.name = name;
        this.age = age;
        this.school = school;
    }
}