第08章 泛型

/*****************
***第08章 泛型
*******知识点:
**************1.泛型定义
**************2.泛型使用
******************2.1 普通泛型
******************2.2 类型通配符
******************2.3 受限泛型
******************2.4 泛型接口、类、方法
******************2.5 泛型数组
******************2.6 嵌套设置
*/
import java.util.*;

class Point<T>{       // 此处可以随便写标识符号，T是type的简称  
    private T var ; // var的类型由T指定，即：由外部指定  
    public T getVar(){  // 返回值的类型由外部决定  
        return var ;  
    }  
    public void setVar(T var){  // 设置的类型也由外部决定  
        this.var = var ;  
    }  
    public Point(T t){
        this.var = t;
    }
    public Point(){
        
    }
}

class PointKeyValue<K,V>{  // 此处指定了两个泛型类型  
    private K key;    // 此变量的类型由外部决定  
    private V value;  // 此变量的类型由外部决定
    public void setKey(K key){
        this.key = key;
    }
    public void setValue(V value){
        this.value = value;
    }
    public K getKey(){
        return key;
    }
    public V getValue(){
        return value;
    }
    
    public String toString(){
        return "{" + key + "," + value + "}";
    }
    public PointKeyValue(K k ,V v){
        this.key = k;
        this.value = v;
    }
    public PointKeyValue(){
        
    }
    
}

class PointInner<T,K,V>{
    private PointKeyValue p_PointKeyValue; // 接收两个泛型类型成员变量
    private Point p_Point;
    public PointInner(T t,K k,V v){
        this.p_Point = new Point(t);
        this.p_PointKeyValue = new PointKeyValue(k,v);
    }
    
    public String toString(){
        return "{" + p_Point.getVar() + ":" + p_PointKeyValue.getKey() + "," + p_PointKeyValue.getValue() + "}";
    }
}

public class test8{
    public static void main(String[] args){
        showDemo("泛型定义");
        testGenericsDefined();//演示泛型定义
        
        showDemo("泛型使用");
        testGenericsUse();//演示泛型使用
    }    
    
    /*
    *1.泛型定义
    */
    public static void testGenericsDefined(){
        /*List l_Gen = new ArrayList();
        l_Gen.add(1);
        l_Gen.add(2);
        l_Gen.add("aaaaa");//注意跟之前两个元素类型发生了变化，但不报错
        System.out.println("集合中元素有："  + l_Gen);
        
        List<Integer> l_Gen1 = new ArrayList<Integer>();
        l_Gen1.add(1);
        l_Gen1.add(2);
        l_Gen1.add("aaaaa");//此行报错
        System.out.println("集合中元素有："  + l_Gen1);*/
        
        //泛型：Java的参数化类型，即允许我们在创建集合时指定集合中元素的类型,且该集合只能存储指定类型的元素
        //使用范围：定义类、接口、方法是使用类型形参
        //需注意：静态初始化块中是不允许的
        
    }
    
    /*
    *2.泛型使用
    */
    public static void testGenericsUse(){
        /**2.1 普通泛型**/
        System.out.println("演示2.1 普通泛型===========");
        Point<Integer> p_Generics = new Point<Integer>(); //里面的var类型为Integer
        p_Generics.setVar(new Integer(1));//设置var
        System.out.println("返回int值:" + (p_Generics.getVar().intValue()));//返回var
        
        PointKeyValue<Integer,String> p_KeyValue = new PointKeyValue<Integer,String>();
        p_KeyValue.setKey(new Integer(10));
        p_KeyValue.setValue("Ciade");
        System.out.println("返回key：" + p_KeyValue.getKey());
        System.out.println("返回value：" + p_KeyValue.getValue());
        System.out.println("返回p_KeyValue：" + p_KeyValue.toString());
        
        /**2.2 类型通配符**/
        System.out.println("演示2.2 类型通配符===========");
        PointKeyValue<Integer,Double> p_PointKeyValue2 = new PointKeyValue<Integer,Double>();
        PointKeyValue<String,String> p_PointKeyValue3 = new PointKeyValue<String,String>();
        
        p_PointKeyValue2.setKey(new Integer(2));
        p_PointKeyValue2.setValue(new Double(2.2));
        
        p_PointKeyValue3.setKey("3");
        p_PointKeyValue3.setValue("33333333");//注意区分p_PointKeyValue2和p_PointKeyValue3
        
        demoWildcardFun(p_PointKeyValue2);//调用通配符泛型演示方法
        demoWildcardFun(p_PointKeyValue3);//调用通配符泛型演示方法
        
        /**2.3 受限泛型**/
        System.out.println("演示2.3 受限泛型===========");
        PointKeyValue<Integer,String> p_PointKeyValue4 = new PointKeyValue<Integer,String>();
        
        p_PointKeyValue4.setKey(new Integer(4));
        p_PointKeyValue4.setValue("4444444");
        
        //demoLimitedFun(p_PointKeyValue2);//这行报错  类型受限
        //demoLimitedFun(p_PointKeyValue3);//这行报错  类型受限
        demoLimitedFun(p_PointKeyValue4);
        
        /**2.4 泛型接口、类、方法**/
        //接口、类 、方法 参照上面的Point类和PointKeyValue类的定义使用
        //温馨提示  当重载方法时，若重载的参数个数相同，参数类型和返回值不同时 可以使用泛型方法
        
        /**2.5 泛型数组**/
        //Java 不支持泛型数组。也就是说
        //List<String>[] ls = new ArrayList<String>[10];  //编译报错
        //而你可以这样子
        //List<String>[] ls = new ArrayList[10];
        //不过不建议使用
        
        /**2.6 嵌套设置**/
        System.out.println("演示2.6 嵌套设置===========");
        PointInner<Integer,Integer,String> p_PointInner = new PointInner<Integer,Integer,String>
                                                        (new Integer(7),new Integer(7),"777777777");
        System.out.println("PointInner对象:" + p_PointInner);

    }
    
    /*
    *  通配符泛型演示方法
    */
    public static void demoWildcardFun(PointKeyValue<?,?> temp){  // 可以接收任意的泛型对象 其中?为通配符
        System.out.print("返回key：" + temp.getKey());
        System.out.print("_返回value：" + temp.getValue());
        System.out.println("_返回PointKeyValue对象：" + temp.toString());
        
    }
    
    /*
    * 受限泛型演示方法
    */
    //第一个参数只能接收Number及其Number的子类，第二个参数只能接收String或Object类型的泛型
    public static void demoLimitedFun(PointKeyValue<? extends Number,? super String> temp){
        demoWildcardFun(temp);
    }
    
    
    /*
    *    抽取打印演示函数  用于打印演示功能提示
    */    
    public static void showDemo(String demoStr){
        System.out.println("演示:" + demoStr);
    }
}