泛型类

1.泛型类在数据结构中的使用(java中的数据结构都采用了泛型的思路进行构造,所以一般都用泛型来调用数据结构)

 

ArrayList<Integer> list = new ArrayList<Integer>();
        list.add(78);
        list.add(89);
        list.add(99);
        list.add(60);
        
        for (Integer score: list)
        {
            System.out.println(score);
        }
        
        Iterator<Integer> it = list.iterator();
        while (it.hasNext())
        {
            System.out.println(it.next());
        }

Map<String,Integer> map = new HashMap<String,Integer>();
        map.put("a", 1);
        map.put("b", 2);
        map.put("c", 4);
        Set<Entry<String,Integer> > s = map.entrySet();
        Iterator<Entry<String,Integer> > it = s.iterator();
        while (it.hasNext())
        {
            Entry<String,Integer> et = it.next();
            String key = et.getKey();
            Integer value = et.getValue();
            System.out.println(key + " " + value);
        }

 

2.自定义泛型类

自定义泛型类即在类中含义泛型变量即为自定义泛型类

例如：

public class Order<T> {
    String orderName;
    int orderId;
    //类的内部声明一个泛型类T,命名为orderT
    T orderT;
    
    public Order(){};
    
    public Order(String orderName,int orderId,T orderT)
    {
        this.orderName = orderName;
        this.orderId = orderId;
        this.orderT = orderT;
    }
    
    //以下的两个方法都不属于泛型方法,它们都是泛型类中的某个方法
    public T GetOrderT()
    {
        return orderT;
    }
    
    public void SetOrderT(T orderT)
    {
        this.orderT = orderT;
    }

    @Override
    public String toString() {
        return "Order [orderName=" + orderName + ", orderId=" + orderId + ", orderT=" + orderT + "]";
    }
    
}

 

 

3.泛型函数

注意：泛型类中对泛型进行处理的函数不属于泛型函数

例子：

//泛型方法实例:
    public static <E> E GetE (E object)
    {
        return object;
    }
    /*
     * 所以泛型方法的本质是:引用了泛型类型,并以此作为返回值或者参数
     */

 

4.有关泛型的子类继承问题：

//将会默认为<Object,Object>,所以a，b可以被设置为任意类型
class Son1 extends Father{
    public void Set()
    {
        a = 1;
        b = 2;
    }
}

//此时a只能为字符串,b只能为整型
class Son2 extends Father<String,Integer>{
    public void Set()
    {
        a = "1";
        b = 2;
    }
}

//此时则将不确定的泛型转移到子类Son3来确定，即仍保留了这个泛型 
class Son3<T1,T2> extends Father<T1,T2> {
    
}

//保留了部分泛型,即T1确定为Integer,T2留到子类中再进行确定
class Son4<T2> extends Father<Integer,T2> {
    
}

 

5.泛型在继承方面的特点

/* 泛型在继承方面的特点：
     * 1.类A是类B的父类，但G<A>和G<B>并不具有子父类的关系
     *   如果可以具有子父类关系,则A中就会混入B的数据,不符合泛型的要求
     * 2.类A是类B的父类,A<T>和B<T>仍是子父类的关系
     * 
     */

/* 通配符的使用   
     * 通配符：?
     * 
     * 类A是类B的父类,G<A>和G<B>无关系,但二者的共同父类是G<?>
     *  
     */

public static void test2()
    {
        List<Object> list1 = null;
        List<String> list2 = null;
        
        List<?> list = null;
        
        list = list1;
        list = list2;
        
        List<String> list3 = new ArrayList<>();
        list3.add("aa");
        list3.add("bb");
        list3.add("cc");
        
        //对于List<?>的list,无法进行添加数据,只能添加null
        list.add("123");//报错
        list.add(null);//正常执行
        
        //允许读取数据,读取数据的类型为Object
        Object o = list.get(0);
        System.out.println(o);
    }

 

6.有限制条件的通配符使用

public void test4()
    {
        /* 有限制条件的通配符使用 
         * 若A是B的父类,则记为A > B 所以 Object > A > B
         * ? extends A:
         * 分三种情况进行分析：
         * 1.涉及到G(某一数据结构)<? extends A>整体赋值时,满足<=的含义,即A,B可以被赋值,Object不可以被赋值
         * 2.涉及到从数据结构获取值时,满足>=的含义,即可以给Object和A对象赋值,不可以给B对象赋值
         * 3.向数据结构添加数据类型:无法向数据结构中添加除null外的任意数据类型
         * 
         * ? super A:
         * 分三种情况进行分析：
         * 1.涉及到G(某一数据结构)<? super A>整体赋值时,满足>=的含义,即A,Object可以被赋值,B不可以被赋值
         * 2.涉及到从数据结构获取值时,满足>的含义,只能给Object的对象赋值
         * 3.向数据结构添加数据类型:只能向数据结构中添加A的数据类型
         * 
         */
        List<? extends Person> list1 = null;
        List<? super Person> list2 = null;
        
        //情况1
        List<Student> list3 = new ArrayList<>();
        List<Person> list4 = new ArrayList<>();
        List<Object> list5 = new ArrayList<>();
        
        list1 = list3;
        list1 = list4;
        list1 = list5;//该行会报错 
        
        list2 = list3;//该行会报错
        list2 = list4;
        list2 = list5;
        
        //情况2
        Object o1 = list1.get(0);
        Person p1 = list1.get(0);
        Student s1 = list1.get(0);//该行会报错,因为list1的类是Person类或者Person的父类
        
        Object o2 = list2.get(0);
        Person p2 = list2.get(0);//该行会报错
        Student s3 = list2.get(0);//该行会报错
        
        //情况3
        list1.add(new Student());//编译不通过
        list1.add(new Person());//编译不通过
        list1.add(new Object());
        
        list2.add(new Student());
        list2.add(new Person());
        list2.add(new Object());//编译不通过
        
    }