泛型

• jdk1.5引入，解决工具，容器等类型经常使用Object来代指多种类型使用时经常要造型而造成的类型安全问题
• 声明<T> T
• 使用泛型情况
  • 集合
  • 工具类
  • 自定义
• 理解，通过泛型，提供一种储存类型的方式，即储存类型变量，类类型。
• 泛型变量缺省为Object类型
• 泛型类型隶属与对象的，不同的对象创建对象的时候制定了不同的类型
  • 理解，隶属于对象还是类，可以看一个东西是类加载的时候确定还是对象创建时 创建
• 泛型方法，方法的泛型类型在方法的返回值类型之前声明
  • 泛型方法必须在形参中指定好特定的类型，否则泛型方法中的泛型用于时Object
  • 泛型方法中的泛型类型究竟时什么，由实参类决定
    • 根据对象获取类型
    • <T1,T2,T3,…> 返回值类型 方法名(T1 t1, T2 t2, T3 t3, …)
  • 当实参的类型无法确定时，泛型中的类型就是Object
• 泛型类
  • 隶属于对象，创建方法时确定
  • 类的静态成员中不可以使用泛型

class 类名<T1, T2, T3, ...>{
    ...
    //使用泛型的类型成员
}

• 泛型继承
  • class b entends A{} //没有类型即为缺省值Object，实现擦除效果
  • class c extends A{} //子类在继承时直接写死父类的泛型类型，在子类中X类型永远固定
  • class d extends A {} //子类在继承父类时仍然保持泛型的不确定性
• 通配符，例： List<?> list 2 = new ArrayList();
  • 表示类型未知；
  • 不能添加，只能遍历，用于只读访问
  • 此方法对于集合的访问更安全
  • List<? super Number> list; //集合保持的时number类型及其未知父类类型，类型范围>=NUmber;
    • 理解，这里限制父类，子类属于父类，
    • list.add(200); //表示至少时number类型的对象
    • 不能直接拿出，因为list中保持的类型不确定
  • List<? extend Number> list2; //集合保存的是number类型及其未知的子类，类型范围是<=Number;
    • 不可添加元素，因为具体子类未知，不可以贸然添加元素
    • list2.get(0); //可以获取，因为最多是number，多态引用
    • *主要用于形参统配
• 使用泛型的节点
  • 类的声明（类名后面声明泛型类型，哪里使用其类型，哪里获取类型）
  • 方法声明（返回值前可以声明泛型类型，哪里使用其类型，哪里获取类型）
  • 对象创建（类名后面尖括号传入类型，缺省为Object）
  • 方法调用（参数做实参，缺省为Object）

public class FanTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
	}
	
	public static Comparable min1(Collection<? extends Comparable> collection) {
		Comparable min = null; 
		Iterator<? extends Comparable> iterator = collection.iterator();
		while (iterator.hasNext()) {
			if(min == null) {
				min = iterator.next();
			}
			else {
				Comparable temp = iterator.next();
				min = min.compareTo(temp) > 0 ? min : temp;
			}
			Comparable comparable = (Comparable) iterator.next();
			
		}
		return min;
	}
	@Test
	public void test1() {
		List<Integer> l = new ArrayList<Integer>();
		List<Float> l1 = new ArrayList<Float>();
		Set<String> s = new HashSet();
		for(int i = 0; i< 10; i++) {
			 l.add(((int)(Math.random() * 100)));
			 l1.add(( (float)( toTwo(Math.random() *100)) ));
			 s.add("字符串" + i);
		}
		System.out.println("list1 : \n" + l);
		System.out.println("list1 中 min = " + min1(l));
		System.out.println("list2 : \n" + l1);
		System.out.println("list2 中 min = " + min1(l1));
		System.out.println("set1 : \n" + s);
		System.out.println("set1 中 min = " + min1(s));
	}
	
	public static double toTwo(double d) {
		return Math.round(d*100)/100.0;
	}
	public static double min(List<? extends Number> t) {
		double min = 200;
//		for (int i = 0; i < t.size(); i++) {
//			min = min 
//		}
		for (Number number : t) {
			min = min < number.doubleValue() ? min : number.doubleValue();
		}
		return min;
	}
	@Test
	public void test() {
		List<Integer> l = new ArrayList<Integer>();
		List<Float> l1 = new ArrayList<Float>();
		for(int i = 0; i< 10; i++) {
			 l.add(((int)(Math.random() * 100)));
			 l1.add(( (float)( toTwo(Math.random() *100)) ));
		}
		System.out.println("list1 : \n" + l);
		System.out.println("list1 中 min = " + min(l));
		System.out.println("list2 : \n" + l1);
		System.out.println("list2 中 min = " + min(l1));
	}

}