第十三章总结

一.枚举类型
1.使用枚举类型设置常量
2.深入了解枚举类型
3.使用枚举类型的优势
二.泛型
1.回顾向上转型和向下转型
        1.例子

2.定义泛型类
1.object类为最上层的父类，很多程序员为了使程序更为通用，设计程序时通常使传入的值与返回objct类型为主。当需要使用这些实例时，必须正确地将该实例转换为原来的类型，否则在时将会发生 ClassCastException 异常。

2.Java提供了泛型机制。其语法如下

类名<T>
 [例13.6]创建带泛型的图书类

public class Book<T> {//定义带泛型的book<t>类
    private T bookInfo;//参考类型：书籍信息
    public Book(T bookInfo) {//参数为类型形参的构造方法
        this.bookInfo= bookInfo;//为书籍信息赋值
    }
    public T getbookInfo() {
        return bookInfo;//获取书籍信息的值
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Book<String> bookName = new Book<String>("java从入门到精通");//创建参数为String类型的书名对象
        Book<String> bookAuther = new Book<String>("明日科技");//创建参数为String类型的作者对象
        Book<Double> bookPrice = new Book<Double>(69.8);//创建参数为Double类型的价格对象
        Book<Boolean> HasSourse = new Book<Boolean>(true);//创建参数为Boolean类型的附赠源代码
        //控制台输出书名，作者，价格和是否附赠光盘
        System.out.println("书名："+bookName.getbookInfo());
        System.out.println("作者："+bookAuther.getbookInfo());
        System.out.println("价格："+bookPrice.getbookInfo());
        System.out.println("是否附赠源代码："+HasSourse.getbookInfo());
        
    }
 
}

3.泛型的常规用法
1.定义泛型类时声明多个类型

        在定义泛型类时，可以声明多个类型。语法如下:

class MyClass<T1,T2>{}
        这样，在实例化指定类型的对象时就可以指定多个类型。例如:

MyClass <Boolean,Float> m = new MyClass <Boolean,Float>();
2.定义泛型类时声明数组类型

         [例13.7]定义泛型数组

public class ArrayClass<T> {
	private T[]array;//定义泛型数组
	public T[]getArray(){
		return array;
	}
	public void setArray(T[]array) {
		this.array=array;
	}
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		ArrayClass<String>demo=new ArrayClass<String>();
		String value[]= {"成员1","成员2","成员3","成员4","成员5"};
		demo.setArray(value);
		String array[]=demo.getArray();
		for(int i =0;i<array.length;i++) {
			System.out.println(array[i]);
		}
}
}

3.集合类声明容器的元素

表13.2常用的被泛型化的集合类

[例13.8]使用泛型约束集合的元素类型

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
 
public class AnyClass {
 
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//定义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));
		}
	}
 
}

4.泛型的高级用法
1.限制泛型可用类型

默认可以使用任何类型来实例化一个泛型类对象，但Java 中也对泛型类实例的类型作了限制。语法如下:

class 类名称<Textends anyClass>
使用泛型限制后，泛型类的类型必须实现或继承 anyClass 这个接口或类。无论 anyClass 是接口是类，在进行泛型限制时必须使用extends关键字。

[例13.9]限制泛型的类型必须为list的子类（代码最后一行是错误的）

import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
 
public class LimitClass<T extends List>  {
 
	public static void main(String[] args) {
		
		//可以实例化已经实现 List 接口的类
		LimitClass<ArrayList> l1= new LimitClass<ArrayList>();
	LimitClass<LinkedList> l2 = new LimitClass<LinkedList>();
	//这句是错误的，因为 HashMap 类没有实现List()接口
	LimitClass<HashMap> l3 = new LimitClass<HashMap>();
	}
 
}

2使用类型通配符

泛型机制中，提供了类型通配符，其主要作用是在创建一个泛型类对象时限制这个泛型类的类或承某个接口或类的子类。要声明这样一个对象可以使用“?”通配符来表示，同时使用 extends穿来对泛型加以限制。使用泛型类型通配符的语法如下:

泛型类名称<?extends List> a=null:
<extendsList>表示类型未知，当需要使用该泛型对象时，可以单独实例化。例如:

A<?extends List> a = null;
B=new A<ArrayList>();
B=new A<LinkedList>();
可以实例化一个限制泛型类型的实例，还可以将该实例放置在方法的参数中。例如:

Public void doSomethina(A<? extends List> a){}
:3，继承泛型类与实现泛型接口

定义为泛型的类和接口也可以被继承与实现。例如，让SubClass 类继承 ExtendClass 的泛型代码
如下:

class ExtendClass<T1>{}
class SubClass<T1,T2,T3> extends ExtendClass<T1>{}
定义为泛型的接口也可以被实现。例如，让SubClass 类实现 SomeInterface 接口，并继承接口的发型，代码如下:

interface Somelnterface<T1>{}
class SubClass<T1,T2,T3> implements Somelnterface<T1>(}
5.泛型总结
1.泛型的类型参数只能是类类型，不可以是简单类型，如 A<in>这种泛型定义就是错误的

2.泛型的类型个数可以是多个。

3.可以使用 extends 关键字限制泛型的类型

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