泛型的使用

第一、泛型是什么？java为什么需要泛型？
泛型的思想及其优点：
 public static void main(String[] args) {
  
  List list = new ArrayList();
  list.add("A");
  list.add("B");
  list.add("C");
  list.add(new Integer(13));
  Iterator it = list.iterator();
  while(it.hasNext()) {
   String str = (String)it.next();
   System.out.println(str);
  }
  
  /*
  思考一下：
  1. 万一集合里放的对象不一致，有可能在遍历的时候导致类型转换错误。
  2. 既使集合里的类型能够确定，但集合每一次都要进行强制转换，这样太麻烦。
  
  为了解决这两个问题，jdk推出了泛型的机制
  */
  // 使用泛型：
  // 指定了该ArrayList集合只能够放String类型的对象
  List<String> list = new ArrayList<String>();
  list.add("A");
  list.add("B");
  list.add("C");
  /*
  泛型的优点：
  1. 在编译的时候就把错误报出来，把问题解决在萌芽状态
     [把运行时期的问题带到编译时期来解决！]
  2. 省去强制类型转换带来的麻烦。提高了代码的安全性。
  */
  Iterator<String> it = list.iterator();
  while(it.hasNext()) {
   String str = (String)it.next();
   String str = it.next();
   System.out.println(str);
  }
 }

 

-------------------------------------------------------
第二、泛型的使用
2.1 泛型用在类上（泛型类）
public class NewOperator<E> {
 private E e;
 public E getE() {
  return e;
 }
 public void setE(E e) {
  this.e = e;
 }
 public static void main(String[] args) {
  NewOperator<Teacher> op = new NewOperator<Teacher>();
  Teacher student = new Teacher();
  op.setE(student);
  Teacher s = op.getE();
 }
}

2.2 泛型用在方法上 （泛型方法）
泛型用在普通方法上
public class NewOperator<E> {
 private ArrayList<E> list = new ArrayList<E>();
 
 public void method(E e) {
  list.add(e);
 }
 
 public static void main(String[] args) {
  NewOperator<Teacher> op = new NewOperator<Teacher>();
  op.method(new Teacher());
 }
}

泛型用在静态方法上
public class NewOperator<E> {
 
 // 如果泛型用在静态方法上，必须要先声明。
 // 声明的位置必须放在void方法前面
 public static <EE> void method(EE e) {
 }
 
 public static void main(String[] args) {
  NewOperator<Teacher> op = new NewOperator<Teacher>();
  op.method(new Teacher());
 }
}
/*
声明泛型有两种方式：
第一、写在类的后面：NewOperator<E>
第二、写在静态方法名中间：public static <EE> void method(EE e)
*/

泛型用在接口上（泛型接口）
public class Test<E> {
 public static void main(String[] args) {
  Inter<String> in = new InterImpl<String>();
 }
}

interface Inter<E> {
 public void method(E e);
}

// 第一、你能确定泛型的类型吗？知道子类需要什么泛型类型的写法：
//class InterImpl implements Inter<String>{
// @Override
// public void method(String e) {
// }
//}

// 第二、如果连子类都不知道泛型的类型是什么，就这样写：
class InterImpl<E> implements Inter<E>{
 @Override
 public void method(E e) {
  
 }
}

 

泛型上限与泛型下限

public class Test<E> {
 public static void main(String[] args) {
  
  TreeSet tree = new TreeSet();
  
  
  List<Person> list2 = new ArrayList<Person>();
  list2.add(new Person());
  list2.add(new Person());
  print(list2);
  
  List<Dog> list3 = new ArrayList<Dog>();
  list3.add(new Dog());
    list3.add(new Dog());
  list3.add(new Dog());
  print(list3);
 }

 // 调用此方法的泛型类型必须是人！狗不能进来！
 // 泛型上限<? extends Person>:表示只能是Person或Person的子类
 // 泛型下限<? super Student>: 表示只能是Student或Student的父类
 /*
 泛型上限与泛型下限的作用：
 可以让一个集合放入另一个集合的的时候，限制它们的类型
 
 使用泛型上限，不可以向集合添加任何元素，除了null之外。
 使用泛型下限，可以向集合添加元素。但只能添加super后类型本身或它的子类
 <? super T> 只能添加T以及T的子类
 */

 
 public static <E> void print(List<E> list) {
  java.util.Iterator<E> it = list.iterator();
  while(it.hasNext()) {
   E s = it.next();
   System.out.println(s);
  }
 }
 
}