黑马程序员_泛型笔记

一、泛型演示一：
/* 
泛型：jdk1.5 以后出现的新特性，用于解决安全问题，是一个安全机制 
 
 
好处： 
1、将运行时期出现的问题 classCastException，转移到了编译时期 
    方便于程序员解决问题。让运行时期问题减少，安全。 
2、避免了强制转换的麻烦 
 
泛型格式：通过 <> 来定义要操作的引用数据类型。 
什么时候使用泛型呢？ 
通常在集合框架中很常见 
只要见到<>就要定义泛型 
 
其实<>就是用来接收类型的。 


<>用来接收引用数据类型
 
当使用集合时，将集合中要存储的数据类型作为参数传递到尖括号中即可，和函数传参数一样 
*/  
import java.util.*;  
  
  
public class GenericlDemo{  
    public static void main(String args[]){  
        ArrayList<String> al = new ArrayList<String>();  
        al.add("abc01");  
        al.add("abc02");  
        al.add("abc03");  
        al.add("abc04");  
        //al.add(4);//相当于al.add(new Integer(4))----自动装箱功能  
         
Iterator<String> it = al.iterator();
 while(it.hasNext()){ String s = it.next(); sop(s); } } public static void sop(Object obj){ System.out.println(obj.toString()); } }
二、泛型演示二：
泛型在比较器中的应用：
import java.util.*;  
  
  
public class GenericlDemo{  
    public static void main(String args[]){  
        TreeSet<String> al = new TreeSet<String>(new LenComparator());  
        al.add("abc1");  
        al.add("d");  
        al.add("ex");  
        al.add("ace");  
        Iterator<String> it = al.iterator();
        while(it.hasNext()){  
            String s = it.next();  
            System.out.println(s);  
        }           
    }   
}  
class LenComparator implements Comparator<String>{  
    public int compare(String s1,String s2){  
        int num = new Integer(s2.length()).compareTo(new Integer(s1.length()));  
        if(num==0){  
            return s1.compareTo(s2);  
        }  
        return num;  
    }  
}  
三、泛型类
/* 
泛型类 
舍呢么时候定义泛型类？ 
当类中要操作的引用数据类型不确定的时候 
早期定义Object 来完成扩展 
现在，定义泛型来完成扩展 
*/  
import java.util.*;  
//泛型类  
class Utils<QQ>{  
  private QQ q;  
  public void setObject(QQ q){  
      this.q = q;  
  }  
  public QQ getObject(){  
      return q;  
  }  
}   
public class GenericlDemo{  
    public static void main(String args[]){   
        Utils<Worker> u = new Utils<Worker>();  
        u.setObject(new Worker());  
        Worker w = u.getObject();  
    }  
    public static void sop(Object obj){  
        System.out.println(obj.toString());  
    }  
}  
class Worker{  
      
}  
class Student{  
      
}  


四、泛型方法
/* 
 泛型类定义的泛型，在整个类中有效，如果被方法是用 
 那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了 


 为了让不同方法可以操作不同类型，而且类型还不确定 
 那么可以将泛型定义在方法上，而不定义在类上 


 public <T> void show(T t){ 


 } 


 */
import java.util.*;


class Demo{
// 泛型方法
public <T> void show(T t) {
System.out.println("show:"+t);
}


public <Q> void print(Q q) {
System.out.println("print:" + q);
}



}
public class GenericlDemo {
public static void main(String args[]) {
Demo d = new Demo();
d.show("haha");
d.print(new Integer(4));
d.print("hehe");
}


public static void sop(Object obj) {
System.out.println(obj.toString());
}
}


五、泛型限定
/* 
? 通配符 
泛型的限定：
? extends E:可以接收 E 类型或者 E 的子类型。上限。 
？ super E：可以接收E类型或者E的父类型，下限 
*/  
import java.util.*;  
public class Demo{  
    public static void main(String args[]){  
        ArrayList<Person> al = new ArrayList<Person>();  
        al.add(new Person("adf"));  
        al.add(new Person("dfgdf"));  
        al.add(new Person("dfsdas"));  
          
        ArrayList<Student> al1 = new ArrayList<Student>();  
        al1.add(new Student("---vdf"));  
        al1.add(new Student("---sd"));  
        al1.add(new Student("---acddc")); 
        printColl(al1);
    }  
   
    public static void printColl(ArrayList<? extends Person> al){//这样可以接收别的子类  
        Iterator<? extends Person> it = al.iterator();  
        while(it.hasNext()){  
            System.out.println(it.next().getName());  
        }  
    }  
}  
class Person{  
    private String name;  
    Person(String name){  
        this.name = name;  
    }  
    public String getName(){  
        return name;  
    }  
}  
class Student extends Person{  
    Student(String name){  
        super(name);  
    }  
}