CoreJava学习笔记07 泛型

泛型 JDK5
集合：约束集合中元素的类型

泛型没有多态，赋值语句前后必须一致
方法参数的泛型定义：通配符？
？：任何类型
？extends A ：A或A的任何子类 A：可以是类，也可以是接口
？ super A： A或A的父类
泛型方法：<T> 泛型定义在修饰符之后，返回值类型之前
<T extends A > T为A或A的子类
<T extends A & B> T为A或A的子类，同时实现B接口

泛型

import java.util.ArrayList;
import java.util.List;

public class TestGenerics3 {

	public static void main(String[] args) {
		List<Object> l1 = new ArrayList<>();
		List<String> l2 = new ArrayList<>();    //implements Comparalbe
		List<Number> l3 = new ArrayList<>();
		List<Integer> l4 = new ArrayList<>();   // extends Number implements Comparable
		List<Double> l5 = new ArrayList<>();    // extends Number implements Comparable
		List<Comparable> l6 = new ArrayList<>();
		
		/*
		print(l1);
		print(l2);
		print(l3);
		print(l4);
		print(l5);
		print(l6);
		*/
		
		//copy(new Object[]{} , l1);
		//copy(new String[]{} , l2);
		//copy(new Number[]{} , l3);
		copy(new Integer[]{} , l4);
		copy(new Double[]{} , l5);
		//copy(new Comparable[]{} , l6);
	}
	//打印Number或Number的子类
//	static void print(List<? extends Number> list){
//		for(int i = 0 ; i < list.size() ; i++){
//			Number n =list.get(i);
//		}
//	}
	//打印Number或Number的父类
//	static void print(List<? super Number> list){
//		for(int i = 0 ; i < list.size() ; i++){
//			Object o = list.get(i);  //
//		}
//	}
	static <T extends Number & Comparable> void copy(T[] os , List<T> list){
		for(T o : os){
			list.add(o);
		}
	}
	static <T,S> void m(T t , S s){}  
	static <T , S extends T> void m2(T t , S s){}
}

泛型方法和泛型类

public class TestGenerics4 {

	public static void main(String[] args) {
		MyClass<String> m1 = new MyClass<>();
		
		MyClass<Integer> m2 = new MyClass<>();
	}

}

class MyClass <T>{
	public void method1(T t){}
	public T method2(){
		return null;
	}
}

/*
class MyArrayList <T>{
	private T[] os ; 
	private int index;
	public void add(T t){}
	public T get(int pos){
		return os[pos];
	}
}
MyArrayList<String> m1 = new MyArrayList<>();
m1.add("abc");
String s = m1.get(0);
*/

interface A{
	void m(String s);
}
interface B{
	void m(Integer i);
}
interface I<T>{
	void m(T t);
}
interface N <T>{
	T m();
}
class C1 implements I<String>{
	public void m(String s){}
}
class C2 implements I<Integer>{
	public void m(Integer i){}
}

class C3 implements N<String>{
	public String m(){
		return "helloworld";
	}
}
 class C4 implements N<Integer>{
	 public Integer m(){
		 return 0;
	 }

}
}