黑马程序员_泛型

--------------------ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ --------------------

 

1.     泛型

     1.概述

 

           泛型是为了解决了集合中存储对象安全问题，如果集合中存数了不同类型的对象，那么读取出来后，操作取出的对象以为不知道类型，会出现安全问题，但是这不会在编译时期提示错误，而是会在运行时期出现问题，所以泛型会把运行时期的错误移到了编译时期，那么错误就会避免。

     2.集合中的泛型

           在集合中都会存在泛型，下同时迭代器中也定义了泛型，在读取出来后，我们也要指定迭代器的类型，这样我们就不需要强制类型转换了，因为迭代器中就指定了类型，所以读取出来的对象类型也就是我们指定的类型。

 

 

package www.fuxi.jihe;import java.util.ArrayList;
import java.util.Iterator;public class fanxingDemo {public static void main(String[] args) {ArrayList<String> list = new ArrayList<String>();list.add("zhangsan");// 在这里必须传入的String对象，如果不是那么编译会出错误list.add("lisi");Iterator<String>it = list.iterator();// 在这里也要指定迭代器的类型while (it.hasNext()) {String s = it.next();// 在这里不需要强制类型转换为String了，因为迭代器已经指定了类型System.out.println(s);}}}
结果：
zhangsan
lisi

 

 

 

2.     自定义泛型类

自定义的泛型类，可以按照我们随意要求指定类型

 

 

package www.fuxi.jihe;/*** 在此类型定义了一个泛型，这个字母可以随便定义当创建了此类的对象，那么就需要指定泛型的类型，那么里面的成员泛型就统一指定了*/
package www.fuxi.jihe;public class Demo<T> {private T t;public void set(T t){//此方法是和类上的泛型一起变化this.t=t;System.out.println("set:"+t);}public static void main(String [] agrs){Demo<String> d=new Demo<String>();d.set("123");}}
结果：
set:123

 

 

3.     泛型方法

1.     一个泛型

   

public class Demo<T> {public void show(T t) {System.out.println("show:" + t);}public void print(T t) {System.out.println("print:" + t);}public static void main(String[] args) {Demo<String> d = new Demo<String>();d.show("hello");d.print("world");// d.show(new// Integer(2));//在这里编译出错，因为d对象泛型已经指定了是String类型，所以参数全部是String类型System.out.println("-----------");Demo<Integer> d1 = new Demo<Integer>();d1.show(new Integer(3));d1.print(new Integer(6));}}
结果：
show:hello
print:world
-----------
show:3
print:6

 

 

 

2.     多个泛型

 

 

package www.fuxi.jihe;public class Demo<T> {public void set(T t){//此方法是和类上的泛型一起变化System.out.println("set:"+t);}public <Q> void get(Q q){//此方法上的泛型是和类上的泛型无关，可以是任意类型System.out.println("get:"+q);}public static void main(String [] agrs){Demo<String> d=new Demo<String>();d.set("123");d.get("abc");d.get(5);}}结果：
set:123
get:abc
get:5

 

从结果可以看出，这个类中既有和类上的泛型一起变化的，也有自己特有的方法，例如：get()方法上的泛型，可以和类上的一样也可以不一样。

 

3.静态方法上的泛型

  把泛型定义在返回值和修饰符之间

静态方法上的泛型的定义需要自己定义，不要和类上的泛型统一，因为静态方法只要是类一加载就生成，如果和类上的泛型统一的话，在静态方法加载的时候，没有对象生成，也就没有指定泛型的类型，那么就会出错，这些都和泛型定义出现的时间有关。

 

 

package www.fuxi.jihe;public class Demo<T> {public static <Q> void show(Q q){//这里不要和类上的泛型统一System.out.println("show:"+q);}public static void main(String [] agrs){Demo.show("hello");}}
结果：
show:hello

 

4.     接口泛型

     在接口上自定义泛型

 

 

package www.fuxi.jihe;interface inter<T> {void show(T t);
}/* 第一种实现泛型接口，在接口上指定泛型类型 */
public class Demo implements inter<String> {public void show(String t) {System.out.println("show:" + t);}public static void main(String[] agrs) {Demo d = new Demo();d.show("hellowrold");}
}
结果：
show:hello world

 

 

下面是在对象是上指定泛型类型

 

 

package www.fuxi.jihe;interface inter<T> {void show(T t);
}/* 第二种实现泛型接口，在接口上不定义泛型，而是在对象上指定泛型类型 */
public class Demo<T> implements inter<T> {public void show(T t) {System.out.println("show:" + t);}public static void main(String[] agrs) {Demo<Integer> d = new Demo<Integer>();d.show(3);}
}结果：
show:3

 

5.     泛型的高级应用

1.     通配符

通配符用？表示，也叫占位符，可以表示任意类型

 

 

package www.fuxi.jihe;import java.util.ArrayList;
import java.util.Iterator;public class Demo {/*在这里泛型类型使用通配符表示，表次是此可以传入任意类型*/public void show(ArrayList<?> list) {Iterator<?> it = list.iterator();while (it.hasNext()) {System.out.println(it.next());}}public static void main(String[] agrs) {Demo d = new Demo();ArrayList<String> l1 = new ArrayList<String>();l1.add("abc");l1.add("123");l1.add("ased");d.show(l1);System.out.println("---------");ArrayList<Integer> l2 = new ArrayList<Integer>();l2.add(1);l2.add(2);l2.add(3);d.show(l2);}
}
结果：
abc
123
ased
---------
1
2
3

 

 

但是也可以使用另一中方式表示，但是其有缺点，不能表示一个范围类型，通配符可以表示一个类型范围，详细“2.参考通配符设置上下限”

 

 

package www.fuxi.jihe;import java.util.ArrayList;
import java.util.Iterator;public class Demo {/* 在这里泛型类型使用通配符表示，表次是此可以传入任意类型 */public <T> void show(ArrayList<T> list) {Iterator<T> it = list.iterator();while (it.hasNext()) {T t= it.next();System.out.println(t);}}public static void main(String[] agrs) {Demo d = new Demo();ArrayList<String> l1 = new ArrayList<String>();l1.add("abc");l1.add("123");l1.add("ased");d.show(l1);System.out.println("---------");ArrayList<Integer> l2 = new ArrayList<Integer>();l2.add(1);l2.add(2);l2.add(3);d.show(l2);}
}结果：
abc
123
ased
---------
1
2
3

 

从结果上可以看出，结果和使用通配符是一样的，这个好处可以把对象取出来，可以进行操作，T t= it.next();但是使用通配符的话，就不能进行此操作，但是通配符可以设置上下限。

2.     通配符设置上下限

？ extends E ：？表示可以是E类型或者是E的子类，这是设置的上限

？ super E：？表示的可以是E类型或者E的父类类型，这是设置的下限

 

设置上限

 

 

package www.fuxi.jihe;import java.util.ArrayList;
import java.util.Iterator;class door {privateString name;publicdoor(String name) {this.name= name;}publicString toString() {returnthis.name;}
}class tieDoor extends door {// 继承了door类publictieDoor(String name) {super(name);}
}public class fanxingDemo {publicvoid show(ArrayList<? extends door> list) {// 设置类泛型的限，可以是door类型或者是door的子类型Iterator<?extends door> it = list.iterator();while(it.hasNext()) {System.out.println(it.next());}}publicstatic void main(String[] args) {fanxingDemod = new fanxingDemo();ArrayList<tieDoor>list = new ArrayList<tieDoor>();list.add(newtieDoor("door-1"));list.add(newtieDoor("door-2"));list.add(newtieDoor("door-3"));d.show(list);}}
结果：
door-1
door-2
door-3

 

 

设置下限：

 

TreeSet(Comparator<?super E> comparator)
          构造一个新的空 TreeSet，它根据指定比较器进行排序。

我们就根据这个比较器看看设置下限：

 

package www.fuxi.jihe;import java.util.ArrayList;
import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;class door {privateString name;publicdoor(String name) {this.name= name;}publicString toString() {returnthis.name;}publicString getName(){returnthis.name;}
}class tieDoor extends door {// 继承了door类publictieDoor(String name) {super(name);}
}class MyCom implements Comparator<door>{publicint compare(door o1, door o2) {returno1.getName().compareTo(o2.getName());}}
public class fanxingDemo {publicstatic void main(String[] args) {fanxingDemod = new fanxingDemo();TreeSet<tieDoor>list = new TreeSet<tieDoor>(new MyCom());list.add(newtieDoor("door-3"));list.add(newtieDoor("door-1"));list.add(newtieDoor("door-2"));Iterator<tieDoor>it=list.iterator();while(it.hasNext()){System.out.println(it.next());}}}
结果：
door-1
door-2
door-3

 

从结果可以看出，已经比较了，但是设置的比较器是父类型，但是TreeSet集合设置的door的子类型，也可以排序，就是可以是下限或者是下限的父类型

可以是tieDoor类型或者tieDoor的父类型，都可以进行比较

假如又有一个类继承了door类，那么此子类对象添加到在TreeSet中，也可以使用当前的比较器进行排序。

--------------------ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ --------------------