【6】泛型 优缺点 泛型在类中的定义和使用 泛型在方法的定义和使用 泛型在接口中的定义和使用 泛型的通配符？

泛型

泛型：是一种未知的数据类型，当我们不知道使用什么数据类型的时候，可以使用泛型

           泛型也可以看出是一个变量，用来接收数据类型

创建集合对象，不使用泛型

  好处：集合不适用泛型，默认的类型就是object类型，可以存储任意类型的数据

  弊端：不安全，会引发异常

创建集合对象，使用泛型

   好处：避免了类型转换的麻烦，存储的是什么类型，取出的就是什么类型

             把运行期异常，提升到了编译期

   弊端：泛型是什么类型，只能存储什么类型的数据

定义和使用泛型的类

定义泛型类

/*
 * 定义一个含有泛型的类，模拟ArrayList集合
 * 泛型是一个未知的数据类型，当我们不确定什么数据类型的时候，可以使用泛型
 * 泛型可以接收任意的数据类型，可以使用Integer String Student
 * 创建对象的时候确定泛型的数据类型
 * */
public class GgenericClass<E> { //E泛型，不把数据类型写死
	private E name;

	public E  getName() {
		return name;
	}

	public void setName(E name) {
		this.name = name;
	}
	
}

使用泛型类

GgenericClass g = new GgenericClass<>();//泛型什么都不写，默认的是Object
		g.setName("我是Object");
		Object name = g.getName();
		System.out.println(name);
		
		GgenericClass<String> gs = new GgenericClass<>();//泛型写的是String，则name的数据类型就是String类型的
		gs.setName("我设置的泛型是String");
		String name2 = gs.getName();
		System.out.println(name2);
		
		GgenericClass<Integer> gi = new GgenericClass<>();//泛型写的是Integer，则name的数据类型就是Integer类型的
		gi.setName(15);
		Integer name3 = gi.getName();
		System.out.println(name3);

含有泛型的方法

/*
 * 定义还含有泛型的方法：泛型定义在方法的修饰符和返回值类型之间
 * 
 * 格式
 * 	修饰符 <泛型> 返回值类型 方法名(泛型){}
 * */
public class GenericClassMethod {
	public <M> void method(M m){
		System.out.println(m);
	}
	
	public static <S> void method2(S s){
		System.out.println(s);
	}
}

/*
 * 测试泛型的方法类
 * */
public class Test2 {
	public static void main(String[] args) {
		GenericClassMethod g = new GenericClassMethod();
		g.method(123);
		g.method("String");
			
		GenericClassMethod.method2(3);
		
	}
}

接口使用泛型

/*
 * 定义一个含有泛型的接口
 * */
public interface GenericInterface<E> {
	public void method(E e);
}

/*
 * 接口实现类1
 * 方法一:在写实现类的时候确定泛型
 * */
public class Impl1 implements GenericInterface<String> {

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

/*
 * 实现类2
 * 在接口的实现类中填入的泛型也是E new对象的时候才确定准确的泛型
 * */
public class Impl2<E> implements GenericInterface<E> {
	@Override
	public void method(E e) {
		System.out.println(e);
	}
}

/*
 * 测试类
 * */
public class Test3 {
	public static void main(String[] args) {
		Impl1 i = new Impl1();
		i.method("方法1");
		
		Impl2<Integer> ii = new Impl2<>();
		ii.method(12);
		
		Impl2<String> iii = new Impl2<>();
		iii.method("方法2");
	}
}

？泛型的通配符

public class Test4 {
	public static void main(String[] args) {
		/*
		 * 泛型的通配符：？代表任意的数据类型
		 * 适用方式：
		 * 		不能创建对象使用
		 * 		只能作为方法的参数使用
		 * */
		ArrayList<String> a = new ArrayList<>();
		a.add("a");
		a.add("b");
		
		ArrayList<Integer> b  = new ArrayList<>();
		b.add(1);
		b.add(2);
		
		method(a);
		method(b);
	}
	public static void method(ArrayList<?> m){ //？作为参数接收，泛型
		Iterator<?> it = m.iterator();
		while (it.hasNext()) {
			System.out.println(it.next());
		}
	}
}