【前端学javaJava中的接口和枚举概念（7）

往期回顾：

• 【前端学java】JAVA开发的依赖安装与环境配置 （0）
• 【前端学 java】java的基础语法（1）
• 【前端学java】JAVA中的packge与import（2）
• 【前端学java】面向对象编程基础-类的使用 （3）
• 【前端学java】类中的访问权限详解，通俗易懂（4）
• 【前端学java】java中final修饰符（5）
• 【前端学java】全网最通俗易懂的JAVA抽象概念（6）

如果你是一名前端开发者，并且熟悉TS的话，接口（Interface）概念你一定非常熟悉，枚举肯定也是信手拈来。

interface People {
    age:number，
    name:string
}

let peple:People = {
    age:18，
    name:"shixiaoshi"
}

上述代码就是前端接口使用的一个简单演示，Java中，接口和枚举的概念几乎是一致的。现在，我们来学习一下java中的接口概念。

Java中的接口

基础概念

在Java中，接口（Interface） 是一种抽象类型，它定义了一组抽象方法和常量字段，简单来说，就是提前定义了类的结构用来约束类的创建。

如果你明白TypeScript，那么接口的概念理解起来，也轻而易举。

一个简单的Demo如下

// 接口的定义
interface Car {
    // 声明抽象方法
    void run();
}

定义接口

• 使用interface关键字来定义接口，接口的命名通常以大写字母开头，符合驼峰命名规则。
• 接口中可以包含抽象方法和常量字段，但不能包含具体实现的方法和实例变量（即成员变量）。
• 方法在接口中默认为public abstract，字段默认为public static final，可以省略这些修饰符。

// 接口的定义
interface Car {
    // 声明抽象方法
    void run();
    // 接口中的常量，默认为 public static final
    int money = 12345;
}

实现接口

• 使用implements关键字来让类实现一个或多个接口。一个类可以同时实现多个接口，用逗号分隔。
• 实现接口时，类必须提供接口中定义的所有抽象方法的具体实现，否则该类必须被声明为抽象类。
• 实现接口的类可以拥有自己的其他成员变量和方法，但它必须实现接口中定义的所有方法

示例代码：

// 接口的定义
interface Car {
    // 声明抽象方法
    void run();
    // 接口中的常量，默认为 public static final
    int money = 12345;
}

// 实现接口
class Benchi implements Car {
    public void run() {
        System.out.println("run.....");
    }
}

接口的继承

在Java中，接口也可以像类一样进行继承，即一个接口可以继承自另一个或多个接口。接口继承使用关键字extends。

// 接口的定义
interface Car {
    // 声明抽象方法
    void run();
    // 接口中的常量，默认为 public static final
    int money = 12345;
}

// 实现接口
class Benchi extends Car {
    // 子接口新增的抽象方法
}

在接口继承中，子接口将包含父接口的所有抽象方法和常量字段，并且子接口可以添加自己的抽象方法，但不能添加具体实现的方法。

接口中的默认方法

在Java 8中引入了默认方法（default method），可以在接口中提供具体的方法实现。

• 默认方法使用default关键字来定义，允许接口在不破坏现有实现的情况下添加新的方法。
• 实现类不强制重写默认方法，但仍可以选择重写以覆盖默认实现。

// 定义一个接口
interface MyInterface {
    int count = 100; // 常量字段，默认为 public static final

    void abstractMethod(); // 抽象方法，默认为 public abstract

    default void defaultMethod() {
        // 默认方法，提供默认实现
        System.out.println("默认方法.....");
    }
}

// 类实现接口
class MyClass implements MyInterface {
    public void abstractMethod() {
        System.out.println("Abstract method implementation.");
    }
}

public class Main {
    public static void main(String[] args) {
        MyClass obj = new MyClass();
        obj.abstractMethod(); // 调用抽象方法的实现
        obj.defaultMethod();  // 调用默认方法的实现
        System.out.println(MyInterface.count); // 访问接口中的常量
    }
}

接口中的静态方法

• 在Java 8中引入了静态方法，使用static关键字来定义。
• 静态方法只能在接口中定义，不能在实现类中被重写。

// 定义一个接口
interface MyInterface {
    // 静态方法，不可重写
    static void staticMethod() {
        System.out.println("这是静态方法");
    }
}

public class Main {
    public static void main(String[] args) {
        MyInterface.staticMethod(); // 调用接口中的静态方法
    }
}

java中的枚举

什么是枚举

在Java中，枚举（Enum） 是一种特殊的数据类型，用于定义一组常量，这些常量在代码中是固定且有限的。

Java中的枚举通过关键字enum进行声明，我们看一个示例：

// 定义一个枚举
enum DayOfWeek {
    MONDAY,
    TUESDAY,
    WEDNESDAY,
    THURSDAY,
    FRIDAY,
    SATURDAY,
    SUNDAY
}

public class Main {
    public static void main(String[] args) {
        // 使用枚举类型的常量
        DayOfWeek today = DayOfWeek.MONDAY;

        // 使用switch语句处理枚举
        switch (today) {
            case MONDAY:
                System.out.println("Today is Monday.");
                break;
            case TUESDAY:
                System.out.println("Today is Tuesday.");
                break;
                // 其他的case...
            default:
                System.out.println("Today is some other day.");
        }
    }
}

这个和ts中的枚举概念用法其实是一致的。

枚举的valueOf和values方法（了解）

Java编译器会为每个枚举类型生成valueOf和values方法。valueOf方法用于将枚举常量的名称转换为对应的枚举实例，values方法返回包含所有枚举常量的数组。

示例代码：

enum Color {
    RED,
    GREEN,
    BLUE
}

public class Main {
    public static void main(String[] args) {
        // 使用valueOf将字符串转换为枚举实例
        Color color = Color.valueOf("RED");
        System.out.println("Color: " + color);

        // 使用values获取所有枚举实例
        Color[] colors = Color.values();
        for (Color c : colors) {
            System.out.println(c);
        }
    }
}

枚举的构造函数和字段（了解）

枚举可以像普通类一样拥有构造函数，并且每个枚举常量都可以有自己的字段和方法。每个枚举常量在定义时都必须调用构造函数，并为字段赋值。

示例代码：

javaCopy code
enum Size {
    SMALL("S", 10),
    MEDIUM("M", 20),
    LARGE("L", 30);

    private final String abbreviation;
    private final int value;

    Size(String abbreviation, int value) {
        this.abbreviation = abbreviation;
        this.value = value;
    }

    public String getAbbreviation() {
        return abbreviation;
    }

    public int getValue() {
        return value;
    }
}

public class Main {
    public static void main(String[] args) {
        Size size = Size.MEDIUM;
        System.out.println("Size: " + size);
        System.out.println("Abbreviation: " + size.getAbbreviation());
        System.out.println("Value: " + size.getValue());
    }
}

枚举的构造函数只能是private访问权限，这样可以保证枚举常量只能在枚举内部进行实例化。