继承和接口-CFANZ编程社区

一、继承

1. 继承的目的：创建一个新的类，新类复制了现有类的属性和方法并且增加自己本身的属性和方法。

2. 实现继承

// 定义一个基本类作为父类
class Person {
    // 定义属性
    String name;
    int age;
    
    // 定义方法
    void eat() {
        System.out.println("吃东西！！！");
    }
}

// 定义一个继承 Person 类的子类 Student 类
// 用到 extends 关键字
// 结构：class + 类名 + extends + 父类 {}
class Student extends Person {
    // 增加新的属性
    String Stu_id;
    
    // 增加新的方法
    void read() {
        System.out.println("看书！！！");
    }
}

// 再次继承 Student 类
class UNStudent extends Student {
    // 增加新的属性
    int CET_4;
    
    // 增加新的方法
    void printInfo() {
        System.out.println("姓名："+name);
        System.out.println("年龄："+age);
        System.out.println("学号："+Stu_id);
        System.out.println("CET_4："+CET_4);
    }
    
}

3. 继承的一些特性

用 extends 关键字可以使子类拥有父类的属性和方法，这些属性和方法不需要我们重新写，这样提高了写代码的速度，我们只要写子类独有的属性和方法即可；子类是可以再次被继承的，新的子类也拥有它的父类的所有属性和方法。

4. 继承的实际用法

class main {
    public static void main(String[] args) {
        // 创建一个UNStudent类型对象
        UNStudent unstudent1 = new UNStudent();
        // 对象名调用属性赋值
        unstudent1.name = "张三";
        unstudent1.age = 19;
        unstudent1.Stu_id = "19029300";
        unstudent1.CET_4 = 450；
        // unstudent1 是一个大学生类型对象
        unstudent1.printInfo();
        unstudent.printInfo();
        unstudent.read();
        unstudent.eat();
        // 身份转变为 学生类型 对象
        Student student = unstudent;
        student.read();
        // 身份转变为 人类类型 对象
        Person person = student;
        person.eat();
        
        // unstudent1 student person 都是同一个对象在不同身份类型下的代词
        
    }
}

二、接口

1. 接口的用法

// 接口是一种类型 用 interface 定义
// 结构：interface + 接口名 {}
// 接口中的属性是常量，但是方法是抽象的，是没有方法体的。
interface Lock {
    // 方法是抽象的
    // 结构：返回值类型 + 方法名();
    void open();
    void close();
}

// 用 implements 关键字使用接口
// class + 类命 + implements + 接口名 {}
// 在类中复制接口的抽象方法，实现方法的具体化
class FaceLock implements Lock {
    void open() {
        System.out.println("扫脸开锁");
    }
    void close() {
        System.out.println("扫脸关锁");
    }
}

class KeyLock implements Lock {
    void open() {
        System.out.println("密钥开锁");
    }
    void close() {
        System.out.println("密钥关锁");
    }
}

2. 接口和类的转化

class Test {

    public static void main(String[] args) {
        
        // 创建一个 FaceLock 类型的对象
        FaceLock facelock = new FaceLock();
        facelock.open();
        facelock.close();

        // 创建一个 KeyLock 类型的对象
        KeyLock keylock = new KeyLock();
        keylock.open();
        keylock.close();
        
        // FaceLock类类型对象转化成 Lock 接口类型
        Lock lock1 = facelock;
        // lock1 调用facelock对象中重写的方法
        lock1.open();
        lock1.close();
        
        // KeyLock类类型对象转化成 Lock 接口类型
        Lock lock2 = keylock;
        // lock2 调用keylock对象中重写的方法
        lock2.open();
        lock2.close();
    }
}

3. 接口在实际中的应用

有一个 Door 类，Door 有开关门的方法，同时有两种方法开关门，即扫脸和密钥方法。如果按照普通的写法，就需要写两种方法来表示两种开关门的方式。两种锁的类型分别作为两种开关方法的参数类型。

class Door {
    void openDoor(FaceLock facelock) {
        facelock.open();
        System.out.println("门开了！！");
    }
    void openDoor(KeyLock keylock) {
        keylock.open();
        System.out.println("门开了");
    }
    void closeDoor(KeyLock keylock) {
        keylock.close();
        System.out.println("门关了");
    }
    void closeDoor(KeyLock keylock) {
        keylock.close();
        System.out.println("门关了");
    }
}

这样会有大量代码重复，显然很麻烦。因此，参考接口与类的转化，可以将父接口类型作为参数类型，这样不管什么锁对象都可以作为参数传入。

class Door {
    void openDoor(Lock lock) {
        lock.open();
        System.out.println("门开了!!");
    }
    void closeDoor(Lock lock) {
        lock.close();
        System.out.println("门关了!!");
    }
}

接下来可以在实现中看看效果

public class main {
    public static void main(String[] args) {
        // 创建 Door FaceLock KeyLock 类型对象
        Door door1 = new Door();
        FaceLock facelock1 = new FaceLock();
        KeyLock keylock1 = new KeyLock();
        // 身份转化为 Lock
        Lock lock = facelock;

        // 用 FaceLock 类型 开门
        Door.open(facklock);
        // 用 KeyLock 类型 关门
        Door.close(keylock);
        // 用 Lock 类型 开门
        Door.openDoor(lock);
    }
}

运行结果如下图