Java泛型——泛型概念

泛型引入

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

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

package Month01.Day03.Demo03;

public class C1 {

	private Integer a;

	//a的get方法和set方法
	public Integer getA() {
		return a;
	}

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

	//a的构造方法
	public C1(Integer a) {
		super();
		this.a = a;
	}
	
	//打印a的类型
	public void print(){
		System.out.println("a的类型:"+a.getClass().getName());
	}
}

同样的再定义一个C2类，里面定义一个String类型属性，给出构造方法以及打印类型和get set方法：

package Month01.Day03.Demo03;

public class C2 {

	private String a;

	//a的get方法和set方法
	public String getA() {
		return a;
	}

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

	//a的构造方法
	public C2(String a) {
		super();
		this.a = a;
	}

	//打印a的类型
	public void print(){
		System.out.println("a的类型:"+a.getClass().getName());
	}
}

我们再写个测试类Test：

package Month01.Day03.Demo03;

public class Test {

	public static void main(String[] args) {
		C1 c1=new C1(1);
		c1.print();
		int i=c1.getA();
		System.out.println("i="+i);
		
		C2 c2=new C2("hh");
		c2.print();
		String s=c2.getA();
		System.out.println("s="+s);
		
	}
}

输出结果为：

a的类型:java.lang.Integer
i=1
a的类型:java.lang.String
s=hh

可以看到没什么问题；

如果有多个这样的类，只有属性的类型不同，那么我们要写多个类，但是这样显得很繁琐；

当然可以用到多态，我们改写下试下：

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

package Month01.Day03.Demo03;

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;
	}
	
	public void print(){
		System.out.println("object的类型:"+object.getClass().getName());
	}
}

测试类：

package Month01.Day03.Demo03;

public class Test {

	public static void main(String[] args) {
		C1 c1=new C1(1);
		c1.print();
		int i=c1.getA();
		System.out.println("i="+i);
		
		C2 c2=new C2("hh");
		c2.print();
		String s=c2.getA();
		System.out.println("s="+s);
		
		System.out.println("*****************************");
		
		C12 c12=new C12(2);//向上转型，安全
		c12.print();
		int i1=(int) c12.getObject();//向下转型，需要强制类型转换
		System.out.println("i1="+i1);
		
		C12 c21=new C12("kk");//向上转型，安全
		c21.print();
		String s1=(String) c21.getObject();//向下转型，需要强制类型转换
		System.out.println("s1="+s1);
	}
}

输出结果：

a的类型:java.lang.Integer
i=1
a的类型:java.lang.String
s=hh
*****************************
object的类型:java.lang.Integer
i1=2
object的类型:java.lang.String
s1=kk

我们发现测试类里需要转型，类简便了，但是测试类复杂了；

有没有一种类简单，测试也简单的方式呢，这时候，就可以用到泛型；

我们先定义一个泛型类：

package Month01.Day03.Demo03;

public class CC <T>{

	private T t;

	//get set方法
	public T getT() {
		return t;
	}

	public void setT(T t) {
		this.t = t;
	}

	//构造方法
	public CC(T t) {
		super();
		this.t = t;
	}
	
	public void print(){
		System.out.println("t的类型:"+t.getClass().getName());
	}
}

可以看到跟之前的定义是差不多的，语法上有一个<T>；

测试类：

package Month01.Day03.Demo03;

public class Test {

	public static void main(String[] args) {
		C1 c1=new C1(1);
		c1.print();
		int i=c1.getA();
		System.out.println("i="+i);
		
		C2 c2=new C2("hh");
		c2.print();
		String s=c2.getA();
		System.out.println("s="+s);
		
		System.out.println("*****************************");
		
		C12 c12=new C12(2);//向上转型，安全
		c12.print();
		int i1=(int) c12.getObject();//向下转型，需要强制类型转换
		System.out.println("i1="+i1);
		
		C12 c21=new C12("kk");//向上转型，安全
		c21.print();
		String s1=(String) c21.getObject();//向下转型，需要强制类型转换
		System.out.println("s1="+s1);
		
		System.out.println("*****************************");
		
		CC<Integer> cc=new CC<Integer>(3);//泛型实例化的时候需要指明类型
		cc.print();
		int i3=cc.getT();//这里不需要强制类型转换，泛型的优越性
		System.out.println("i3="+i3);
		
		CC<String> cc1=new CC<String>("hello");
		cc1.print();
		String s3=cc1.getT();
		System.out.println("s3="+s3);
	}
}

测试结果：

a的类型:java.lang.Integer
i=1
a的类型:java.lang.String
s=hh
*****************************
object的类型:java.lang.Integer
i1=2
object的类型:java.lang.String
s1=kk
*****************************
t的类型:java.lang.Integer
i3=3
t的类型:java.lang.String
s3=hello

可以看到泛型是非常方便的；

Java泛型——泛型概念

猜你喜欢