Java泛型（一）

第一、泛型是什么？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) {

}
}




问一个问题：
以下动物中，选出你最怕的一个（单选）
A. 老鼠
B. 蜈蚣
C. 小强
D. 蛇
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());
// 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);
// }
// }

}