泛型
没有引入时：
//没有泛型 时，Object 是所有类的父类,所以向上转型
class Generics
{
private Object obj;
public void setObj(Object obj)
{
this.obj = obj;
}
public Object getObj()
{
return this.obj;
}
}
public class Hi
{
public static void main(String[] args)
{
Generics gd = new Generics();
gd.setObj(new Integer(5));
Integer in = (Integer)gd.getObj();
System.out.println("设置的数："+in);
gd.setObj(new Float(1.23F));
Float f = (Float)gd.getObj();
System.out.println("设置的数："+f);
}
}
/*
设置的数：5
设置的数：1.23
*/
如果向下转型则容易报错
泛型的创建
[public] class 类名 <泛型类型标识1[,泛型 类型标识2,...]>
{
// 定义属性
[访问控制符] 泛型类型标识 变量名;
// 定义方法
[访问控制符] 泛型类型标识 方法名(){};
// 定义方法
[访问控制符] 返回值类型 方法名(泛型类型标识 参数名){};
}
一般而言，类型的参数命名为单个大写字母,普通名称如下：
E--元素
K--键
N--数字
T--类型
V--值
S,U,V--第二，第三，第四个类型
// 声明泛型
class Generics<T>
{
private T obj;
public void setObj(T obj)
{
this.obj = obj;
}
public T getObj()
{
return obj;
}
}
// 定义泛型对象
类名<泛型类型> 对象名 = new 类名<泛型类型>();
其中类型为引用类型，不可为基本数据类型
class Generics<T>
{
private T obj;
public void setObj(T obj)
{
this.obj = obj;
}
public T getObj()
{
return this.obj;
}
}
public class Hi
{
public static void main(String[] args)
{
// 只能是用引用的 Integer，不能用 int表示
Generics<Integer> gd1 = new Generics<Integer>();
gd1.setObj(new Integer(5)); // 同上转型
Integer in = gd1.getObj(); // 向下转型
System.out.println("设置的数为："+in);
Generics<Float> gd2 = new Generics<Float>();
gd2.setObj(new Float(1.23)); // 同上转型
Float f = gd2.getObj(); // 向下转型
System.out.println("设置的数组为："+f);
}
}
/*
设置的数为：5
设置的数组为：1.23
*/
泛型类的构造方法与普通的无什么不同
构造方法格式如下：
[访问控制符] 类名([泛型类型] 参数列表)
{
// 构造方法语句
}
// 应用
class Generics<T>
{
private T obj;
public Generics(){}
public Generics(T obj)
{
setObj(obj);
}
public void setObj(T obj)
{
this.obj = obj;
}
public T getObj()
{
return this.obj;
}
}
public class Hi
{
public static void main(String[] args)
{
Generics<Integer> gd = new Generics<Integer>(5);
int in = gd.getObj();
System.out.println(in);
}
}
//定义泛型类时声明多个类型
class Generics<T,S>
{
private T obj1;
private S obj2;
public Generics(){}
public Generics(T obj1, S obj2)
{
setObj1(obj1);
setObj2(obj2);
}
public void setObj1(T obj1)
{
this.obj1 = obj1;
}
public void setObj2(S obj2)
{
this.obj2 = obj2;
}
public T getObj1()
{
return this.obj1;
}
public S getObj2()
{
return this.obj2;
}
public void show()
{
System.out.println("姓名："+getObj1()+",年龄："+getObj2());
}
}
public class Hi
{
public static void main(String[] args)
{
Generics<String, Integer> gd = new Generics<String, Integer>("小二", 27);
gd.show();
}
}
//姓名：小二,年龄：27
// =========
//接收任意指定泛型时需要使用通配符
//无界通配符 "?"
class Generics<T,S>
{
private T obj1;
private S obj2;
public Generics(){}
public Generics(T obj1, S obj2)
{
setObj1(obj1);
setObj2(obj2);
}
public void setObj1(T obj1)
{
this.obj1 = obj1;
}
public void setObj2(S obj2)
{
this.obj2 = obj2;
}
public T getObj1()
{
return this.obj1;
}
public S getObj2()
{
return this.obj2;
}
public void show()
{
System.out.println("姓名："+getObj1()+",年龄："+getObj2());
}
public String toString()
{
return "姓名："+getObj1()+",年龄："+getObj2();
}
}
public class Hi
{
public static void main(String[] args)
{
Generics<?,?> gd = new Generics<String, Integer>("小二", 27);
gd.show();
fun(gd);
}
public static void fun(Generics<?,?> t)
{
System.out.println("fun():"+t);
}
}
/*
姓名：小二,年龄：27
fun():姓名：小二,年龄：27
*/
受限泛型
设置类型形参的上限
定义类
<泛型 类型 标识 extends 泛型类型1 & 泛型类型2 ....>
一个类型参数可以用多个限界类型。限界类之间用 "&"分隔开，在多个限界类型中，可以用多个接口，
但只能有一个类。如果类作为限界类型，则必须放在限界列表中的第一个。
// 设置通配符的上限
// 因为是 继承了 Number类，所以只能是数字
class Generics<T extends Number>
{
private T obj;
public void setObj(T obj)
{
this.obj = obj;
}
public T getObj()
{
return this.obj;
}
public void show(Generics<?> t)
{
System.out.println("show():"+getObj());
}
}
public class Hi
{
public static void main(String[] args)
{
Generics<Integer> gd1 = new Generics<Integer>();
gd1.setObj(3);
gd1.show(gd1);
info(gd1);
Generics<Double> gd2 = new Generics<Double>();
gd2.setObj(1.234);
gd2.show(gd2);
info(gd2);
}
public static void info(Generics<? extends Number> t)
{
System.out.println("info():"+t.getObj());
}
}
/*
show():3
info():3
show():1.234
info():1.234
*/
// =========
//还可以设置下限，使其只能是某种类型或该类型的父类，只需使用 super关键字
<? super 泛型类型>
class Generics<T>
{
private T obj;
public Generics(){}
public Generics(T obj)
{
setObj(obj);
}
public void setObj(T obj)
{
this.obj = obj;
}
public T getObj()
{
return this.obj;
}
public String toString()
{
return getObj().toString();
}
}
public class Hi
{
public static void main(String[] args)
{
Generics<Integer> p = new Generics<Integer>(21);
info(p);
}
//可接收 Integer, Number, Object
public static void info(Generics<? super Integer> t)
{
System.out.println("info():"+t);
}
}
// =============
//泛型也可以作为父类或子类,同样也适用于继承
//以泛型 类为父类,当父类为泛型时，该类也必定是泛型
class Generics<T>
{
private T obj;
public Generics(){}
public Generics(T obj)
{
setObj(obj);
}
public void setObj(T obj)
{
this.obj = obj;
}
public T getObj()
{
return this.obj;
}
}
public class Hi<T> extends Generics<T>
{
public Hi(){}
public Hi(T obj)
{
super(obj);
}
public String toString()
{
return getObj().toString();
}
public static void main(String[] args)
{
Hi<String> p = new Hi<String>("小二");
System.out.println("内容为："+p);
}
}
// =============
// 子类自身的需求增加泛型类型
class Generics<T>
{
private T obj;
public Generics(){}
public Generics(T obj)
{
setObj(obj);
}
public void setObj(T obj)
{
this.obj = obj;
}
public T getObj()
{
return this.obj;
}
}
public class Hi<T,S> extends Generics<T>
{
private S sub;
public Hi(){}
public Hi(T obj, S sub)
{
super(obj);
setSub(sub);
}
public void setSub(S sub)
{
this.sub = sub;
}
public S getSub()
{
return this.sub;
}
public String toString()
{
return ("姓名："+getObj().toString()+",年龄："+getSub());
}
public static void main(String[] args)
{
Hi<String, Integer> p = new Hi<String, Integer>("小二", 27);
System.out.println("对象内容："+p);
}
}
// ==========
//以非泛型类为父类，这时不再需要传递参数给父类
class Generics{}
public class Hi<T> extends Generics
{
private T obj;
public Hi(){}
public Hi(T obj)
{
setObj(obj);
}
public void setObj(T obj)
{
this.obj = obj;
}
public T getObj()
{
return this.obj;
}
public String toString()
{
return getObj().toString();
}
public static void main(String[] args)
{
Hi<String> p = new Hi<String>("小二");
System.out.println("对象内容："+p);
}
}
// =============
//泛型 接口,与泛型类差不多
[访问控制符] interface 接口名称 <泛型类型标识>
{
// code
}
interface Hi<T>
{
public T add();
}
// =========
interface InterGenerics<T>
{
public T show();
}
class Generics<T> implements InterGenerics<T>
{
private T obj;
public Generics(){}
public Generics(T obj)
{
setObj(obj);
}
public void setObj(T obj)
{
this.obj = obj;
}
public T getObj()
{
return this.obj;
}
public T show()
{
return getObj();
}
}
public class Hi
{
public static void main(String[] args)
{
Generics<Integer> g = new Generics<Integer>(5);
System.out.println("对象内容："+g.show());
}
}
//=============
子类在实现泛型接口时明确地给出泛型类型
interface InterGenerics<T>
{
public T show();
}
class Generics implements InterGenerics<Integer>
{
private Integer obj;
public Generics(){}
public Generics(Integer obj)
{
setObj(obj);
}
public void setObj(Integer obj)
{
this.obj = obj;
}
public Integer getObj()
{
return this.obj;
}
public Integer show()
{
return this.getObj();
}
}
public class Hi
{
public static void main(String[] args)
{
Generics g = new Generics(5);
System.out.println(g.show());
}
}
// -----------
//泛型方法
格式：
[访问控制符] [static|final] <泛型类型标识>返回值类型 方法名([<泛型类型参数>] [参数])
// ---------
class Generics
{
public <T> T show(T t)
{
return t;
}
public static <T> T staticShow(T t)
{
return t;
}
}
// ==========
使用泛型方法
格式1：
[对象名|类名.]方法名(实参列表);
格式2:
[对象名|类名.]<实际泛型类型>方法名(实参列表);
// ------------
class Generics
{
public <T> T show(T t)
{
return t;
}
public static <T> T staticShow(String str, T t)
{
return t;
}
}
public class Hi
{
public static void main(String[] args)
{
Generics gen = new Generics();
System.out.println("格式一:"+gen.show("小二"));
System.out.println("格式1："+Generics.staticShow("小二", 27));
System.out.println("格式2:"+gen.<String>show("小二"));
System.out.println("格式3："+Generics.<Integer>staticShow("99", 98));
}
}
