11.1枚举
JDK1.5中新增了枚举,枚举是一种数据类型,它是一系列具有名称的常量的集合。比如在数学中所学的集合:A={1,2,3},当使用这个集合时,只能使用集合中的1,2,3这3个元素,不是这3个元素的值就无法使用。Java中的枚举也是同样的道理,比如在程序中定义一个性别枚举,里面只有两个值:男、女,那么在使用该枚举时,只能使用男和女这两个值,其他的任何值都是无法使用的。
11.1.1使用枚举类型设置常量
以往设置常量,通常将常量放置在接口中,这样在程序中就可以直接使用,并且该常量不能被修改,因为在接口中定义常量时,该常量的修饰符为final与static.
public interface Constants{
public static final int Constants_A=1;//定义一个泛型变量并赋初值
public static final int Conostants_B=12;
}
在JDK1.5版本中新增枚举类型后就逐渐取代了这种常量定义方式,因为通过使用枚举类型,可以赋予程序在编译时进行检查的功能。语法如下:
public enum Constants{
Constants_A,//泛型常量
Constants_B,
Constants_c
}
其中,enum是定义枚举类型的关键字。当需要在程序中使用该常量时,可以使用Constants.Constant_A来表示。
interface Constants { // 将常量放置在接口中
public static final int Constants_A = 1;
public static final int Constants_B = 12;
}
public class test12{
enum Constants2 { // 将常量放置在枚举类型中
Constants_A, Constants_B
}
// 使用接口定义常量
public static void doit(int c) { // 定义一个方法,这里的参数为int型
switch (c) { // 根据常量的值做不同操作
case Constants.Constants_A:
System.out.println("doit() Constants_A");
break;
case Constants.Constants_B:
System.out.println("doit() Constants_B");
break;
}
}
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) {
test12.doit(Constants.Constants_A); // 使用接口中定义的常量
test12.doit2(Constants2.Constants_A); // 使用枚举类型中的常量
test12.doit2(Constants2.Constants_B); // 使用枚举类型中的常量
test12.doit(3);
// ConstantsTest.doit2(3);
}
}
运行结果:
11.1.2深入了解枚举类型
1.操作枚举类型成员的方法
枚举类型较传统定义常量的方式,除了具有参数类型检测的优势之外,还具有其他方面的优势。用户可以将一个枚举类型看作是一个类,它继承于java. lang. Enum类,当定义一个枚举类型时,每一个枚举类型成员都可以看作是枚举类型的一个实例,这些枚举类型成员都默认被final、public、static修饰,所以当使用枚举类型成员时直接使用枚举类型名称调用枚举类型成员即可。由于枚举类型对象继承于java. lang. Enum类,所以该类中一些操作枚举类型的方法都可以应用到枚举类型中。表11.1中列举了枚举类型中的常用方法。
1.values():将枚举类型成员以数组的形式返回。
import static java.lang.System.out;
public class test12 {
enum Constants2 { // 将常量放置在枚举类型中
Constants_A, Constants_B
}
// 循环由values()方法返回的数组
public static void main(String[] args) {
for (int i = 0; i < Constants2.values().length; i++) {
// 将枚举成员变量打印
out.println("枚举类型成员变量:" + Constants2.values()[i]);
}
}
}
运行结果:
2.valueOf()与compareTo()
枚举类型中静态方法valueOft)可以将普通字符串转换为枚举类型,而compareTo(万房)较两个枚举类型成员定义时的顺序。调用compareTo(方法时,如果方法中参数在调用该方法对象位置之前,则返回正整数;如果两个互相比较的枚举成员的位置相同,则返回0;如参数在调用该方法的枚举对象位置之后,则返回负整数。
import static java.lang.System.out;
public class test12 {
enum Constants2 { // 将常量放置在枚举类型中
Constants_A, Constants_B, Constants_C, Constants_D
}
// 定义比较枚举类型方法,参数类型为枚举类型
public static void compare(Constants2 c) {
// 根据values()方法返回的数组做循环操作
for (int i = 0; i < Constants2.values().length; i++) {
// 将比较结果返回
out.println(c + "与" + Constants2.values()[i] + "的比较结果为:" + c.compareTo(Constants2.values()[i]));
}
}
// 在主方法中调用compare()方法
public static void main(String[] args) {
compare(Constants2.valueOf("Constants_B"));
}
}
运行结果:
3.ordinal():获取枚举对象的位置索引值。
import static java.lang.System.out;
public class test12 {
enum Constants2 { // 将常量放置在枚举类型中
Constants_A, Constants_B, Constants_C
}
public static void main(String[] args) {
for (int i = 0; i < Constants2.values().length; i++) {
// 在循环中获取枚举类型成员的索引位置
out.println(Constants2.values()[i] + "在枚举类型中位置索引值" + Constants2.values()[i].ordinal());
}
}
}
运行结果:
2.枚举类型中的构造方法
在枚举类型中,可以添加构造方法,但是规定这个构造方法必须为private修饰符或者默认修饰符所修饰。
import static java.lang.System.out;
public class test12 {
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) { // 定义参数为int型的构造方法
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());
}
}
运行结果:
import static java.lang.System.out;
interface d {
public String getDescription();
public int getI();
}
public enum test12 implements d {
Constants_A { // 可以在枚举类型成员内部设置方法
public String getDescription() {
return ("我是枚举成员A");
}
public int getI() {
return i;
}
},
Constants_B {
public String getDescription() {
return ("我是枚举成员B");
}
public int getI() {
return i;
}
},
Constants_C {
public String getDescription() {
return ("我是枚举成员C");
}
public int getI() {
return i;
}
},
Constants_D {
public String getDescription() {
return ("我是枚举成员D");
}
public int getI() {
return i;
}
};
private static int i = 5;
public static void main(String[] args) {
for (int i = 0; i < test12.values().length; i++) {
out.println(test12.values()[i] + "调用getDescription()方法为:" +test12.values()[i].getDescription());
out.println(test12.values()[i] + "调用getI()方法为:" +test12.values()[i].getI());
}
}
}
运行结果:
注意:
(1)从上面代码中可以看出,枚举类型可以实现一个或者多个接口,但是它不能继承类。因为编译器会影响将枚举类型继承自java. lang. Enum类,这一过程由编译器完成。
(2)枚举类型中的常量成员必须在其他成员之前定义,否则这个枚举类型不会产生对象。
11.1.3 使用枚举类型的优势
枚举类型声明提供了一种用户友好的变量定义方法,枚举了某种数据类型所有可能出现的值。总结枚举类型,它具有以下特点:
(1)类型安全。
(2)紧凑有效的数据定义。
(3)可以和程序其他部分完美交互。
(4)运行效率高。
11.2泛型
在JDK1.5版本中提供了泛型概念,泛型实质上就是使程序员定义安全的类型。在没有出现泛型之前,Java也提供了对Object的引用“任意化”操作,这种任意化操作就是对Object引用进行“向下转型”及“向上转型”操作,但某些强制类型转换的错误也许不会被编译器捕捉,而在运行后出现异常,可见强制类型转换存在安全隐患,所以提供了泛型机制。本节就来探讨泛型机制。
11.2.1回顾向上转型和向下转型
public class test12 {
private Object b; // 定义Object类型成员变量
public Object getB() { // 设置相应的getXXX()方法
return b;
}
public void setB(Object b) { // 设置相应的setXXX()方法
this.b = b;
}
public static void main(String[] args) {
test12 t = new test12();
t.setB(new Boolean(true)); // 向上转型操作
System.out.println(t.getB());
t.setB(new Float(12.3));
Float f = (Float) (t.getB()); // 向下转型操作
System.out.println(f);
}
}
运行结果:
11.2.2定义泛型类
Object类为最上层的父类,很多程序员为了使程序更为通用,设计程序时通常使传入的做回的值都以Object类型为主。当需要使用这些实例时,必须正确地将该实例转换为原来的类型.则在运行时将会发生ClassCastException异常。
类名<T>
public class test12<T> {
private T[] array; // 定义泛型数组
public void SetT(T[] array) { // 设置SetXXX()方法为成员数组赋值
this.array = array;
}
public T[] getT() { // 获取成员数组
return array;
}
public static void main(String[] args) {
test12<String> a = new test12<String>();
String[] array = { "成员1", "成员2", "成员3", "成员4", "成员5" };
a.SetT(array); // 调用SetT()方法
for (int i = 0; i < a.getT().length; i++) {
System.out.println(a.getT()[i]); // 调用getT()方法返回数组中的值
}
}
}
运行结果:
11.2.3泛型的常规用法
1.定义泛型类时声明多个类型
在定义泛型类时,可以声明多个类型
Class<T1,T2>
Class:泛型类名称
2.定义泛型类时声明数组类型
import java.util.HashMap;
import java.util.Map;
public class test12<K, V> {
public Map<K, V> m = new HashMap<K, V>(); // 定义一个集合HashMap实例
// 设置put()方法,将对应的键值与键名存入集合对象中
public void put(K k, V v) {
m.put(k, v);
}
public V get(K k) { // 根据键名获取键值
return m.get(k);
}
public static void main(String[] args) {
// 实例化泛型类对象
test12<Integer, String> mu = new test12<Integer, String>();
for (int i = 0; i < 5; i++) {
// 根据集合的长度循环将键名与具体值放入集合中
mu.put(i, "我是集合成员" + i);
}
for (int i = 0; i < mu.m.size(); i++) {
// 调用get()方法获取集合中的值
System.out.println(mu.get(i));
}
}
}
运行结果:
3.集合类声明容器的元素
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Vector;
public class ListClass {
public static void main(String[] args) {
// 定义ArrayList容器,设置容器内的值类型为Integer
ArrayList<Integer> a = new ArrayList<Integer>();
a.add(1); // 为容器添加新值
for (int i = 0; i < a.size(); i++) {
// 根据容器的长度循环显示容器内的值
System.out.println("获取ArrayList容器的值:" + a.get(i));
}
// 定义HashMap容器,设置容器的键名与键值类型分别为Integer与String型
Map<Integer, String> m = new HashMap<Integer, String>();
for (int i = 0; i < 5; i++) {
m.put(i, "成员" + i); // 为容器填充键名与键值
}
for (int i = 0; i < m.size(); i++) {
// 根据键名获取键值
System.out.println("获取Map容器的值" + m.get(i));
}
// 定义Vector容器,使容器中的内容为String型
Vector<String> v = new Vector<String>();
for (int i = 0; i < 5; i++) {
v.addElement("成员" + i); // 为Vector容器添加内容
}
for (int i = 0; i < v.size(); i++) {
// 显示容器中的内容
System.out.println("获取Vector容器的值" + v.get(i));
}
}
}
运行结果: