java第十一章总结

目录

 11.1 枚举

  11.1.1 使用枚举类型设置常量

   11.1.2 深入了解枚举类型

11.1.3 使用枚举类型的优势

11.2 泛型

11.2.1 回顾"向上转型" 与"向下转型"

11.2.2 定义泛型类

11.2.3 泛型的常规用法

11.2.4 泛型的高级用法

11.2.5 泛型总结

11.3 小结

---

 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来表示。

例11.1 

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); //使用枚举类型中的常量
		//ConstantsTest.doit2(3);
		// TODO Auto-generated method stub

	}

}

 

 11.1.2 深入了解枚举类型

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

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

 
public class ShowEnum {
 
		    enum Constants { // 将常量放置在枚举类型中
		        Constants_A, Constants_B, Constants_C, Constants_D
		    }
		 
		    // 循环由values()方法返回的数组
		    public static void main(String[] args) {
		    	Constants enumArray[] = Constants.values();//values()方法返回枚举数组
		        for (int i = 0; i < enumArray.length; i++) {
		            // 将枚举成员变量打印
		            System.out.println("枚举类型成员变量：" + enumArray[i]);
		        }
		    }
		}

 

 2.valueOf()与compareTo()
枚举类型中静态方法valueOft)可以将普通字符串转换为枚举类型，而compareTo(万房)较两个枚举类型成员定义时的顺序。调用compareTo(方法时，如果方法中参数在调用该方法对象位置之前，则返回正整数；如果两个互相比较的枚举成员的位置相同，则返回0；如参数在调用该方法的枚举对象位置之后，则返回负整数.

 例11.3

enum Constants {  //将常量放在枚举类型中
	   Constants_A,
	   Constants_B,
	   Constants_C,
	   Constants_D
}
public class EnumMethodTest { //定义比较枚举类型方法,参数类型为枚举类型
     public static void compare(Constants c) {
    	 Constants array[] = Constants.values();//根据values()方法返回的数组 //将比较结果返回
    	 for (int i =0;i < array.length;i++) {
    		 System.out.println(c + "与" + array[i] + "的比较结果为:" + c.compareTo(array[i]));
    		 
    	 }
     }  //在主方法中调用compare()方法
	public static void main(String[] args) {
		compare(Constants.valueOf("Constants_B"));
		// TODO Auto-generated method stub

	}

}

 

 

 3.ordinal():获取枚举对象的位置索引值。

 例11.4

public class EnumIndexTest {
  enum Constats2 {  //将常量放在枚举类型中
	  Constants_A,
	   Constants_B,
	   Constants_C
  }
	public static void main(String[] args) {
		Constants2[] arrayCon = Constants2.values();
		for (int i =0;i<arrayCon.length;i++) {  //在循环中获取枚举类型成员的索引位置
			System.out.println(arrayCon[i] + "在枚举类型中位置索引值"
		+ arrayCon [i].ordinal());
		}
		// TODO Auto-generated method stub

	}

}

 

 

 例11.5

public class EnumConTest {
	enum Constants2 {  //将常量放置在枚举类型中
		 Constants_A("我是枚举成员A"), //定义带参数的枚举类型成员
		   Constants_B("我是枚举成员B"),
		   Constants_C("我是枚举成员C"),
		   Constants_D(3);
		private String description;
		private int i =4;
		//定义参数为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) {
		// TODO Auto-generated method stub
		Constants2 array[] = Constants2.values(); //获取枚举成员数组
		for(int i = 0;i<array.length;i++) {
			System.out.println(array[i] + "调用getDescription()方法为:" +array[i]. getDescription());
		}
    Constants2 c2 = Constants2.valueOf("Constants_D"); //将字符串转换成枚举对象
    System.out.println(c2 + "调用getI()方法为:" + c2.getI());
	}

}

 

例11.7

public class Test {
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) {
			// TODO Auto-generated method stub
			Test t = new Test();
			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);
	}

}

 

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

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接口的类
		// TODO Auto-generated method stub
		LimitClass<ArrayList> l1 = new LimitClass<ArrayList>();
		LimitClass<LinkedList> l2 = new LimitClass<LinkedList>();
		//这句是错误的,因为HashMap没有实现List()接口
		//LimitListClass<HashMap> l3 = new LimitClass<HashMap>();
		

	}

}

例11.11

import java.util.*;

public class WildClass {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		List<String> l1 = new ArrayList<String>();  //创建一个ArrayList对象
l1.add("成员"); //在集合中添加内容
List<?> l2 = l1;  //使用通配符
List<?> l3 = new LinkedList<Integer>();
System.out.println("l1:" +l1.get(0)); //获取l1集合中第一个值
System.out.println("l2:" +l2.get(0)); //获取l2集合中第一个值
l1.set(0, "成员改变"); //使用通配符的对象不能调用set()方法
//l2.add("添加");    //使用通配符的对象不能调用add方法
// l2.set(0,"成员改变"); //使用通配符的对象不能调用set方法
//13.add(1);
//13.set(0,1);
System.out.println("l1:" +l1.get(0));
	}

}