java枚举类

java枚举类

什么是枚举类？
在部分情况中，我们的类的对象是固定的，比如说class season，他的对象应该是只有四个的，这时候我们希望外部不能调用构造器创建新的对象，内部自己定义好要调用的对象。
这时候我们怎么做呢？

public class Season {
    public final static int spring =1;
    public final static int summer =2;
}

或许会想到这样去实现，但是要知道，这样是很不安全的，因为你不知道你以后会用它来干嘛。
比如说：

 System.out.println(spring + summer);

这不就离谱了？
而且在打印的时候，输出的spring是1，你怎么知道1是什么。
所以这样是不好的，那怎么改进呢？

public class Season {
    public final static Season Spring = null;
    public final static Season Summer = null;

    public static void main(String[] args) {
//        System.out.println(Spring + Summer);
    }
}

这样输出语句就不会出现这种非法使用 *** 作了。
但是，这样显然太繁琐了，为了更简单的使用枚举类，jdk1.5提供了enum关键字。

public enum season {
    Spring,Summer,Auntumn,Winter;
}

在这段代码中，我在枚举类season中创建了四个季节对象。
他们默认被public static final所修饰。
public保证他们能被合理调用。
static保证他们是被类所有。
final保证他们的指向不会改变，当然你可以改变指向的某属性的值。
当然，作为对象，他当然会有属性和方法。
现在我们简单测试一下：

public enum season {
    Spring,Summer,Auntumn,Winter;
    private String name;
    public String getname(){
        return name;
    }
}
class test{
    public static void main(String[] args) {
        System.out.println(season.Spring.getname());
    }
}

枚举对象定义是在枚举类的开头，多个对象通过逗号隔开，最后一个打上分号。
你会发现，调用枚举类的对象的方法是通过类.对象名。
你可以尝试直接输出枚举对象，或者输出枚举对象.name()。
他们返回的都是枚举对象的变量名。
不过不建议使用name方法，因为toString输出的明显用户体验更高。
而对于print方法，输出的时候是直接调用的对象的toString方法。
枚举类并不是继承于Object，他的toString默认情况下便是返回变量名。
例如这样：

public enum season {
    Spring,Summer,Auntumn,Winter;
    private String name;
    public String getname(){
        return name;
    }
    public String toString(){
        return "haha";
    }
}
class test{
    public static void main(String[] args) {
        System.out.println(season.Spring);
    }
}

我们知道，在类的属性没有初始化的时候，都会有默认值，那么我怎么在枚举类创建的时候就给他赋值呢？
1.通过初始化代码块。

    {
        name = this.name();
    }

注意不要用成类的初始化代码块了，否则所有的枚举对象的name属性都是相同的了。
2.构造器

public enum season {
    Spring("春天"),Summer("夏天"),Auntumn("球天"),Winter("冬天");
    private String name;
    private season(String name){
        this.name = name;
    }
    public String getname(){
        return name;
    }
    public String toString(){
        return "haha";
    }
}
class test{
    public static void main(String[] args) {
        System.out.println(season.Spring);
    }
}

注意一下创建对象的形式，后面有了形参列表。
注意构造器只能用private修饰，不显示的写出也会默认加上private。
另外，在不包含抽象方法的时候，枚举类默认使用final修饰。
这表明枚举类是不可继承的。
那在有抽象方法的时候呢？

public enum season {
    Spring("春天"){
        public void a(){

        }
    };
    private String name;
    public abstract void a();
    private season(String name){
        this.name = name;
    }
    public String getname(){
        return name;
    }
    public String toString(){
        return "haha";
    }
}
class test{
    public static void main(String[] args) {
        System.out.println(season.Spring);
    }
}
interface show{
    void display();
}

你会发现，你必须在创建枚举对象的时候，通过匿名内部类的方式来创建枚举对象。
但是我们知道，匿名内部类创建的是该类的匿名子类，而枚举类都是final修饰的，怎么会有子类呢？
这事因为，枚举类在含有抽象方法的时候，final自动转变为abstract。
但是！
并不能因此而创建所谓的抽象枚举类。
他只能被匿名子类继承。
说到抽象，就不得不说接口了。
我们一样可以通过implement来实现接口，然后重写接口种的抽象方法，我们可以在枚举类中重写，这样所有的枚举对象的该方法都一样。
我们也可以让所有的枚举对象都实现该接口，这样每个对象的该抽象方法不相同。