Java面向对象-继承

继承

---

---

前言

理解继承的作用、使用继承、掌握super关键字的使用

---

一、继承的概念

继承是面向对象三大特征之一，可以使得子类具有父类的属性和方法，还可以在子类中重新定义，以及追加属性和方法

父类和子类的概念

1）多个类中存在相同的属性和方法，可以抽取出来，放在一个公共类中，这个公共类称之为父类

2）那么，多个类中就不需要再定义那些相同的属性和方法，只需要通过extends关键字继承父类，就可以使用父类中的属性和方法

3）在这个多个类中只修要定义自己类特有的属性和方法，这多个类称之为子类

二、继承的实现

1、编写父类

访问修饰符 class Pet { 
		// 公共的属性和方法
}

2、编写子类

访问修饰符 class Dog extends Pet {
    	// 子类特有的属性和方法
}

3、直接父类

继承是Java中实现代码重用的重要手段之一

1）Java中类与类之间的继承关系只能是单根继承，即一个类只能有一个直接父类

2）类与类之间可以间接继承：A继承B，B继承C，那么A间接继承C，A可以使用B和C中的属性和方法

4、子类访问父类

1）访问父类构造方法

super(); // 访问父类中的无参
super(name); // 访问父类中的有参

2）访问父类属性

super.name;

3）访问父类方法

super.print()

5、super关键字

1）使用super关键字，super代表父类对象

2）super只能出现在子类的方法和构造方法中

3）super调用构造方法时，必须是第一句

4）不可以访问父类中定义为private的属性和方法

public class Pet {
    // 定义Dog类、Penguin类、Cat类、...等类中相同的代码
    private String name;
    private int health;
    private int love;

    public Pet() {
    }

    public Pet(String name, int health, int love) {
        this.name = name;
        this.health = health;
        this.love = love;
    }

    public String getName() {
        return name;
    }

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

    public int getHealth() {
        return health;
    }

    public void setHealth(int health) {
        this.health = health;
    }

    public int getLove() {
        return love;
    }

    public void setLove(int love) {
        this.love = love;
    }

    // 定义一个方法输出name、health、love属性值
    public void printInfo(){
        System.out.println("昵称："+this.getName()+"，健康值："+this.getHealth()+"，亲密度："+this.getLove());
    }
}

public class Penguin extends Pet{ // 使用extends继承父类Pet
    // 这里只需要定义Penguin类中特有的属性
    private String sex;

    public Penguin() {
    }

    public Penguin(String name, int health, int love, String sex) {
        super(name, health, love); // 使用super关键字访问父类中的属性
        this.sex = sex;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }
}

package com.bdqn.demo02;

public class Dog extends Pet {
    // 这里只需要定义Dog类中特有的属性
    private String strain; // 品种

    public Dog() {
    }

    public Dog(String name, int health, int love, String strain) {
        super(name, health, love); // super关键字
        this.strain = strain;
    }

    public String getStrain() {
        return strain;
    }

    public void setStrain(String strain) {
        this.strain = strain;
    }
}

测试

public class Test {

    public static void main(String[] args) {

        // 创建Dog类对象
        Dog dog1 = new Dog();
        // 说明：setName()、setHealth()、setLove()方法在Dog类中不存在，但是在Pet类中存在，而Dog类继承了Pet类，所以Dog类对象可以调用Pet类中的方法
        dog1.setName("旺财");
        dog1.setHealth(90);
        dog1.setLove(100);
        // setStrain()方法在Dog中存在，可以调用
        dog1.setStrain("金毛");

        // 通过getXxx()方法获取信息
        // 说明：getName()、getHealth()、getLove()方法在Dog类中不存在，但是在Pet类中存在，而Dog类继承了Pet类，所以Dog类对象可以调用Pet类中的方法
        System.out.println(dog1.getName());
        System.out.println(dog1.getHealth());
        System.out.println(dog1.getLove());
        // getStrain()方法在Dog中存在，可以调用
        System.out.println(dog1.getStrain());

        // 说明：printInfo()在Dog类中不存在，但是在Pet类中存在，而Dog类继承了Pet类，所以Dog类对象可以调用Pet类中的方法
        dog1.printInfo();

        System.out.println("-------------------------------------");

        // 创建Penguin类对象
        Penguin penguin1 = new Penguin();
        // 给属性赋值
        // setName()、setHealth()、setLove()方法在Penguin类中不存在，但是在Pet类中存在，而Penguin类继承了Pet类，所以Penguin类对象可以调用Pet类中的方法
        penguin1.setName("QQ");
        penguin1.setHealth(100);
        penguin1.setLove(99);
        // setSex()方法在Penguin中存在，可以调用
        penguin1.setSex("公");

        // 输出Penguin对象属性信息
        // getName()、getHealth()、getLove()方法在Penguin类中不存在，但是在Pet类中存在，而Penguin类继承了Pet类，所以Penguin类对象可以调用Pet类中的方法
        System.out.println(penguin1.getName());
        System.out.println(penguin1.getHealth());
        System.out.println(penguin1.getLove());

        // getSex()方法在Penguin中存在，可以调用
        System.out.println(penguin1.getSex());

        // printInfo()在Penguin类中不存在，但是在Pet类中存在，而Penguin类继承了Pet类，所以Penguin类对象可以调用Pet类中的方法
        penguin1.printInfo();
    }
}

三、子类访问父类

1、继承下的构造方法

继承条件下的构造方法的调用规则

1）子类构造方法没有通过super显式调用父类的有参构造方法，也没通过this显式调用自身其他构造方法

系统默认调用父类的无参构造方法

2）子类构造方法通过super显式调用父类的有参构造方法

执行父类相应构造方法，而不执行父类无参构造方法

3）子类构造方法通过this显式调用自身的其他构造方法，在相应构造方法中应用以上两条规则

2、子类能继承父类

1）继承public修饰的属性和方法，不管子类和父类是否在同一个包里

2）继承默认权限修饰符修饰的属性和方法，但子类和父类必须在同一个包里

（默认权限修饰符，包级私有）

3、子类不能继承父类

1）private成员

2）子类与父类不在同包，使用默认访问权限的成员

3）构造方法

即子类不能创建父类的对象