枚举类型

使用枚举类型设置常量

public class ConstantsTest {
	enum Constants2 { // 将常量放置在枚举类型中
		Constants_A, Constants_B
	}
	
	// 定义一个方法，这里的参数为枚举类型对象
	public static void doit2(Constants2 c) { 
		switch (c) { // 根据枚举类型对象做不同操作
			case Constants_A:
				System.out.println("doit2() Constants_A");
				break;
			case Constants_B:
				System.out.println("doit2() Constants_B");
				break;
		}
	}
	
	public static void main(String[] args) {
		ConstantsTest.doit2(Constants2.Constants_A); // 使用枚举类型中的常量
		ConstantsTest.doit2(Constants2.Constants_B); // 
	}
}

深入了解枚举类型

操作枚举类型成员的方法

枚举类型中构造方法

import static java.lang.System.*;

public class EnumIndexTest {
	enum Constants2 { // 将常量放置在枚举类型中
		Constants_A("我是枚举成员A"), // 定义带参数的枚举类型成员
		Constants_B("我是枚举成员B"), 
		Constants_C("我是枚举成员C"), 
		Constants_D(3);
		
		private String description;
		private int i = 4;
		
		private Constants2() {
		}
		 // 定义参数为String型的构造方法
		private Constants2(String description) {
			this.description = description;
		}
		
		private Constants2(int i) { // 定义参数为整型的构造方法
			this.i = this.i + i;
		}
		
		public String getDescription() { // 获取description的值
			return description;
		}
		
		public int getI() { // 获取i的值
			return i;
		}
	}
	
	public static void main(String[] args) {
		for (int i = 0; i < Constants2.values().length; i++) {
			out.println(Constants2.values()[i] + "调用getDescription()方法为："
					+ Constants2.values()[i].getDescription());
		}
		out.println(Constants2.valueOf("Constants_D") + "调用getI()方法为："
				+ Constants2.valueOf("Constants_D").getI());
		
		out.println(Constants2.Constants_D + " " + Constants2.Constants_D.getI());
	}
}

泛型

定义泛型类

public class OverClass<T> {
	private T over;
	public T getOver() {
		return over;
	}
	public void setOver(T over)
	{
		this.over = over;
	}
	
	public static void main(String[] args) {
		OverClass<Boolean> over1 = new  OverClass<Boolean>();
		OverClass<Float> over2 = new OverClass<Float>();
		
		over1.setOver(true);
		over2.setOver(12.1f);
		Boolean b = over1.getOver();
		Float f = over2.getOver();
		System.out.println(b);
		System.out.println(f);
	}
}

泛型的常规用法

• 定义泛型类时声明多个类型

MutiOverClass<Integer, String> mu = new MutiOverClass<Integer, String>();

• 定义泛型时声明数组类型
  
• 集合类中声明容易的元素

泛型的高级用法