泛型(Generic)

1.定义:一种特殊的变量,保存的是引用变量的类型
2.好处:避免数据类型的转换;将运行时期ClassCastException提前到编译时期
3.自定义带泛型的类:
     public class A<泛型名>{

    }
     注:类中凡是使用到数据类型的地方,都可以使用泛型名代替;
         泛型名自定义,但是将来使用者只能传递引用数据类型;

代码实现:
//自定义泛型类和泛型方法:
class A<MM>{
	private MM name;
	private int age;

	public MM getName(){
		return name;
	}
	public void setName(MM name){
		this.name = name;
	}
	public int getAge(){
		return age;
	}
	public void setAge(int age){
		this.age = age;
	}

	public void say(){
		System.out.println(this.name+"	"+this.age);
	}

	//定义一个带泛型的方法,传入一个QQ类型的值,返回一个QQ类型的值
	public <QQ> QQ show(QQ m){
		System.out.println(m);
		return m;
	}
}

public class MmDemo{
	public static void main(String[] args){
		//MM此处开始确定为String类型
		A<String> a = new A<>();
		a.setName("baobao");
		a.setAge(24);
		a.say();
		//带泛型的show方法QQ此处定为String类型
		a.show("xiaobao");//xiaobao
		//带泛型的show方法QQ此处定为int类型
		a.show(123);//123

		A<String> b = new A<>();
		b.setName("rongrong");
		b.setAge(12);
		b.say();

	}
}

4.自定义带泛型的方法:
     public <泛型名>泛型 getName(){
         return name;
     }
代码:见3.代码实现

5.自定义带泛型的接口:
     public interface B<泛型名>{

    }
     注:接口中凡是使用到数据类型的地方都可以使用泛型名代替;
代码实现:

给泛型赋值的格式有两种形式:
     (1)在定义子类的时候,直接给接口的泛型传递固定的数据类型;
     public class 类名 implements 接口名<具体的数据类型>{
         在类中但凡是使用到数据类型的地方,都可以使用泛型名代替;
     }
     (2)在定义子类的时候也不确定数据类型,在创建子类对象的时候,确定数据类型
     public class 类名<泛型名B> implements 接口名<泛型名B>{
         在类中但凡是使用到数据类型的地方,都可以使用泛型名代替;
     }

//定义一个带泛型的接口
	interface A<W>{
		//带泛型参数的show方法,抽象方法
		public abstract void show(W w);
	}

	//定义一个实现类--带泛型的实现类
	class BImpl<W> implements A<W>{	//类名后需加上与接口一致的泛型名
		@Override
		public void show(W w){	//重写了带泛型的方法
			System.out.println(w);
		}

		public static void main(String[] args){
			BImpl<String> b = new BImpl<>();
			b.show("baobao");	//baobao

			BImpl<Integer> a = new BImpl<>();
			a.show(12345);	//12345
		}
	}

6.泛型通配符:?
创建带泛型的类的对象的时候,泛型不能使用多态;只能使用通配符的形式,来达到这样的效果;

具体的通配符的符号:?  代表任意数据类型
对通配符的范围进行限定:
     ? extends 具体的数据类型A   此时是限定了上限;A类或A类的子类符合要求,其他数据类型不能传递;
     ? super   具体的数据类型A   此时是限定了下限;A类或A类的父类符合要求,其他数据类型不能传递;

代码实现:

import java.util.List;
	import java.util.ArrayList;
	//定义一个父类
	class Father{

	}

	//定义一个子类
	class Son extends Father{

	}

	//定义一个测试类
	public class FsDemo{
		public static void main(String[] args){
			//分别使用Object Father Son作为泛型,定义list集合
			List<Object> Biggest = new ArrayList<>();
			List<Father> Bigger = new ArrayList<>();
			List<Son> Big = new ArrayList<>();

			//method1(Biggest);//错误: 不兼容的类型: List<Object>无法转换为List<? extends Father>
			method1(Bigger);	//safe extends
			method1(Big);	//safe extends

			method2(Biggest);	//safe super
			method2(Bigger);	//safe super
			//method2(Big);//错误: 不兼容的类型: List<Son>无法转换为List<? super Father>

		}
			//定义带泛型的method1方法,上限为Father--? extends Father
			public static void method1(List<? extends Father> list){
				System.out.println("safe extends");
			}

			//定义带泛型的method2方法,下限为Father--? super Father
			public static void method2(List<? super Father> list){
				System.out.println("safe super");
			}
	}