java通用
1、通用部署
定义：泛型类型允许指向任何对象类型。
让我们先看一个例子：
定义类C1。 Integer属性显示了生成方法、打印类型和获取集方法package com.Java 1234.chap 06.se c01。
公共类C1 {
私有integera；
公共C1 (integera ) {
super (；
this.a=a；
}
publicIntegergetA (
returna；
}
公共语音集(integera ) )。
this.a=a；
}
//*
*打印a的类型
*/
公共void print (
system.out.println(a的类型为(a.getClass ) ).getName )；
}
}
同样还定义了另一个C2类，其中定义了String型属性。 package com.Java 1234.chap 06.se c01；
公共类C2 {
privateStringa；
公共字符串geta (
returna；
}
公共void seta (stringa ) {
this.a=a；
}
公共C2 (stringa ) {
super (；
this.a=a；
}
//*
*打印a的类型
*/
公共void print (
system.out.println(a的类型为(a.getClass ) ).getName )；
}
}
写测试班吧。 package com.Java 1234.chap 06.se c01；
公共类测试1 {
publicstaticvoidmain (string [ ] args ) {
//begintestc1
C1C1=newC1(1；
C1 .打印(；
inti=c1.getA (；
system.out.println(I=) I；
//endtestc1
//begintestc2
C2C2=newC2(hi )；
C2 .打印(；
Strings1=c2.getA (；
system.out.println('S1='S1 )；
//endtestc2
}
}
执行输出：
a的类型为java.lang.Integer
i=1
a的类型为java.lang.String
s1=Hi
有100个类型，相似的我们必须写100个相似的班，很麻烦。 这个时候，考虑多态性。 试着改写一下：
在一个类中实现：所有类都是从Object类继承的，因此直接定义为Object类型的属性； package com.Java 1234.chap 06.se c01；
公共类c 12 {
私有对象；
公共对象对象
返回对象；
}
公共对象(objectobject ) {
this.object=object；
}
公共12 (objectobject ) {
super (；
this.object=object；
}
//*
*打印对象类型
*/
公共void print (
system.out.println(object的类型为' object.getClass ().getName ) )；
}
}
编写测试类： package com.Java 1234.chap 06.se c01；
公共类测试1 {
publicstaticvoidmain (string [ ] args ) {
//begintestc1
p>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=我是泛型，好简单啊