泛型

泛型

泛型的概念:

• 在编译时期就确定的类型的一种技术
• 泛型是一种参数化类型

方法:

public 返回值类型 方法名(类型 参数1， 类型 参数2){
方法体;
}

泛型是JDK1.5之后引入的新特性，是一种将引用类型当做参数传递的参数化类型，在编译时期就已经确定了集合存储的元素类型
格式:

• <数据类型> 这里的类型必须是引用类型
• 泛型一般用于集合

泛型的好处:

• 1.提高了程序的安全性
• 2.消除了黄色警告线
• 3.在编译时期将类型确定，减少不必要的强转代码

public class GenericDemo {
	public static void main(String[] args) {
		ArrayList<String> list = new ArrayList<String>();
		list.add("abc");
		list.add("346");
		
		Iterator<String> it = list.iterator();
		while (it.hasNext()) {
			String s = it.next();
			System.out.println(s);
		}
		
		for (String s : list) {
			System.out.println(s);
		}
		
		ArrayList<Integer> list2 = new ArrayList<>();
	}
}

泛型类

泛型类： 把泛型定义在类上。

JDK1.5之前没有使用泛型的时候，代码如下：

public class GernericDemo {
	public static void main(String[] args) {
		GenericClass gc = new GenericClass();
		gc.setObj("张三");
		
		Object oj = gc.getObj();
		String s = (String) oj;
		System.out.println(s + "|" + s.length());
	}
}

class GenericClass {
	private Object obj;

	public Object getObj() {
		return obj;
	}

	public void setObj(Object obj) {
		this.obj = obj;
	}
	
}

以上代码存在安全隐患,如果添加如下代码：

gc.setObj(10);

会出现类型转换异常，我们可以使用泛型类来改进,继续看如下代码：

泛型类改进:
public class GernericDemo {
	public static void main(String[] args) {
		GenericClass<String> gc = new GenericClass<String>();
		gc.setE("张三");
//		gc.setE(10);
		
		String s = gc.getE();
		System.out.println(s + "|" + s.length());
	}
}

class GenericClass<E> {
	private E e;

	public E getE() {
		return e;
	}

	public void setE(E e) {
		this.e = e;
	}
}

泛型接口

概念：把泛型定义在接口

泛型接口代码如下：

interface GenericInterface<E, T> {
	
	void test(E e);
	
	T add(T t);
}

泛型接口的使用方式

public class GenericDemo {
	public static void main(String[] args) {
		GenericInterface<String> gi = new GenericInterfaceImpl<String>();
		gi.show("张三");
		System.out.println(gi.method());
		
		System.out.println("----------2.使用匿名内部类的方式--------------");
		GenericInterface<Integer> gi2 = new GenericInterface<Integer>() {

			@Override
			public void show(Integer e) {
				System.out.println(e);
			}

			@Override
			public Integer method() {
				return 25;
			}
		};
		gi2.show(100);
		Integer integer = gi2.method();
		System.out.println(integer);
	}
}

// 1.在实现的时候确定泛型的类型
class GenericInterfaceImpl<E> implements GenericInterface<String>{

	@Override
	public void show(String e) {
		System.out.println(e);
	}

	@Override
	public String method() {
		return "method";
	}
	
}

interface GenericInterface<E>{
	
	public abstract void show(E e);
	
	public E method();
}

泛型方法

概念： 把泛型定义在方法上,泛型方法又可以理解为局部泛型。

泛型方法的特点：

1. 泛型方法独立于泛型类或者泛型接口
2. 泛型方法在方法调用的时候确定类型
3. 一个泛型接口或者泛型类中可以有多个泛型方法
4. 一个泛型方法也可以定义多个泛型

public class GenericDemo {
	public static void main(String[] args) {
		GenericMethod<String,Integer,Character> gm = new GenericMethod<String,Integer,Character>();
		gm.setObj("abc");
		System.out.println(gm.getObj());
		
		gm.method(25.8);
		
		gm.show(18);
		
		System.out.println("------------------");
		ArrayList<String> list = new ArrayList<String>();
		list.add("123");
		list.add("456");
		list.add("789");
		
		String[] array = list.toArray(new String[list.size()]);
		for (String s : array) {
			System.out.println(s);
		}
		
	}
}

class GenericMethod<E,H,I>{
	private E e;
	
	public void setObj(E e) {
		this.e = e;
	}
	
	public E getObj() {
		return this.e;
	}
	
	public <T> void method(T t) {
		System.out.println(t);
	}
	
	public void show(H h) {
		System.out.println(h);
	}
}

泛型限定符

概念： 用来限定泛型的符号

泛型限定符的常用格式：

1. ？: 表示泛型可以是任意类型
2. ？ extends E：表示泛型可以是E或者E的子类
3. ? super E ：表示泛型可以是E或者E的父类

代码用例如下：

public class GenericDemo {
	public static void main(String[] args) {
		Collection<Object> c1 = new ArrayList<Object>();
		Collection<?> c2 = new ArrayList<Object>();
		Collection<?> c3 = new ArrayList<Son>();
		Collection<?> c4 = new ArrayList<Daughter>();
		
		Collection<? extends Father> c5 = new ArrayList<Son>();
		Collection<? extends Father> c6 = new ArrayList<Father>();
		
		Collection<? super Father> c7 = new ArrayList<Object>();
		Collection<? super Father> c8 = new ArrayList<Father>();
		
		System.out.println("-------------------------");
		Collection<Father> c9 = new ArrayList<Father>();
		c9.add(new Father());
		c9.add(new Father());
		
		c9.addAll(new Vector<Daughter>());
	}
}

class Father{}

class Son extends Father{}

class Daughter extends Father{}

泛型嵌套

泛型嵌套：泛型中可以包含泛型

有以下常见几种情况：

1. Collection嵌套Collection集合
2. Collection嵌套Map集合
3. Map嵌套Collection集合
4. Map嵌套Map集合

代码实例如下：

public class GenericDemo04 {
	public static void main(String[] args) {
		// 集合嵌套
		// 存储:由内至外
		ArrayList<Student> stuList01 = new ArrayList<Student>();
		stuList01.add(new Student("张三",19));
		stuList01.add(new Student("李四",18));
		stuList01.add(new Student("王五",17));
		
		ArrayList<Student> stuList02 = new ArrayList<Student>();
		stuList02.add(new Student("赵六",19));
		stuList02.add(new Student("钱八",18));
		
		ArrayList<ArrayList<Student>> gradeList = new ArrayList<ArrayList<Student>>();
		gradeList.add(stuList01);
		gradeList.add(stuList02);
		
		// 用于控制班级的变量
		int i = 1;
		// 遍历: 由外到内
		for (ArrayList<Student> grade : gradeList) {
			System.out.println(i + "班");
			for (Student  s: grade) {
				System.out.println("\t" + s.getName() + "|" + s.getAge());
			}
			i++;
		}
	}
}