疯狂java


您现在的位置: 疯狂软件 >> 新闻资讯 >> 正文

Java面向对象-枚举类


 

   

  可以创建几个对象?

  n多个:大部分的类,都可以随意创建对象,只要内存不爆掉

  1个:比如单例类

  有限的几个:采用单例类的设计思路,可以只允许创建少数的几个特定的对象;还有就是枚举类。

  创建少数几个对象,不用枚举类实现

  package testpack;

  public class Test1{

  public static void main(String[] args) {

  Season s=Season.getSeason("秋天");

  System.out.println(s.getName()+s.getDesc());

  }

  }

  class Season{

  public final static Season SPRING=new Season("春天","花开"); //所有实例用public final static 修饰

  public final static Season SUMMER=new Season("夏天","蝉鸣");

  public final static Season AUTOMN=new Season("秋天","落叶");

  public final static Season WINTER=new Season("冬天","大雪");

  private final String desc;

  private final String name;

  public static Season getSeason(String sea){ //提供一个静态方法获取实例

  switch(sea){

  case "春天":

  return SPRING;

  case "夏天":

  return SUMMER;

  case "秋天":

  return AUTOMN;

  case "冬天":

  return WINTER;

  default :

  return null;

  }

  };

  private Season(String name,String desc){ //用private隐藏构造器

  this.name=name;

  this.desc=desc;

  }

  public String getName(){

  return this.name;

  };

  public String getDesc(){

  return this.desc;

  }

  }

  创建少数几个对象,用枚举类改写

  package testpack;

  public class Test1{

  public static void main(String[] args) {

  Season s1=Season.SPRING; //像访问类变量一样获得一个枚举类的对象

  Season s2=Season.valueOf("AUTOMN"); //通过valueOf(参数)也可以。这里的参数得跟枚举类第一行列出的枚举对象名一致

  Season.showStaticDesc(); //调用枚举类的类方法

  System.out.println("调用实例方法:"+s1.toString()); //调用枚举对象的实例方法

  System.out.println("s1的索引号: "+s1.ordinal()); //ordinal()方法返回这个对象在枚举类第一行的顺序号,0-based

  System.out.println("s2的索引号: "+s2.ordinal());

  System.out.println("s1在s2的前面返回int负数:"+s1.compareTo(s2)); //枚举对象的compareTo()方法,其实就是s1.ordinal()-s2.ordinal()

  System.out.println(s1.name()); //枚举对象的name()方法返回枚举类第一行的枚举名称

  for (Season s:Season.values()) { //values()方法遍历Season枚举类

  System.out.println(s)

  }

  }

  }

  enum Season{ //在枚举类的第一行列出所有的枚举对象,个数多的话,可以分行

  SPRING("春天","花开"), //圆括号表示在调用构造方法,不写圆括号则调用默认的无参构造

  SUMMER("夏天","蝉鸣"), //所有的枚举对象默认被public static final修饰。是不是有点像不可变类?

  AUTOMN("秋天","落叶"), //AUTOMN相当于是Season类型的变量名,同时调用构造方法创建对象

  WINTER("冬天","大雪"); //相当于:public static final Season WINTER=new Season("冬天","大雪");

  private final String name; //枚举类可以包含实例变量,一般都用private final修饰,是不是又像不可变类

  private final String desc;

  private static final String staticDesc="枚举类可以包含类变量"; //枚举类可以包含类变量

  private Season(String name,String desc){ //枚举类可以包含构造方法,只能是private或者默认private修饰

  this.name=name; //在构造方法中给实例变量初始化,

  this.desc=desc;

  }

  public static void showStaticDesc(){ //枚举类可以包含类方法

  System.out.println(staticDesc);

  }

  public String toString(){ //枚举类可以包含实例方法

  return "实例方法toString():季节名+描述:"+this.name+"+"+this.desc;

  }

  public String getName(){

  return this.name;

  }

  public String getDesc(){

  return this.desc;

  }

  }

  枚举类

  枚举类的关键字是enum,跟class、interface地位相同

  枚举类都默认继承java.lang.Enum,而不是java.lang.Object,因而不能显式的继承其他父类,否则就继承了两个类

  java.lang.Object是java.lang.Enum的直接父类,枚举类对象可以赋值给Object类型的变量

  java.lang.Enum实现了java.lang.Serializable和java.lang.Comparable接口

  非抽象的枚举类默认有final修饰,因而不能被继承

  枚举类的构造器只能用private修饰符,因为不能让外部随意创建对象嘛

  枚举类的所有实例必须在第一行列出,并默认添加public static final修饰

  枚举类名.values()方法可以遍历所有枚举类对象

  通过枚举类名.枚举对象名可以返回枚举类对象;Enum.valueOf(枚举类.class,枚举对象名)也可以

  枚举类的主要方法

  int compareTo(E o):比较两个枚举对象的顺序,调用对象位于参数对象之前返回负int

  String name():返回枚举对象的名字,就是枚举类中第一行列出的枚举对象的名字

  int ordinal():返回该枚举对象的索引号,就是在枚举类第一行的顺序号,第一个顺序号0

  String toString():枚举类一般都重写这个方法

  static >T valueOf(Class enumType,String name):Enum的静态方法,返回一个枚举类中与name相同名称的枚举对象,比如Enum.valueOf(Season.class,"AUTOMN")

  枚举类的成员变量、方法、构造器

  枚举类中可以包含类变量、类方法、实例变量、实例方法、构造方法

  实例变量一般都在构造方法中初始化,枚举类一般都设计为不可变类,用private final修饰,且不提供setter方法

  实例变量、构造器、第一行声明枚举对象:

  第一行声明枚举对象时,如果不写圆括号,或者写无参数的圆括号,那么构造器要么不写,要么是无参构造器

  也就是说如果不写构造器,那么有一个默认的无参构造器,初始化赋值就是:0;0.0;false;null

  如果写了带参数的圆括号,那么就得写对应的构造器

  如果写了有参数的构造器,那么第一行声明枚举对象时,就得传入对应的参数

  以上所述,就是说第一行声明枚举对象时,实际上就是在调用构造方法创建对象,然后将这些对象赋值给声明的枚举对象名

  枚举类实现接口

  枚举类可以像类一样,实现若干个接口,也用implements

  可以把接口的方法实现一次,每个枚举对象公用相同的一个方法,示例

  package testpack;

  public class Test1{

  public static void main(String[] args) {

  Season s=Enum.valueOf(Season.class, "SUMMER");

  s.year();

  }

  }

  enum Season implements Year{

  SPRING,SUMMER,AUTOMN,WINTER;

  public void year(){

  System.out.println("一年有四季");

  }

  }

  interface Year{

  public void year();

  }

  还可以每个枚举对象,都把接口的抽象方法实现一次,各个对象的这个方法行为不同,示例

  package testpack;

  public class Test1{

  public static void main(String[] args) {

  Season s1=Enum.valueOf(Season.class, "SPRING");

  Season s2=Enum.valueOf(Season.class, "SUMMER");

  Season s3=Enum.valueOf(Season.class, "AUTOMN");

  Season s4=Enum.valueOf(Season.class, "WINTER");

  s1.year();

  s2.year();

  s3.year();

  s4.year();

  }

  }

  enum Season implements Year{

  SPRING{

  public void year(){ //实际上就是匿名内部类

  System.out.println("一年有四季:这是春天");

  }

  },SUMMER{

  public void year(){ //创建的不是Season的对象,而是Season的匿名子类的对象

  System.out.println("一年有四季:这是夏天");

  }

  },AUTOMN{

  public void year(){

  System.out.println("一年有四季:这是秋天");

  }

  },WINTER{

  public void year(){

  System.out.println("一年有四季:这是冬天");

  }

  };

  }

  interface Year{

  public void year();

  }

  上面的代码实际上就是创建了Season的匿名子类的对象,看编译后生的字节码文件

  Test1.class

  Year.class

  Season.class

  Season$1.class

  Season$2.class

  Season$3.class

  Season$4.class

  枚举类可以包含抽象方法

  枚举类可以包含抽象方法,但不需要用abstract修饰该枚举类

  每个枚举值必须实现这个抽象方法

  这个跟实现一个接口是一个道理,只是把抽象方法从接口转移到自己这个枚举类里

  其他

  switch语句的控制表达式可以是任何枚举类型