第十一章总结

11.1枚举
JDK1.5中新增了枚举，枚举是一种数据类型，它是一系列具有名称的常量的集合。比如在数学中所学的集合：A={1，2，3}，当使用这个集合时，只能使用集合中的1，2，3这3个元素，不是这3个元素的值就无法使用。Java中的枚举也是同样的道理，比如在程序中定义一个性别枚举，里面只有两个值：男、女，那么在使用该枚举时，只能使用男和女这两个值，其他的任何值都是无法使用的。

 

使用枚举类型设置常量

以往设置常量，通常将常量放置在接口中，这样在程序中就可以直接使用，并且该常量不能被修改，因为在接口中定义常量时，该常量的修饰符为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来表示。

深入了解枚举类型
1.操作枚举类型成员的方法
枚举类型较传统定义常量的方式，除了具有参数类型检测的优势之外，还具有其他方面的优势。用户可以将一个枚举类型看作是一个类，它继承于java. lang. Enum类，当定义一个枚举类型时，每一个枚举类型成员都可以看作是枚举类型的一个实例，这些枚举类型成员都默认被final、public、static修饰，所以当使用枚举类型成员时直接使用枚举类型名称调用枚举类型成员即可。由于枚举类型对象继承于java. lang. Enum类，所以该类中一些操作枚举类型的方法都可以应用到枚举类型中。表11.1中列举了枚举类型中的常用方法。

1.values()：将枚举类型成员以数组的形式返回。

 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());
		}
	}
}

 

.枚举类型中的构造方法

在枚举类型中，可以添加构造方法，但是规定这个构造方法必须为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)枚举类型中的常量成员必须在其他成员之前定义，否则这个枚举类型不会产生对象。

 

使用枚举类型的优势

枚举类型声明提供了一种用户友好的变量定义方法，枚举了某种数据类型所有可能出现的值。总结枚举类型，它具有以下特点：
(1)类型安全。
(2)紧凑有效的数据定义。
(3)可以和程序其他部分完美交互。

(4)运行效率高。

泛型
在JDK1.5版本中提供了泛型概念，泛型实质上就是使程序员定义安全的类型。在没有出现泛型之前，Java也提供了对Object的引用“任意化”操作，这种任意化操作就是对Object引用进行“向下转型”及“向上转型”操作，但某些强制类型转换的错误也许不会被编译器捕捉，而在运行后出现异常，可见强制类型转换存在安全隐患，所以提供了泛型机制。本节就来探讨泛型机制。
回顾向上转型和向下转型

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);
	}
}

 

定义泛型类

Object类为最上层的父类，很多程序员为了使程序更为通用，设计程序时通常使传入的做回的值都以Object类型为主。当需要使用这些实例时，必须正确地将该实例转换为原来的类型.则在运行时将会发生ClassCastException异常。

泛型的常规用法

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));
		}
	}
}

 

集合类声明容器的元素

1.  

   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));
   		}
   	}
   }

 

 

泛型的高级用法

1.通过类型参数T的继承限制泛型类型

默认可以使用任何类型来实例化一个泛型类对象，但Java中也对泛型类实例的类型作了限制，这主要通过对类型参数T实现继承来体现。

anyClass:接口或者类

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
public class Limitclass<T extends List> {//限制泛型的类型
public static void main (string[] args) {//可以实例化已经实现List接口的类
Limitclass<ArrayList> 11 = new LimitClass<ArrayList>();
Limitclass<LinkedList>12 = new Limitclass<LinkedList>();
//这句是错误的,因为HashMap没有实List()接口
//LimitClass<HashMap> 13=new Limitclass<HashMap>();

 

上面代码中，由于对象11是没有使用A<?>这种形式初始化出来的对象，所以它可以调用set(方法改变集合中的值,但2与l3则是通过使用通配符的方式创建出来的，所以不能改变集合中的值，所以无法调用set(）方法;另外，List<?>类型的对象可以接受String 类型的ArrayList集合，也可以接受Integer类型的LinkedList集合，也许有的读者会有疑问，List<?>12=11语句与List 12=11存在何种本质区别?使用通配符声明的名称实例化的对象不能对其加入新的信息，只能获取或删除。

技巧:
泛型类型限制除了可以向下限制之外,还可以向上限制,只要在定义时使用super关键字即可。例如,"A<? superList> a=null;”这样定义后,对象a只接受List接口或上层父类类型，如a=new A<Objec>0;o
3．继承泛型类与实现泛型接口
定义为泛型的类和接口也可以被继承与实现。
例如,在项目中创建一个类文件，在该类中继承泛型类。

public class Extendclass<T1>{
}
class Subclass<T1，T2,T3> extends ExtendClass<T1>{//泛型可以比父类多，但不可以比父
类少
}

 

如果在SubClass类继承ExtendClass类时保留父类的泛型类型，需要在继承时指明，如果没有指明，直接使用extends ExtendsClass语句进行继承操作，则SubClass类中的T1、T2和T3都会自动变为Object，所以在一般情况下都将父类的泛型类型保留。
定义的泛型接口也可以被实现。
例如，在项目中创建一个类文件，在该类中实现泛型接口。

 

interface TestInterface<T1>{
}
class SubClass2<T1,T2,T3> implements TestInterface<T1>{
}

11.2.5泛型总结

使用泛型需遵循以下原则。
(1 )泛型的类型参数只能是类类型，不可以是简单类型，如A<int>这种泛型定义就是错误的，

(2）泛型的类型个数可以是多个.
(3 ）可以使用extends关键字限制泛型的类型。

( 4）可以使用通配符限制泛型的类型。