Java泛型

一.泛型简介

1.1问题引入

• 如果需要产生多个对象，每个对象的逻辑完全一样，只是对象内的成员变量类型不一样，应该怎么做？

1.2问题解决

• 创建多个类文件，给每个类的成员对象，设定指定的数据类型
  - 缺点，这种方法会导致类的膨胀，重用性差
  -创建一个类文件，给这个类的成员变量设置Object数据类型
  • 缺点，编译时正常，但运行是可能会异常
    -泛型：创建一个类文件，class +类名，然后类文件中定义数据类型是用’T+变量名’,main函数使用时传入具体的数据类型。

1.3 JDK1.5后引入Java

• 泛型可以在编译时，检查类型安全，并且所有的强制转化都是自动和隐式的。
• 泛型的原理就是“类型的参数化”，也就是说，把所有要操作的数据类型看作参数，就像方法的形式参数，是运行时传递的值的占位符样。
• 简单来说，类型变量扮演的角色，就如同一个参数，他提供给编译器用来类型检查的信息。
• 泛型可以提高代码的拓展性和重用性。

二. 泛型类的特点

1. 泛型的类型参数可以是泛型类
2. 泛型类可以同时设置多个类型参数
3. 泛型类可以继承泛型类
4. 泛型类可以实现泛型接口

2.1多个类型参数，泛型为参数

class Cls1<T>{
	
	T a;
	
	public Cls1(T a){
		
		this.a = a;
		
	}
	
	public T getdata(){
		
		return a;
		
	}
		
}

class Cls2<T1 , T2>{
	
	T1 a;
	T2 b;
	
	public Cls2(T1	a,T2  b){
		
		this.a = a;
		this.b = b;
		
	}
	
	public T1 getdata1(){
		
		return a;
		
	}
	public T2 getdata2(){
		
		return b;
		
	}		
}





public class test {

	public static void main(String[] args) {
		//传入一个整型参数
		Cls1<Integer> cls1 = new Cls1<Integer>(10);
		System.out.println("传入一个整型参数:"+cls1.getdata());
		
		//传入泛型
		Cls1<Cls1<Integer>> cls4 = new Cls1<Cls1<Integer>>(new Cls1<Integer>(10));
		System.out.println("传入泛型:"+cls4.getdata().getdata());
	
		//传入不同类型参数，相加
		Cls2<Integer,String> cls2 = new Cls2<Integer,String>(10,"曾铁江帅！");
		System.out.println("传入不同类型参数:"+cls2.getdata1()+" " +cls2.getdata2());
		System.out.println("传入不同类型参数相加:"+cls2.getdata1()+cls2.getdata2());//不同类型可加，表示分隔符
		
		//传入两个整型相加
		Cls2<Integer,Integer> cls3 = new Cls2<Integer,Integer>(10,100);
		System.out.println("传入两个整型:"+cls3.getdata1() +" "+ cls3.getdata2());
		System.out.println("传入两个整型相加:"+cls3.getdata1() + cls3.getdata2());//整型数据可加，表示运算符
		
		
		
	}
	
}

传入一个整型参数:10
传入泛型:10
传入不同类型参数:10 曾铁江帅！
传入不同类型参数相加:10曾铁江帅！
传入两个整型:10 100
传入两个整型相加:10100

2.2 泛型类的继承，抽象泛型类的重写，泛型接口继承和重写

abstract class Cls1<T>{
	
	T a;
	
	public Cls1(T a){
		
		this.a = a;
		
	}
	
	public T getdata1(){
		
		return a;
		
	}
	
	abstract void printInfo();
		
}

interface Clas6<T>{
	
	abstract void printInfoInClas5(T t);
	
}



class Cls5<T1,T2> extends Cls1<T1> implements Clas6<T1>{
	
	T1 a;
	T2 b;
	
	public Cls5(T1 a,T2 b){
		super(a);
		this.b = b;
		
	}
	
	public T2 getdata2(){
		
		return b;
		
	}

	@Override
	void printInfo() {
		
		System.out.println("抽象类继承重写");
		// TODO Auto-generated method stub
		
	}

	public void printInfoInClas5(T1 t) {
		// TODO Auto-generated method stub
		System.out.println("Cls5.printInfoInClas5()泛型接口方法重写");
	}
	


}




class Cls2<T1 , T2>{
	
	T1 a;
	T2 b;
	
	public Cls2(T1	a,T2  b){
		
		this.a = a;
		this.b = b;
		
	}
	
	public T1 getdata1(){
		
		return a;
		
	}
	public T2 getdata2(){
		
		return b;
		
	}		
}





public class test {

	public static void main(String[] args) {
/*		//传入一个整型参数
		Cls1<Integer> cls1 = new Cls1<Integer>(10);
		System.out.println("传入一个整型参数:"+cls1.getdata1());
		
		//传入泛型
		Cls1<Cls1<Integer>> cls4 = new Cls1<Cls1<Integer>>(new Cls1<Integer>(10));
		System.out.println("传入泛型:"+cls4.getdata1().getdata1());*/
	
		//传入不同类型参数，相加
		Cls2<Integer,String> cls2 = new Cls2<Integer,String>(10,"曾铁江帅！");
		System.out.println("传入不同类型参数:"+cls2.getdata1()+" " +cls2.getdata2());
		System.out.println("传入不同类型参数相加:"+cls2.getdata1()+cls2.getdata2());//不同类型可加，表示分隔符
		
		//传入两个整型相加
		Cls2<Integer,Integer> cls3 = new Cls2<Integer,Integer>(10,100);
		System.out.println("传入两个整型:"+cls3.getdata1() +" "+ cls3.getdata2());
		System.out.println("传入两个整型相加:"+cls3.getdata1() + cls3.getdata2());//整型数据可加，表示运算符
		
		
		//
		//一个泛型继承另一个泛型
		Cls5<Integer,Integer> cls5 = new Cls5<Integer,Integer>(10,10);
		System.out.println("继承泛型:"+cls5.getdata1()+" "+ cls5.getdata2());
		cls5.printInfo();//泛型抽象类重写
		cls5.printInfoInClas5(60);
		
	}
	
}

传入不同类型参数:10 曾铁江帅！
传入不同类型参数相加:10曾铁江帅！
传入两个整型:10 100
传入两个整型相加:10100
继承泛型:10 10
抽象类继承重写
Cls5.printInfoInClas5()泛型接口方法重写

三.限制泛型的可用类型

• 在定义泛型类别时，默认在实例化泛型类的时候，可以使用任何类型，但是如果想要限制使用泛型类型时，只能用某个特定类型或者是其子类型才能实例化该类型时，可以在定义类型时，使用extends关键字指定这个类型必须继承某个类，或者实现某个接口。
• 当没有指定泛型类型的指定接口时，默认使用extends Object，所以默认情况下，任何类型都可以作为参数传入。

四.类型通配声明

• 同一泛型类，如果实例化时，给定的实际类型不同，则这些实例的类型时不兼容的，不能相互赋值

• 泛型类实例之间的不兼容性会带来使用的不便，我们可以使用泛型通配符（？）声明泛型类的变量，就可以解决这个问题。

• 泛型通配的方式

  1. “？”表示任意一个类型
  2. 和限制泛型上限类似，extends限定泛型通配的上限
  3. 用super限定泛型通配的下限

五.泛型方法

5.1 概念

• 不仅类可以声明泛型，类中的方法也可以声明仅用于自身的泛型，这种方法叫做泛型方法。其定义格式为：访问修饰符+<泛型列表>+返回值 +方法名+（参数列表）{
  实现代码
  }
• 在泛型列表中声明的泛型，可用于该方法的返回类型声明，参数类型声明，和代码中局部变量的类型声明。
• 类中的其他方法不能使用当前方法声明的泛型。
• 提示：是否拥有泛型方法，与其所在类是否泛型没有关系，要定义泛型方法，只需将泛型参数列表置于返回值前。

5.2什么时候使用泛型方法而不是泛型类？

• 添加类型约束，只作用于一个方法的多个参数之间，而不涉及到类中的其它方法时。
• 施加类型约束的方法，为静态方法，只能将其定义为泛型方法，因为静态方法不能使用其所在类的类型参数。