java 泛型，

java 泛型，

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
 
import org.junit.Test;

public class genericDemo1 {
	// 展示没有泛型的代码可能存在潜在bug
	@Test
	public void demo1() {
		List list = new ArrayList();
		list.add("abc123");
		list.add("okwwwok");
		list.add("jack");
		list.add(100);// 这句会带来bug ---没有泛型的坏处

		Iterator it = list.iterator();
		while (it.hasNext()) {
			String str = (String) it.next();
			System.out.println(str.length());
		}
	}

	// 演示泛型
	@Test
	public void demo2() {
		List<String> list = new ArrayList<String>();
		list.add("abcabc");
		list.add("harden");
		list.add("Mvp");
		list.add("paul");
		list.add("dengpao");
		// list.add(100);//泛型的好处1: 可以把运行时异常提前到编译期

		Iterator<String> it = list.iterator();
		while (it.hasNext()) {
			String str = it.next();
			System.out.println(str);
		}
	}

	@Test
	// 测试我们自己在MySet中定义的泛型
	public void demo3() {
		MySet3<String> set = new MySet3<String>();
		set.add("abc123");
		set.add("hncuaaa");
		// set.add(100); //泛型的好处1: 可以把运行时异常提前到编译期
		// 泛型的好处2: 不用进行类型强转
		String s = set.pop();
		System.out.println("s: " + s);
		
		Object[] objs = set.toArray();
		for(int i=0;i<objs.length;i++){
			String str = (String) objs[i];
			System.out.println(str.length());
		}
		
	}
}

/* 
	 * 泛型一共就3种:
	 * 1.定义在“类”上
	 * 2.定义在“方法”上
	 * 3.定义在“接口”上
	 */

public class demo1 {
	//1. 定义在“类”上的泛型
    public static void main(String[] args) {
    	MyVessel<String,Person> vv = new MyVessel<String,Person>();
    	vv.setObj("abc");
 	   //vv.setObj(100);//编译错误，因为类上的泛型限定此方法的参数为String
    	 String str = vv.getObj();
    	 System.out.println(str);
    	   
    // vv.setObj2( "abc123");//编译错误，因为类上的泛型限定第2个类型参数为Person
  	   vv.setObj2( new Person("Rose",24) );
  	   Person p = vv.getObj2();
  	   System.out.println(p);
	}
}
class MyVessel<QQ,EE>{
	private QQ obj;
	private EE obj2;
	
	public QQ getObj() {
		return obj;
	}
	
	public void setObj(QQ obj) {
		this.obj = obj;
	}
	
	public EE getObj2() {
		return obj2;
	}
	
	public void setObj2(EE obj2) {
		this.obj2 = obj2;
	}
	
	
}

import org.junit.Test;


/*
 * 2. 定义在方法上的泛型:
 * 1) 泛型方法的定义(与类的泛型捆绑)
 2) 泛型方法的定义(独立于类的泛型)
 3) 泛型方法的定义(静态方法的泛型)
 * 
 */
public class demo2 {
	@Test
	// 演示: 1) 泛型方法的定义(与类的泛型捆绑)
	public void t1() {
		Tool<String> tool = new Tool<String>();
		tool.show("abc123");
		// tool.show(100); //WA

		Tool<Integer> tool2 = new Tool<Integer>();
		// tool2.show("abc123");//WA
		tool2.show(100);
	}

	@Test 
	// 演示: 泛型方法的定义(独立于类的泛型)
	public void t2() {
		Tool<String> tool = new Tool<String>();
		String str = tool.addData("abc111");
		System.out.println(str);

		// String s = tool.addData( new Person("Tom",20) );//WA
		Person p = tool.addData(new Person("Tom", 20));
		System.out.println(p);
	}
	
	  @Test //演示:  3) 泛型方法的定义(静态方法的泛型)
	   public void t3(){
		   Tool.print(100);
	   }
}

class Tool<W> {
	// 1) 泛型方法的定义(与类的泛型捆绑)
	public void show(W w) {
		System.out.println("show:" + w.toString());
	}

	// 2) 泛型方法的定义(独立于类的泛型)
	public <T> T addData(T p) {
		return p;
	}

	/*
	 * 反模式: 静态方法上不允许使用类上定义的泛型, 因为静态方法属于类模板，而类上的泛型属于类对象。 public static void
	 * print(W w){ }
	 */

	// 3) 泛型方法的定义(静态方法的泛型)
	public static <C> void print(C c) {
		System.out.println("aaaaaa.....");
	}
}

import org.junit.Test;
/*
 * 3. 定义在接口上的泛型
 * 
 */


public class demo3 {
	@Test //演示: 实现类把接口中的泛型写"死" 的用法
	public void t1(){
		//Inter<String> inter = new InterImpl();
			//	inter.show("OKOK下雨了...");
		Inter<Integer> inter2 = new InterImpl();
		inter2.show(100);
	}
	
	@Test //演示: 实现类把接口中的泛型写"活" 的用法
	public void t2(){
		Inter<String> inter = new InterImpl2<String>();
		inter.show("OKOK下雨了...");
		//inter.show(100);//WA
		
		Inter<Integer> inter2 = new InterImpl2<Integer>();
		inter2.show(100);
		//inter2.show("OKOK下雨了..."); //WA
		
		//List<Integer> list = new ArrayList<Integer>();
	}
}


//定义在接口上的泛型
interface Inter<V>{
	public abstract void show(V v);
}


//实现类写法1： 把接口中的泛型写死
class InterImpl implements Inter<Integer>{ //给接口传泛型实参--用具体类型
	@Override
	public void show(Integer v) {
		System.out.println("111:"+v);
	}
}


//实现类写法2： 把接口中的泛型写活
class InterImpl2 <C> implements Inter<C>{ //给接口传泛型实参--用泛型类型
	@Override
	public void show(C v) {
		System.out.println("222:"+v);
	}
}