--------------------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培训、期待与您交流！ --------------------