Java高质量代码之 — 枚举与注解

前言:由于上一个星期工作繁忙,利用上下班和晚上睡前空余的时间拜读了秦小波老师的《改善Java程序的151建议》,感觉廓然开朗,注意到了很多平时在编写代码中并不会注意的问题,甚至感觉自己对Java只是略懂皮毛,不足以登大雅之堂,特此与读者分享读书笔记,以下内容摘自《改善Java程序的151建议》一书和笔者的理解


Java高质量代码系列文章
      面向对象篇:http://ray-yui.iteye.com/blog/1926984
      数据类型篇:http://ray-yui.iteye.com/blog/1927251
          字符串篇:http://ray-yui.iteye.com/blog/1927647
      数组与集合(1):http://ray-yui.iteye.com/blog/1928170
      数组与集合(2):http://ray-yui.iteye.com/blog/1930155
      枚举与注解:http://ray-yui.iteye.com/blog/1931408
      泛型与发射:http://ray-yui.iteye.com/blog/1933127
                  异常:http://ray-yui.iteye.com/blog/1938946
                      杂:http://ray-yui.iteye.com/blog/1942591


      Java从4到5之间有着非常多的变化,那是一个质的飞跃,在Java5之后引入了注解(Annotation),枚举(Enum),枚举(Enum)更符合面向对象的语义性,为开发者带来诸多的便利,注解(Annotation)相信开发过SSH框架的读者对注解绝对不会陌生,而特别是Spring更是大量应用了注解充当配置文件,



1.推荐使用枚举定义常量
      常量的声明是每个项目都不可缺少的,又或者是变相使用了数据字典的形式定义了常量,以往我们基本都使用类常量或接口常量的方式声明常量,但Java1.5以后,建议我们使用枚举(Enum)来声明常量,以下我们来看一下两种方式

public interface Test {

	int SPRING = 0;
	int Summer = 1;
	int Autumn = 2;
	int Winter = 3;
}

public enum Test {
	SPRING, SUMMER, AUTUMN, WINTER
}

      枚举类型比接口常量声明的方式优势体现在哪里呢?
      1.枚举类型声明比接口常量声明更简单

      2.枚举类型其值为稳定的,使用起来更加安全和稳定,请看以下例子

public static void main(String[] args) {
		int num = 1;
		switch (num) {
		case TestInterface.spring:
			System.out.println("Spring");
			break;
		case TestInterface.summer:
			System.out.println("Summer");
			break;
		case TestInterface.autumn:
			System.out.println("Autumn");
			break;
		case TestInterface.winter:
			System.out.println("Winter");
			break;
		default:
			System.out.println("error");
		}

		// Enum
		TestEnum enum1 = TestEnum.SUMMER;
		switch (enum1) {
		case SPRING:
			System.out.println(TestEnum.SPRING.name());
			break;
		case SUMMER:
			System.out.println(TestEnum.SUMMER.name());
			break;
		case AUTUMN:
			System.out.println(TestEnum.AUTUMN.name());
			break;
		case WINTER:
			System.out.println(TestEnum.WINTER.name());
			break;
		}
	}

        从上面一段简短的代码就可以看出两者的区别,首先第一段使用接口常量,
        若然此时我的num是10呢?能否传递到switch当中,答案当然是完全可以的,  
        而枚举呢?甚至不需要编写default,因为在case当中已经穷举了所有的枚举
        类型,而枚举类型只的值只能限制与枚举所声明的,还有一点,当我想要把
        0 = spring时,我可以怎么做?像作者一样写一个switch吧.而枚举类型只需
        要简单的调用.name()即可获得枚举类型的名字,也就是SPRING

      3.枚举类型具有内置方法,从上面已经可以看出枚举类型具有name方法获取
        枚举的名字,当然还有values()方法返回1个枚举类内的枚举型,ordinal()
        返回枚举类型的下标等等.

      4.枚举类型可以自定义方法,每个枚举类中的枚举类型实际上就是枚举类的
       一个对象,一个实例,对象当然可以拥有方法,构造方法,非静态方法等,但枚
       举类型不能继承,枚举类型除非重构,否则是无法扩展的,在项目当中推荐使
        用枚举代替接口常量


2.使用构造函数描述枚举项
      当我们想要使用一个业务逻辑,当使用枚举值为SPRING,但想返回中文为春天时,我们可以怎么做的?此时枚举项的构造函数将会帮助你有效完成

public enum TestEnum {
	SPRING("春天"), SUMMER("夏天"), AUTUMN("秋天"), WINTER("冬天");

	private String name;

	TestEnum(String name) {
		this.name = name;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

}

      就像编写普通的构造函数一样编写枚举类的构造函数即可,但注意,枚举类型的构造函数是不能有public修饰的构造函数，构造函数都是隐含private，编译器自动处理,每个枚举值隐含都是由public static final修饰的，不需要添加这些修饰符。,此时当使用枚举时调用getName()方法即可获得春,夏,秋,冬,而使用接口常量要实现以上逻辑,2个字,麻烦


3.注意枚举的空值
      我们注意,上述曾说过,枚举类型是枚举类的一个实例,对象,那既然是对象当然可以为null,所以在使用switch或枚举类型时,要注意空值的判断


4.在switch的default代码增加异常
      上述也曾说过,在使用枚举时,switch当中可以不编写default,因为枚举类型是限定的,稳定的,只要在case当中穷举枚举的值就可以保证不会执行到default,但前提是在case中进行声明,这就涉及到switch和枚举的关系,是非常脆弱的,只要手工增加了多一个枚举,就必须在switch中编写case,当遇到这种情况时,在default中抛出异常或记录日志就变得重要


5.使用valueOf前必须进行检验
      每个枚举类都拥有valueOf()的方法,用来将字符串类型的值转换成一个枚举类型,请观察以下代码

public static void main(String[] args) {
		String str = "Spring";
		TestEnum enum1 = TestEnum.valueOf(str);
		if (enum1 == null)
			System.out.println("转换失败");
		else
			System.out.println("转换成功");

		// 很遗憾,程序运行结果抛出java.lang.IllegalArgumentException
	}

      从上面可以看到.我们已经对enum1进行了空值判断,那为什么还会抛出异常呢?原因是异常在调用valueOf()方法时已经抛出,注意我们的枚举是SPRING,而不是Spring,因大小写区分导致失败,我们可以用以下方式来进行判断

public static void main(String[] args) {
		String str = "Spring";
		TestEnum enum1 = null;
		for (TestEnum e : TestEnum.values()) {
			if (str.equals(e.getName())) {
				enum1 = TestEnum.valueOf(str);
			}
		}
		// 先进行判断即可解决异常参数问题
	}

6.使用枚举工厂代替工厂
      以下代码为工厂模式的传统实现

interface Car {

}

class FordCar implements Car {

}

class BuickCar implements Car {

}

class CarFactory {
	public static Car createCar(Class<? extends Car> c) {
		try {
			return (Car) c.newInstance();
		} catch (Exception e) {
			e.printStackTrace();
		}
		return null;
	}
}

      以上代码为实现工厂模式的其中一种,当然亦可以传递字符串通过反射创建等等,以下就来看一下使用枚举类型的实现

public enum CarFactory {

	FordCar {
		@Override
		public Car createCar() {
			return new FordCar();
		}
	},
	BuickCar {
		@Override
		public Car createCar() {
			return BuickCar();
		}
	};
	public abstract Car createCar();
}

      枚举当中亦可定义抽象方法,通过抽象方法强制要求每个枚举项都需要实现该方法,而不同的枚举项返回不同的子类,从而实现了工厂方法,使用枚举类型实现工厂方法有以下三个优点
      1.避免错误调用的发生,一般的工厂模式的生产方法都是接受字符串,int类
        型,Class等,但这三种参数是具有宽度的,例如null,边界问题,或Car.class
        等,而且出现这种问题编译时还是可以正常通过的,造成了不必要的错误
     
      2.降低类之间的耦合,不管生产方法接受的是String,int或class,这些都不是
        客户端必须的,而是工厂方法需要的限制,例如class,他必须要传递一个子
        类型的class才能实例化该类型,这严重违背了迪米特原则,也就是最少知识
        原则,一个对象应该对其他对象最少的了解

      3.性能好,使用便捷,枚举类型是以int类型的计算为基础,这是Java中最基本
        的操作,速度当然是非常快速的,至于使用便捷,从代码中就可以看出,我是
        汽车工厂,我需要一辆别克汽车,完全具备面向对象应该拥有的语义性


7.枚举项的数量限制在64个以内
      为什么要枚举类型要限制在64个以内呢?在看这个问题之前首先我们要知道，JDK为了帮助我们更方便的处理枚举类型，为我们提供了EnumSet和EnumMap两个集合,该集合的详细方法请参考JDK帮助文档,以下来看一段代码

public static void main(String[] args) {
		EnumSet<TestEnum> enumSet = EnumSet.allOf(TestEnum.class);

		// LargeTestEnum数量为>64
		EnumSet<LargeTestEnum> enumSet2 = EnumSet.allOf(LargeTestEnum.class);

		System.out.println(enumSet.getClass());
		// 输出为java.util.RegularEnumSet

		System.out.println(enumSet2.getClass());
		// 输出为java.util.JumboEnumSet

	}

      从以上代码可以看到,仅仅因为多出一个枚举类型就导致EnumSet的实现类不一样,这是因为JDK在遇到枚举类型小于等于64个的时候会创建java.util.RegularEnumSet,而遇到大于64时则会创建java.util.JumboEnumSet,这是因为底层JDK使用了Long类型进行了映射,我们都知道Long类型是64位的,而枚举类型又可以化为整数来储蓄,刚好64个枚举类型对应到Long类型的64位进行存储,而当大于64时,则需要使用java.util.JumboEnumSet来创建,使用了Long数组进行存储



======================我是枚举和注解的分割线====================




8.小心注解继承
      请观察以下代码

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Inherited
public @interface TestAnnotation {
	String test() default "Hello World";
}

      以上代码就是声明了一个注解,其中该注解上的三个注解为原元注解,@Retention表示运行时的保留级别,@Target代表该注解可以被方式在什么地方,@Inherited代表该注解是否可以被继承,而需要注意的地方就是@Inherited,例如类A使用了增加了@Inherited的注解,类B继承类A,会将增加在类A的注解一并继承下来,这样做利有弊,利的地方是当为父类增加了注解就可以让子类自动继承,从而达到整齐,统一和方便管理,而弊的地方就是从代码阅读的层面上,只阅读子类代码无法了解到该注解,这是非常糟糕的设计,所以能不使用时尽量不要使用@Inherited


9.注解配合枚举使用威力更大
      注解中声明的类型可以是枚举类型,这样配合使用将更加能表达语义


10.注意@Override版本问题
      在Java5的编译环境是,若复写父类方法是,父类若然是接口,增加@Override则不能算是复写,会报出编译错误,而若然是Java6则进行了宽松处理,实现接口方法亦可以增加@Override,若然是Java6移植到Java5的环境上,就需要注意了


总结:
      笔者在本文章中只从《改善Java程序的151建议》中提取部分进行归纳性叙述,推荐各位读者购买这本书,该书不仅从事例中学习,而且涉及到原理,底层的实现,不仅告诉你应该怎么做,还告诉你为什么要这样做.

评论

4 楼 ray_yui 2013-08-28  

zjf201172653 写道

楼主：
枚举类型的构造函数是没有访问修饰符的，这句话有问题吧？

（1）枚举类不能有public修饰的构造函数，构造函数都是隐含private，编译器自动处理。
（2）每个枚举值隐含都是由public、static、final修饰的，不需要添加这些修饰符。

非常感谢你的提醒,是我没有注意到这个问题..

3 楼 zjf201172653 2013-08-28  

楼主：
枚举类型的构造函数是没有访问修饰符的，这句话有问题吧？

（1）枚举类不能有public修饰的构造函数，构造函数都是隐含private，编译器自动处理。
（2）每个枚举值隐含都是由public、static、final修饰的，不需要添加这些修饰符。

2 楼 zeroman1212 2013-08-27  

拜读，有空深入使用一下，在项目当中使用。

1 楼 aine_pan 2013-08-27  

不得不提的《Effective Java》，作者是不是看过这本书？
不过写的不错！支持一下！