JAVA 继承 - 技术栈

继承的简单介绍

即子类与子类之间具有的共同的属性包含于父类（注意是共同的属性，不同属性的不在父类中）

子类与子类可以有不同的属性，但是不能差太大（如手机和人都具有姓名，年龄，但两者不是一种东西，所以不能放在一个父类中）

java仅支持单继承，不支持多继承，但是支持多层继承。

意思是一个子类只属于一个父类

支持多层继承含义如下图

子类能继承父类的内容

示例

java 复制代码

class Animal {
    public String name;         // 子类可直接继承
    protected int age;          // 子类可直接继承
    String color;               // 同包子类可继承
    private String secret;      // 不可直接继承
}

class Cat extends Animal {
    void showInfo() {
        name = "咪咪";  // 直接访问 public 属性
        age = 2;       // 直接访问 protected 属性
        color = "白色"; // 同包下可访问默认属性
        // secret = "xxx"; // 编译错误！private 不可直接访问
    }
}

示例

java 复制代码

class Animal {
    private String dna;  // 私有属性，不可直接继承
    
    public Animal(String dna) { 
        this.dna = dna; 
    }

    public String getDna() {  // 通过公共方法间接访问私有属性
        return dna;
    }
}

class Cat extends Animal {
    public Cat(String dna) {
        super(dna);  // 必须调用父类构造方法
    }
    
    void printDna() {
        // System.out.println(dna); // 编译错误！private 不可直接访问
        System.out.println(getDna()); // 通过公共方法获取
    }
}

借用公共方法与super来调用private修饰的部分

final关键字

在继承中涉及到了一个关键字----final

final主要起到"禁止"的作用，如下图

示例如下

java 复制代码

class Animal {
    public final void sleep() {  // final方法，禁止重写
        System.out.println("动物睡觉");
    }
}

class Cat extends Animal {
    // @Override
    // public void sleep() { ... } // 编译错误！final方法不可重写
}

明显，被final修饰后对正常的继承起到了很大的限制作用。

继承的实现

通过关键字extends实现，具体代码如下

父类：

java 复制代码

public class Animal {
    public void eat(){
        System.out.println("赤石");

    }
    public void drink(){
        System.out.println("喝合淝水");
    }
}

子类（extends继承父类)：

java 复制代码

public class Cat extends Animal{
    public void catchMouse(){
        System.out.println("miao和老鼠");
    }
}

方法的重写

子类可以重写父类的方法，但是有很多限制。如下：

代码（不可运行，只是方便大家理解）

java 复制代码

class Animal {
    void eat() { System.out.println("动物吃东西"); }
}
class Cat extends Animal {
    @Override
    void eat() { System.out.println("猫吃鱼"); } // 重写父类方法
}

构造方法与继承

子类调用默认先调用无参构造方法

如果是父类的有参构造，调用要用到super，且必须子类构造方法放在首行。

代码如下（代码仅供理解，可能不可运行）

java 复制代码

class Animal {
    Animal(String name) { System.out.println("动物名：" + name); }
}
class Cat extends Animal {
        public void chicken(String name) {
        super.chicken(name);
    }
}

很明显上述代码中name是有参的，所以调用了super。

访问修饰符的复习

上述的限制级逐渐上升。

综合上述，作者自己代码（可以直接运行，想玩玩的直接复制粘贴就行）

Main函数

java 复制代码

public class Main {
    public static void main(String[] args) {
        Cat miaomiao = new Cat();
        miaomiao.eat();
        miaomiao.drink();
        miaomiao.catchMouse();
        System.out.println(".............................");
        Dog soxin = new Dog();
        soxin.eat();
        soxin.konw();
        soxin.chicken("mimi");
        soxin.lookingmyeye();
        soxin.ai("yuean");
    }
}

父类

java 复制代码

public class Animal {
private String id;

    public void konw(){
        System.out.println("man ba out");
    }
    public void eat(){
        System.out.println("赤石");

    }
    public void drink(){
        System.out.println("喝合淝水");
    }
    public void chicken(String name){
        System.out.println("他是"+name);
    }
}

子类

java 复制代码

public class Cat extends Animal{

    public void catchMouse(){
        System.out.println("miao和老鼠");
    }

    @Override
    public void chicken(String name) {
        super.chicken(name);

    }
}

java 复制代码

public class Dog extends Animal{
    public void lookingmyeye(){
        System.out.println("BABY tell me.why?why? ");

    }
    public void ai(String id){
        System.out.println("shi"+id);
    }
}

运行结果

总结

合理利用继承的父类与子类，可以大大提高开发的速度与代码的美观性

多尝试新事物，Just do it