Java学习之继承

1、继承介绍

---

继承就好比一个A和一个B，A中有着一些属性和方法，而B也想要拥有A中的某些属性或方法就要用到继承

1.1代码演示

//现有两个类Zi类和Fu类，它们有着自己的方法或属性，现在子类想要使用父类中的方法或属性就需要继承
public class Fu {
    //父类
    public int age = 30;
    public void show() {
        System.out.println("父类的show方法");
    }
}
----------------------------------------------------------------------------------------
//子类想要继承父类的方法可以通过extends关键字
public class Zi extends Fu {
    //子类
    public int height = 165;
    public int age = 18;

    public void zshow() {
        System.out.println("子类的zshow方法");
    }

    public void show_ha() {
        int age = 20;
        System.out.println("身高：" + height);
        System.out.println("年龄：" + age);
    }
}
----------------------------------------------------------------------------------------
   //使用类
    public class Demo_1 {
    public static void main(String[] args) {
        //调用两个类中的方法
        Fu f = new Fu();
        f.show();
        Zi z = new Zi();
        z.zshow();
        //在子类调用父类的方法
        z.show();
    }
}
/*
    上面会输出Fu类中的show方法中的内容
    Zi类则会输出自己zshow方法中的内容还会在输出Fu类中的show方法中的内容
*/
//使用继承特性访问Fu类中的变量
public class Demo_2 {
    public static void main(String[] args) {
        //调用子类的方法查看身高年龄
        Zi z = new Zi();
        z.show_ha();
        /*
            继承中变量的访问特点
            在子类方法中访问一个变量其查找顺序为
            1- 子类局部范围查找
            2- 子类成员范围查找
            3- 父类成员范围查找
            4- 如果没有就报错(不考虑父亲的父亲...)
         */
    }
}

2、super关键字

---

依旧是上面的代码，现在提出要求需要访问 ==Zi类==中的成员变量，以及父类中的成员变量

2.1代码演示

//直接对Zi类进行修改分别使用this关键字和super关键字即可
public class Zi extends Fu {
    //子类
    public int height = 165;
    public int age = 30;
    public void zshow() {
        System.out.println("子类的zshow方法");
    }

    public void show_ha() {
        int age = 20;
        System.out.println("身高：" + height);
        //访问局部变量的写法
        System.out.println("年龄：" + age);
        //访问成员变量的写法
        System.out.println("年龄：" + this.age);
        //访问父类变量的写法
        System.out.println("年龄：" + super.age);
    }

2.2super关键字总结

super关键字的用法和this关键字的用法相似

• this：代表本类对象的引用
• super：代表父类存储空间的标识(可以理解为父类对象的引用)

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

3.继承中构造方法访问特点

依旧引用顶部的代码

---

3.1代码演示

//无参Fu类构造方法
    public Fu(){
        System.out.println("Fu类无参构造方法");
    }
    //带参Zi类构造方法
    public Fu(int age){
        System.out.println("Fu类带参构造方法");
    }
//无参Zi类构造方法
    public Zi(){
        System.out.println("Zi类无参构造方法");
    }
    //带参Zi类构造方法
    public Zi(int age){
        System.out.println("Zi类带参构造方法");
    }
//调用构造方法
public class Demo_4 {
    public static void main(String[] args) {
        //分别掉用Zi类和Fu类中的构造方法
        Zi z = new Zi();
        Zi z_2 = new Zi(1);
    }
}
//掉用后会这样输出是为什么呢？
/*
    Fu类无参构造方法
    Zi类无参构造方法
    Fu类无参构造方法
    Zi类带参构造方法
*/

3.1继承构造方法总结

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

子类中所有的构造方法默认都会访问父类中的无参构造方法，这是为什么呢？

• 因为子类会继承父类中的数据，可能还会使用父类的数据。所以，子类初始化之前，一定要先完成父类中的数据初始化
• 每一个子类构造方法的第一条语句默认就是super()（只是默认隐藏了而已）

如果父类中没有无构造构造方法，只有带参构造方法，该怎么办呢？

• 通过使用super关键字去显示的调用父类的带参构造方法
• 在父类中自己提供一个无参构造方法

推荐：自己给出无参构造方法

4.继承中成员方法的调用特点

依旧引用顶部的代码

---

4.1代码演示

//Fu类
public void show() {
        System.out.println("父类的show方法");
    }
//Zi类
public void show() {
        System.out.println("子类的show方法");
    }
public void zshow() {
        System.out.println("子类的zshow方法");
    }
//调用方法
public class Demo_5 {
    public static void main(String[] args) {
        //继承中调用成员方法
        Zi z = new Zi();
        z.zshow();
        z.show();
    }
}
//会输出
/*
	子类的zshow方法
    父类的show方法
    子类的show方法
*/

4.2继承中调用成员方法总结

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

通过子类对象访问一个方法，其顺序为

• 子类成员范围查找
• 父类成员范围查找
• 如果没有就报错(不考虑父亲的父亲…)

5.继承中方法的重写

---

5.1方法重写概述

• 子类中出现和父类中一模一样的方法声明

5.2方法重写的应用

• 当子类需要父类的功能，而功能主体子类有自己持有的内容时，可以重写父类中的方法，这样，既 延续了父类的功能，又定义了子类持有的内容
• 练习：手机类和新手机类

public class Phone {
    //手机父类
    public void call(String name) {
        System.out.println("给" + name + "打电话");
    }
}
-----------------------------------------------------------------------------------------
public class NewPhone extends Phone {
    //新手机子类
    @Override //如果下方重写方法在父类中不存在则会显示红色虚线
    public void call(String name) {
        System.out.println("打开视频功能");
        super.call(name);
    }
}
-----------------------------------------------------------------------------------------
    public class Demo_6 {
    public static void main(String[] args) {
        //测试调用手机类
        Phone c = new Phone();
        c.call("小明");
        NewPhone c_2 = new NewPhone();
        c_2.call("小红");
    }
}
//输出
/*
	给小明打电话
	打开视频功能
	给小红打电话
*/

ps：上面用到的@Override

• 是什么：是一个注解(后面会详细说到)
• 可以干嘛：可以帮助检查重写方法的方法声明的正确性

6.方法重写的注意事项

---

• 私有方法(指的是被private关键字修饰的方法)不能被重写（父类私有成员子类是不能继承的）

• 子类方法访问权限(指的是如果父类中用了默认修饰符，那么子类要么和父类同权限要不就要比父类要高)不能低于父类

6.1代码演示

public class Fu {
    private void show(){
        System.out.println("这是父类中的私有方法");
    }
    void call(){
        System.out.println("这是父类中默认修饰的方法");
    }
}

public class Zi extends Fu {
    @Override  //这里会报错：Method does not override method from its superclass
    public void show(){
        System.out.println("这是父类中的私有方法,在子类中无法使用");
    }
    //要不就下面这种要不就加上public修饰符，总之权限必须高于父类
    void call(){
        System.out.println("这是父类中默认修饰的方法,共有两种方式可访问");
    }
}

7.Java中继承的注意事项

---

• Java中类只支持单继承，不支持多继承
• Java中类支持多层继承

7.1代码演示

public class Granddad{
    public void drink(){
        System.out.println("爷爷爱喝酒");
    }
}
public class Father extends Granddad{
    public void smoke(){
        System.out.println("爸爸爱抽烟");
    }
}
public class Mother{
    public void dance(){
        System.out.println("妈妈爱跳舞");
    }
}
public class Son extends Father{
    
}
//以上是正确的多层继承方法：儿子继承父亲————父亲继承祖父
/*
	public class Son extends Father,Mother{
		
	}
*/
//上面这个是错误的继承法因为Java中不支持多继承

8.继承之学生与老师案例

---

8.1代码演示

8.1.1创建人——类

public class Person {
    private String name;
    private int age;

    Person() {
    }

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

8.1.2创建老师类

public class Teacher extends Person {
    //为教师类创建无参构造方法
    public Teacher() {
    }

    //为教师类创建带参构造方法
    public Teacher(String name, int age) {
        super(name, age);
    }

    public void tech() {
        System.out.println("教书育人");
    }
}

8.1.3创建学生类

public class Student extends Person {
    public Student (){

    }

    public Student(String name, int age) {
        super(name, age);
    }

    public void study(){
        System.out.println("我是学生，我爱学习");
    }
}

8.1.4创建测试用类

//测试类
public class Person_Test {
    public static void main(String[] args) {
        //创建老师类对象
        //无参构造方法
        Teacher t_1 = new Teacher();
        t_1.setName("小明");
        t_1.setAge(23);
        System.out.println("教师姓名：" + t_1.getName() + "\t年龄：" + t_1.getAge());
        t_1.tech();
        //带参构造方法
        Teacher t_2 = new Teacher("小红", 20);
        System.out.println("教师姓名：" + t_2.getName() + "\t年龄：" + t_2.getAge());
        t_2.tech();
        //创建学生类对象
        //无参构造方法
        Student s_1 = new Student();
        s_1.setName("小兰");
        s_1.setAge(18);
        System.out.println("学生姓名：" + s_1.getName() + "\t年龄：" + s_1.getAge());
        s_1.study();
        //带参构造方法
        Student s_2 = new Student("小黄", 19);
        System.out.println("学生姓名：" + s_2.getName() + "\t年龄：" + s_2.getAge());
        s_2.study();
    }
}
//输出结果
/*
    教师姓名：小明	年龄：23
    教书育人
    教师姓名：小红	年龄：20
    教书育人
    学生姓名：小兰	年龄：18
    我是学生，我爱学习
    学生姓名：小黄	年龄：19
    我是学生，我爱学习
*/

赏

谢谢你请我吃糖果