java枚举的使用

最新推荐文章于 2024-08-28 03:59:19 发布

原创最新推荐文章于 2024-08-28 03:59:19 发布 · 286 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java #enum #接口 #class #抽象类

java 专栏收录该内容

2 篇文章

订阅专栏

本文详细介绍了Java中的枚举类型，包括枚举的定义、使用方式、添加属性和方法、覆盖方法、实现接口以及组织枚举的策略。枚举可以替代常量声明，提供更安全和易维护的代码。示例展示了如何在枚举中添加属性、方法，以及如何在实际场景中使用枚举进行颜色转换。

枚举类型

Java中的枚举类型，可以用来替换常量的声明

默认在里面是计数的，从0开始，一直到你定义的多少个变量的n-1
以前的做法
private fianl int red = 1;
private final int yello = 2;
现在的做法
public enum Color{
    RED,YELLOW
}

简单使用

enum Color{
    RED,YELLOW,WHITE
}
class Demo{
    main(){
        // 直接使用，其实他们可以看作是0 1 2
        if(color == Color.RED){
            color = Color.YELLOW
        }
    }
}

switch使用

enum Signal{
    GREEN, YELLOW, RED
}
class Demo{
    Signal color = Signal.RED;
    
    public void change(){
        switch(color){
            case RED:
                color = Signal.GREE;
                break;
            case YELLOW:
                color = Signla.RED;
                break;
            case GREEN:
                color = Signal.YELLOW;
                break;
        }
    }
}

在枚举中添加新属性和新方法

默认在类里面的属性和方法是 name和original

本质是类，可以添加方法和属性，但是由于enum的特殊实现，

name()总会返回你第一行用RED 这样定义的东西
original()总会返回他在里面的索引(因为本质存到了$values()里面)

public enum Color{
    RED("红色",1),GREEN("绿色",2),BLANK("白色",3),YELLOW("黄色",4);
    private String name;
    private int index;
    private Color(String name, int index){
        this.name = name;
        this.index = index;
    }
    public static String getName(int index){
        for(Color c: Color.values()){
            if(c.getIndex() == index){
                return c.name;
            }
        }
        return null;
    }
    // name和index的getter(),setter()方法
}

public enum Colo5 {
    RED("红色", 2, 3, 4);

    protected String name;
    protected int idx1;
    protected int idx2;
    protected int idx3;

    Colo5(String name, int idx1, int idx2, int idx3) {
        this.name = name;
        this.idx1 = idx1;
        this.idx2 = idx2;
        this.idx3 = idx3;
    }

}


class Demo{
    public static void main(String[] args) {
        Colo5 colo5 = Colo5.RED;
        System.out.println(colo5.name());  //RED
        System.out.println(colo5.ordinal()); //0
        System.out.println(colo5.name);  //"红色"
        System.out.println(colo5.idx1);  //2
        System.out.println(colo5.idx3); //4
    }
}

覆盖枚举的方法

enum声明的枚举类，其实本质是继承了java.lang.Enum的一个final类，他也可以覆盖字类的方法

public enum Color {
    RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4);
    // 成员变量
    private String name;
    private int index;
    // 构造方法
    private Color(String name, int index) {
        this.name = name;
        this.index = index;
    }
    //覆盖方法
    @Override
    public String toString() {
        return this.index+"_"+this.name;
    }
}

实现接口

因为他是继承了java.lang.Enum,所以他不能再继承了，但是可以实现接口

public interface Behavior{
    void print();
    String getInfo();
}

public enum Color implements Behaviour{  
     RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4);  
     // 成员变量  
     private String name;  
     private int index;  
     // 构造方法,略

    	// 这里实现了接口方法，略

25 }

利用接口来组织枚举

用一个接口来作为抽象的一个组织

public interface Food{
    enum Coffee impolements Food{
        BLACK_COFFEE,DECAF_COFFEE,LATTE,CAPPUCCINO
    }
    enum Dessert impolements Food{
        FRUIT,CAKE,GELATO
    }
}

枚举接口

EnumSet和EnumMap是两个枚举集合

如果要把Enum放在列表内，或者放在map内，那么用这两个更好

原理

目的

以前总是这样的形式定义常量

private final int spring = 1;

private final int summer= 2;

private final int autumn= 3;

private final int winter= 4;

为了减少就来了枚举
public enum Sean{
    SPRING, SUMMER, AUTUMN, WINTER
}
java自动按照枚举的值出现的顺序，从0开始分配编号，通过name()可以获得枚举值的名称，ordinal()获得枚举值的编号
public enum  Season {
    SPRING, SUMMER, AUTUMN, WINTER
}

class Demo{
    public static void main(String[] args) {
        Season season = Season.SPRING;
        System.out.println(season.name());
        System.out.println(season.ordinal());

        System.out.println(Season.SPRING.name());
        System.out.println(Season.SPRING.ordinal());
    }

}

实现原理

我们的Season没有name()和ordinal()方法，他是继承自抽象类

java.lang.Enum

public abstract class Enum<E extends Enum<E>> implements Comparable<E>, Serializable{
    
}

Season反编译之后

扩展了Enum类
枚举类是final的，不能再继承了
我们定义的枚举值都是类中的一个成员，仍然是Sean类型
默认增加了很多静态方法，如values()等

更具体之后

再类的static操作中，编译器帮我们生成了每个枚举值的对象,并且把这些值放到了$VALUES中

实例

颜色转换

利用枚举类来实现颜色常量的定义

并且利用枚举类可以增加属性和方法的特点来进行转换

(没有转换属性，所以属性还是name和ordinal

public enum Color {
    RED, YELLOW, ORANGE, BLUE,
    PURPLE, GREEN, BLACK;

    private static Map<Color, Map<Color, Color>> colorMap;
    static{
        colorMap = new HashMap<>();
//        红色的对应
        Map<Color, Color> temp = new HashMap<>();
        temp.put(YELLOW, ORANGE);
        temp.put(BLUE, PURPLE);
        colorMap.put(RED, temp);

//        蓝色的对应
        temp = new HashMap<>();
        temp.put(YELLOW, GREEN);
        colorMap.put(BLUE, temp);
    }

    public static Color mixture(Color a, Color b){
        return colorMap.get(a).get(b);
    }

    @Override
    public String toString() {
        return "当前的颜色是:" + this.name();
    }
}

class demo{
    public static void main(String[] args) {
        Color color1 = Color.RED;
        Color color2 = Color.YELLOW;
        Color color3 = Color.BLUE;

        System.out.println(color1);
        System.out.println(color2);
        System.out.println();
        System.out.println(Color.mixture(color1, color2));
        System.out.println(Color.mixture(color3, color2));

    }
}