java中泛型t引入哪个类_java泛型-泛型引入

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 

*/

public class CC{

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，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 cc=new CC(1);

cc.print();

int icc=cc.getOb();

System.out.println("icc="+icc);

CC cc2=new CC("我是泛型，好简单啊");

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=我是泛型，好简单啊