Java基礎：枚舉

JDK1.5引入了新的類型——枚舉

1.用法一:常量

在JDK1.5 之前，我們定義常量都是： public static fianl....(這種方式在現在項目中也很常見) 。現在好了，有了枚舉，可以把相關的常量分組到一個枚舉類型裏，而且枚舉提供了比常量更多的方法。而且枚舉類型可以幫助我們檢測許多的編譯失誤。

package enumTest;

public enum Color {
    RED,BLANK,YELLOW
}

package enumTest;

public class Test {
    public static void main(String[] args) {
        String string = Color.BLANK.toString();
        System.out.println(string);
        System.out.println(Color.BLANK);
    }
}

BLANK
BLANK

2.用法二：switch

JDK1.6之前的switch語句只支持int,char,enum類型，使用枚舉，能讓我們的代碼可讀性更強。

    public static void main(String[] args) {
        Color color = Color.RED;
        switch (color) {
        case BLANK:
            System.out.println("黑色");
            break;
        case RED:
            System.out.println("紅色");
            break;
        default:
            break;
        }
    }

紅色

3.用法三：向枚舉中添加新方法

如果打算自定義自己的方法，那麼必須在enum實例序列的最後添加一個分號。而且 Java 要求必須先定義 enum 實例。且枚舉類型的構造方法必須爲私有方法。

package enumTest;

public enum MyDay {
    
    MONDAY(1,"星期一"),THUSDAY(2,"星期二");//這個後面必須有分號
    
    private int code;
    private String name;
    private MyDay(int code,String name) {
        this.code = code;
        this.name = name();
    }
    
    public int getCode() {
        return code;
    }
    public String getName() {
        return name;
    }
    public void setCode(int code) {
        this.code = code;
    }
    public void setName(String name) {
        this.name = name;
    }
    
}

    public static void main(String[] args) {
        System.out.println(MyDay.MONDAY.getCode());
        System.out.println(MyDay.MONDAY.getName());
        System.out.println(MyDay.THUSDAY.getCode());
        System.out.println(MyDay.THUSDAY.getName());
        System.out.println(MyDay.THUSDAY);
    }

1
MONDAY
2
THUSDAY
THUSDAY

4.用法四：覆蓋枚舉的方法

覆蓋toString()方法

package enumTest;

public enum MyDay {
    
    MONDAY(1,"星期一"),THUSDAY(2,"星期二");//這個後面必須有分號
    
    private int code;
    private String name;
    private MyDay(int code,String name) {
        this.code = code;
        this.name = name();
    }
    
    public int getCode() {
        return code;
    }
    public String getName() {
        return name;
    }
    public void setCode(int code) {
        this.code = code;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return this.getName()+"---"+this.getCode();
    }
}

package enumTest;

public class Test {
    public static void main(String[] args) {
        System.out.println(MyDay.MONDAY.getCode());
        System.out.println(MyDay.MONDAY.getName());
        System.out.println(MyDay.THUSDAY.getCode());
        System.out.println(MyDay.THUSDAY.getName());
        System.out.println(MyDay.THUSDAY);
    }
}

1
MONDAY
2
THUSDAY
THUSDAY---2

枚舉類的原理是將枚舉類繼承java.lang.Enum<enumTest.MyDay>，並且聲明爲final，其內部維護多個實例，而且是在靜態代碼塊中進行實例化多個實例。其實普通的類構造方法聲明爲private，靜態代碼塊中初始化對應的變量即可實現enum的原理代碼。

5.用法五：實現接口

所有的枚舉都繼承自java.lang.Enum類。由於Java 不支持多繼承，所以枚舉對象不能再繼承其他類。

package enumTest;

public interface DayInterface {

    public String getDay();
}

package enumTest;

public enum MyDay implements DayInterface{
    
    MONDAY(1,"星期一"),THUSDAY(2,"星期二");//這個後面必須有分號
    
    private int code;
    private String name;
    private MyDay(int code,String name) {
        this.code = code;
        this.name = name();
    }
    
    public int getCode() {
        return code;
    }
    public String getName() {
        return name;
    }
    public void setCode(int code) {
        this.code = code;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return this.getName()+"---"+this.getCode();
    }

    @Override
    public String getDay() {
        return this.getName();
    }
}

package enumTest;

public class Test {
    public static void main(String[] args) {
        System.out.println(MyDay.THUSDAY.getDay());
    }
}

THUSDAY

6.用法六：使用接口組織枚舉

package enumTest;

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

package enumTest;

import enumTest.Food.Coffee;
import enumTest.Food.Dessert;

public class Test {
        
    public  static void main(String[] args) {  
        for (Dessert dessertEnum : Food.Dessert.values()) {  
            System.out.print(dessertEnum + "  ");  
        }  
        System.out.println();  
        //我這地方這麼寫，是因爲我在自己測試的時候，把這個coffee單獨到一個文件去實現那個food接口，而不是在那個接口的內部。  
        for (Coffee coffee : Food.Coffee.values()) {  
            System.out.print(coffee + "  ");  
        }  
        System.out.println();  
        //搞個實現接口，來組織枚舉，簡單講，就是分類吧。如果大量使用枚舉的話，這麼幹，在寫代碼的時候，就很方便調用啦。  
        //還有就是個“多態”的功能吧，  
        Food food = Food.Dessert.CAKE;  
        System.out.println(food);  
        food = Coffee.BLACK_COFFEE;  
        System.out.println(food);  
    } 
}

FRUIT CAKE GELATO 
BLACK_COFFEE DECAF_COFFEE LATTE CAPPUCCINO 
CAKE
BLACK_COFFEE

7.用法七：關於枚舉集合的使用

java.util.EnumSet和java.util.EnumMap是兩個枚舉集合。EnumSet保證集合中的元素不重複；EnumMap中的 key是enum類型，而value則可以是任意類型。

1. EnumSet的簡單用法

　　enumSet繼承AbstractSet，AbstractSet實現了set接口。

public abstract class EnumSet<E extends Enum<E>> extends AbstractSet<E>
    implements Cloneable, java.io.Serializable
{
。。。
}

public abstract class AbstractSet<E> extends AbstractCollection<E> implements Set<E> {
。。。
}

package enumTest;

import java.util.EnumSet;
import java.util.Iterator;

public class Test {
    public static void main(String[] args) {
        // 創建一個EnumSet集合，其內部的值就是MyDay枚舉類的實例
        EnumSet<MyDay> enumSet = EnumSet.allOf(MyDay.class);
        System.out.println(enumSet);
        Iterator<MyDay> iterator = enumSet.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }

        // 創建一個空的EnumSet集合
        System.out.println("====================");
        EnumSet<MyDay> enumSet2 = EnumSet.noneOf(MyDay.class);
        System.out.println(enumSet2);
        enumSet2.add(MyDay.MONDAY);
        System.out.println(enumSet2);

        // 創建一個帶有指定值的EnumSet
        System.out.println("====================");
        EnumSet<MyDay> enumSet3 = EnumSet.of(MyDay.MONDAY);
        enumSet2.add(MyDay.MONDAY);// 由於不可重複所以不會重複兩個元素
        System.out.println(enumSet3);
    }
}

[MONDAY---1, THUSDAY---2]
MONDAY---1
THUSDAY---2
====================
[]
[MONDAY---1]
====================
[MONDAY---1]

2. EnumMap的簡單用法

　　EnumMap繼承AbstractMap，AbstractMap繼承實現map接口。而且EnumMap中的中key必須爲枚舉類型，而且不能爲null

public class EnumMap<K extends Enum<K>, V> extends AbstractMap<K, V>
    implements java.io.Serializable, Cloneable
。。。
}

public abstract class AbstractMap<K,V> implements Map<K,V> {
  。。。  
}

package enumTest;

import java.util.EnumMap;
import java.util.HashMap;
import java.util.Map;

public class Test {
    public static void main(String[] args) {
        // 創建一個空的map
        EnumMap<MyDay, Object> enumMap = new EnumMap<>(MyDay.class);
        System.out.println(enumMap);
        enumMap.put(MyDay.MONDAY, "週一");
        enumMap.put(MyDay.THUSDAY, "週四");
        System.out.println(enumMap);

        // 創建第二個enumMap
        EnumMap<MyDay, Object> enumMap2 = new EnumMap<>(enumMap);
        System.out.println(enumMap2);

        // 以普通map爲參數創建第三個enumMap，要求key必須是枚舉類型
        Map map = new HashMap<>();
        map.put(MyDay.MONDAY, 111);
        EnumMap<MyDay, Object> enumMap3 = new EnumMap<>(map);
        System.out.println(enumMap3);
    }
}

{}
{MONDAY---1=週一, THUSDAY---2=週四}
{MONDAY---1=週一, THUSDAY---2=週四}
{MONDAY---1=111}

1.枚舉類型對象之間的值比較，是可以使用==，直接來比較值，是否相等的，不是必須使用equals方法的喲。

2.我們大概瞭解了枚舉類型的定義與簡單使用後，現在有必要來了解一下枚舉類型的基本實現原理。

實際上在使用關鍵字enum創建枚舉類型並編譯後，編譯器會爲我們生成一個相關的類，這個類繼承了Java API中的java.lang.Enum類，也就是說通過關鍵字enum創建枚舉類型在編譯後事實上也是一個類類型而且該類繼承自java.lang.Enum類。

3.Enum抽象類常見方法

Enum是所有 Java 語言枚舉類型的公共基本類（注意Enum是抽象類），以下是它的常見方法：

返回類型	方法名稱	方法說明
`int`	`compareTo(E o)`	比較此枚舉與指定對象的順序
`boolean`	`equals(Object other)`	當指定對象等於此枚舉常量時，返回 true。
`Class<?>`	`getDeclaringClass()`	返回與此枚舉常量的枚舉類型相對應的 Class 對象
`String`	`name()`	返回此枚舉常量的名稱，在其枚舉聲明中對其進行聲明
`int`	`ordinal()`	返回枚舉常量的序數（它在枚舉聲明中的位置，其中初始常量序數爲零）
`String`	`toString()`	返回枚舉常量的名稱，它包含在聲明中
`static<T extends Enum<T>> T`	`static valueOf(Class<T> enumType, String name)`	`返回帶指定名稱的指定枚舉類型的枚舉常量。`

4.values()方法和valueOf(String name)方法是編譯器生成的static方法

Java基礎：枚舉

1.用法一:常量

2.用法二：switch

3.用法三：向枚舉中添加新方法

4.用法四：覆蓋枚舉的方法

5.用法五：實現接口

6.用法六：使用接口組織枚舉

7.用法七：關於枚舉集合的使用

1. EnumSet的簡單用法

2. EnumMap的簡單用法

設計模式：MVC模式

Java基礎：枚舉

Java基礎：基本類型和包裝類

Java基礎：序列化與反序列化

Java基礎：多線程編程

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結