java泛型

1，泛型引入

定义：使用泛型可以指代任意对象类型；

我们来先看一个实例：

定义一个C1类：里面有个Integer属性  给出构造方法 以及打印类型 和get set方法 

package com.java1234.chap06.sec01;

public class C1 {

	private Integer a;

	
	
	public C1(Integer a) {
		super();
		this.a = a;
	}

	public Integer getA() {
		return a;
	}

	public void setA(Integer a) {
		this.a = a;
	}
	
	/**
	 * 打印a的类型
	 */
	public void print(){
		System.out.println("a的类型是："+a.getClass().getName());
	}
	
}

类似的再定义一个C2类，里面定义一个String类型属性：

package com.java1234.chap06.sec01;

public class C2 {

	private String a;

	public String getA() {
		return a;
	}

	public void setA(String a) {
		this.a = a;
	}

	public C2(String a) {
		super();
		this.a = a;
	}
	
	/**
	 * 打印a的类型
	 */
	public void print(){
		System.out.println("a的类型是："+a.getClass().getName());
	}
}

我们来写个测试类：

package com.java1234.chap06.sec01;

public class Test1 {

	public static void main(String[] args) {
		// begin test c1
		C1 c1=new C1(1);
		c1.print();
		int i=c1.getA();
		System.out.println("i="+i);
		// end test c1
		
		// begin test c2
		C2 c2=new C2("Hi");
		c2.print();
		String s1=c2.getA();
		System.out.println("s1="+s1);
		// end test c2
		
	
	}
}

运行输出：

a的类型是：java.lang.Integer

i=1

a的类型是：java.lang.String

s1=Hi

假如有100个类型，类似的我们要写100个类似的类，很麻烦，这时候我们会想到多态，我们改写下试下：

用一个类实现：因为所有类都继承自Object类，所以直接定义成Object类型的属性；

package com.java1234.chap06.sec01;

public class C12 {

	private Object object;

	public Object getObject() {
		return object;
	}

	public void setObject(Object object) {
		this.object = object;
	}

	public C12(Object object) {
		super();
		this.object = object;
	}
	
	/**
	 * 打印object的类型
	 */
	public void print(){
		System.out.println("object的类型是："+object.getClass().getName());
	}
}

写下测试类：

package com.java1234.chap06.sec01;

public class Test1 {

	public static void main(String[] args) {
		// begin test c1
		C1 c1=new C1(1);
		c1.print();
		int i=c1.getA();
		System.out.println("i="+i);
		// end test c1
		
		// begin test c2
		C2 c2=new C2("Hi");
		c2.print();
		String s1=c2.getA();
		System.out.println("s1="+s1);
		// end test c2
		
		// begin test c12
		C12 c12=new C12(1); // 向上转型
		c12.print();
		int i12=(Integer) c12.getObject(); // 向下转型
		System.out.println("i12="+i12);
		
		C12 c122=new C12("你好");// 向上转型
		c122.print();
		String s122=(String) c122.getObject();   // 向下转型
		System.out.println("s122="+s122);
		// end test c12
		
	}
}

运行输出：

a的类型是：java.lang.Integer

i=1

a的类型是：java.lang.String

s1=Hi

object的类型是：java.lang.Integer

i12=1

object的类型是：java.lang.String

s122=你好

我们发现测试类里需要转型，类简便了，但是测试类复杂了，有没有一种类简单，测试也简单的方式呢，这时候，泛型诞生了；

我们先定义一个泛型类：

package com.java1234.chap06.sec01;

/**
 * 定义泛型类
 * @author caofeng
 *
 * @param <T>
 */
public class CC<T>{

	private T ob;

	
	public CC(T ob) {
		super();
		this.ob = ob;
	}

	public T getOb() {
		return ob;
	}

	public void setOb(T ob) {
		this.ob = ob;
	}
	
	/**
	 * 打印T的类型
	 */
	public void print(){
		System.out.println("T的实际类型是："+ob.getClass().getName());
	}
	
}

用<T>指代任意类型，当然也可以用其他字母，但是一般用T，Type的意思；

我们写个测试类：

package com.java1234.chap06.sec01;

public class Test1 {

	public static void main(String[] args) {
		// begin test c1
		C1 c1=new C1(1);
		c1.print();
		int i=c1.getA();
		System.out.println("i="+i);
		// end test c1
		
		// begin test c2
		C2 c2=new C2("Hi");
		c2.print();
		String s1=c2.getA();
		System.out.println("s1="+s1);
		// end test c2
		
		// begin test c12
		C12 c12=new C12(1); // 向上转型
		c12.print();
		int i12=(Integer) c12.getObject(); // 向下转型
		System.out.println("i12="+i12);
		
		C12 c122=new C12("你好");// 向上转型
		c122.print();
		String s122=(String) c122.getObject();   // 向下转型
		System.out.println("s122="+s122);
		// end test c12
		
		// begin test CC
		CC<Integer> cc=new CC<Integer>(1);
		cc.print();
		int icc=cc.getOb();
		System.out.println("icc="+icc);
		
		CC<String> cc2=new CC<String>("我是泛型，好简单啊");
		cc2.print();
		String icc2=cc2.getOb();
		System.out.println("icc2="+icc2);
		// end test CC
	}
}

运行输出：

a的类型是：java.lang.Integer

i=1

a的类型是：java.lang.String

s1=Hi

object的类型是：java.lang.Integer

i12=1

object的类型是：java.lang.String

s122=你好

T的实际类型是：java.lang.Integer

icc=1

T的实际类型是：java.lang.String

icc2=我是泛型，好简单啊