六. Java“速学通”之抽象与接口

前言

• 课程的第六篇，下一篇开始API和正则表达式相关的内容，故命名为API与Lambda。
• 以防有新读者所以我简述一下第一篇的前言。
• 这个Java急速学习课程适合有一定编程基础的人。它通过实际的代码例子来教Java，减少了理论讲解，使学习过程更直观，帮助你更快地掌握Java的核心技能。课程内容经过优化，力求简洁明了。同时，课程鼓励大家交流心得，提出更好的解决方案，以此来不断改进课程内容。

---

包含的知识

1. final 关键字

• 变量：当final用于变量时，表示该变量一旦被初始化后其值就不能再改变。例如，final double rate = 3.14; 定义了一个常量。
• 类：当final修饰一个类时，意味着该类不能被其他类继承。
• 方法：当final修饰一个方法时，意味着该方法不能在子类中被重写。

2. 抽象类

• 抽象类通过abstract关键字定义，它可以包含抽象方法（没有方法体的方法），也可以包含非抽象方法。
• 抽象类不能被实例化，即不能创建抽象类的对象。
• 继承抽象类的子类必须实现所有抽象方法，除非该子类也是抽象类。

3. 枚举类

• 枚举类通过enum关键字定义，通常用于定义一组固定的常量。
• 枚举类型提供了一种安全的方式来表示固定集合的常量，如代码中的方向Direction。

4. 接口

• 接口使用interface关键字定义，可以看作是一种完全抽象的类，其中所有的方法默认都是抽象的。
• Java 8之后，接口中可以包含默认方法（使用default关键字定义）和静态方法（使用static关键字定义）。
• 类可以通过实现接口来获得接口中定义的行为，一个类可以实现多个接口，这弥补了Java单继承的限制。接口中的方法默认是public的，常量默认是public static final的。

5. 多态

• 多态允许将子类对象当作父类类型的对象来处理，这是通过继承或实现接口实现的。
• 在代码示例中，Student类同时实现了Driver和Friend接口，因此可以将Student对象赋值给Driver或Friend类型的引用变量，体现了多态性。

6. 方法重写

• 当子类提供了父类（包括抽象类和接口）已有的方法的具体实现时，称为方法重写或覆盖。
• 子类可以通过@Override注解来表明正在重写父类的方法，这有助于编译器检查是否正确地重写了方法。

7. 面向接口编程

• 面向接口编程是指程序设计时尽量依赖于接口而非具体的实现类，这有利于提高代码的灵活性和可维护性。
• 例如，在代码中，Driver a = new Student(); 和 Friend bf = new Student();

---

具体代码

package basic_0;
 
public class BasicZc7 {
    public static void main(String[] args) {
        // final修饰变量：变量有且仅能被赋值一次，常量
        // final修饰类，类不能被继承
        // final修饰方法：方法不能被重写
        final double rate = 3.14;
        // 抽象类，抽象方法
        // 抽象类的核心特点：有抽象方法的能力，不能创建对象（重点）
        // A a = new A();  会报错
        // 抽象类就是为了被子类继承
        B b = new B();
        b.setName("张三");
        b.setAge(18);
        System.out.println(b.getName() + "---" + b.getAge());
        b.show0();
        b.show1();
 
        System.out.println("---------------");
        // 枚举类的应用场景
        // 上下左右移动
        // 第一种是常量做信息标志和分类: 参数值不受约束
        move0(Constant.UP);
        // 第二种是枚举做信息标志和分类: 参数值受枚举类约束
        move1(Direction.DOWN);
 
        System.out.println("---------------");
        // 接口：使用interface关键字定义的
        // 接口不能创建对象，接口是被实现的（重点）
        // 常量：接口中定义常量可以省略public static final不写，默认会加上去
        // 抽象方法: 接口中定义抽象方法可以省略public abstract不写，默认会加上去
        // 接口中定义常量和抽象方法，接口的实现类必须实现接口中的抽象方法，否则，实现类必须声明为抽象类
        // 1、接口与接口可以多继承：一个接口可以同时继承多个接口[重点]。
        // 类与类： 单继承 一个类只能继承一个直接父类
        // 类与接口：多实现，一个类可以同时实现多个接口。
        // 接口与接口： 多继承，一个接口可以同时继承多个接口。
        // 2、一个接口继承多个接口，如果多个接口中存在方法签名冲突，则此时不支持多继承，也不支持多实现。[了解]
        // 3、一个类继承了父类，又同时实现了接口，如果父类中和接口中有同名的方法，实现类会优先用父类的。[了解]
        // 4、一个类实现了多个接口，如果多个接口中存在同名的默认方法，可以不冲突，这个类重写该方法即可。
 
        // 接口弥补了类单继承的不足，可以让类拥有更多角色，类的功能更强大。
        People p = new Student();
        Driver d = new Student(); // 多态
        Friend bf = new Student();
 
        // 接口可以实现面向接口编程，更利于解耦合。
        Driver a = new Student();
        Driver a2 = new Teacher();
 
        Friend b1 = new Student();
        Friend b2 = new Teacher();
 
        AImpl c = new AImpl();
        c.go();
        C.show(); // 静态方法
    }
    // 抽象类
    static abstract class A {//abstract抽象关键字
        private String name;
        private int age;
 
        public A() {
            System.out.println("A的无参构造器");
        }
 
        public A(String name, int age) {
            this.name = name;
            this.age = age;
        }
        // 抽象方法：必须用abstract修饰，没有方法体{}，只有方法声明
        public abstract void show0();
 
        public void show1() {
            System.out.println("show1方法");
        }
 
        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;
        }
    }
    static class B extends A {
        @Override
        public void show0() {
            System.out.println("B类重写show方法");
        }
    }
 
    // 枚举类
    public enum Direction {
        // 枚举类的第一行：只能罗列枚举对象的名称，这些名称本质是常量。
        UP, DOWN, LEFT, RIGHT;
    }
    public class Constant {
        public static final int UP = 0; // 上
        public static final int DOWN = 1; // 下
        public static final int LEFT = 2; // 左
        public static final int RIGHT = 3; // 右
    }
 
    public static void move0(int direction){
        // 根据这个方向做移动：上下左右。
        switch (direction){
            case Constant.UP :
                System.out.println("向上移动");
                break;
            case Constant.DOWN :
                System.out.println("向下移动");
                break;
            case Constant.LEFT :
                System.out.println("向左移动");
                break;
            case Constant.RIGHT :
                System.out.println("向右移动");
                break;
            default:
                System.out.println("输入有误");
        }
    }
    public static void move1(Direction direction){
        // 根据这个方向做移动：上下左右。
        switch (direction){
            case UP :
                System.out.println("向上移动");
                break;
            case DOWN :
                System.out.println("向下移动");
                break;
            case LEFT :
                System.out.println("向左移动");
                break;
            case RIGHT :
                System.out.println("向右移动");
                break;
        }
    }
    // 接口
    static class People{}
    interface Driver{}
    interface Friend{}
    static class Student extends People implements Driver, Friend{}
 
    static class Teacher implements Driver, Friend{}
 
    public interface C {
        // 1、默认方法（普通实例方法）：必须加default修饰，
        // 默认会用public修饰。
        // 如何调用？ 使用接口的实现类的对象来调用。
        default void go(){
            System.out.println("==go方法执行了===");
            run();
        }
 
        // 2、私有方法（JDK 9开始才支持的）
        // 私有的实例方法。
        // 如何调用？ 使用接口中的其他实例方法来调用它
        private void run(){
            System.out.println("==run方法执行了===");
        }
 
        // 3、静态方法
        // 默认会用public修饰。
        // 如何调用？ 只能使用当前接口名来调用。
        static void show(){
            System.out.println("==show方法执行了===");
        }
    }
    static class AImpl implements C{ }// 接口实现类
}