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);

// }

// }

}