泛型

package cn.learn.collection.FanXing;
/*
泛型的上限限定，格式？ extend E 代表使用的泛型只能是E类型的子类/本身
泛型的下限限定，格式？ super E 代表使用的泛型只能是E类型的父类/本身
 */
public class GenericControl {

}

package cn.learn.collection.FanXing;
/*
定义一个含有泛型的接口
 */
public interface GenericInterface<I>{
    public abstract void method(I i);
}

package cn.learn.collection.FanXing;
/*
 泛型接口
 第一种使用方式：定义接口的实现类，实现接口并指定接口的泛型

 */
public class GenericInterfaceImpl implements GenericInterface<String> {
    @Override
    public void method(String s) {
        System.out.println(s);
    }
}

package cn.learn.collection.FanXing;
/*
 泛型接口
 第二种使用方式：接口使用的是什么类型，实现类就是什么类型，类跟着接口走

 */
public class GenericInterfaceImpl2<I> implements GenericInterface<I> {
    @Override
    public void method(I i) {
        System.out.println(i);

    }
}

package cn.learn.collection.FanXing;
/*
定义一个含有泛型的方法：
格式：
 修饰符 <泛型> 返回值类型 方法名(参数列表(使用泛型)){
    //方法体
 }
 注:传递什么类型的参数，泛型就是什么类型
 */
public class GenericMethod {
    //定义一个泛型方法
    public <M> void method(M m){
        System.out.println(m);
    }

    //创建一个含有泛型的静态方法，属于这个类
    public static <M> void staticMethod(M m) {
        
        System.out.println(m);
    }
}

package cn.learn.collection.FanXing;
/*
定义一个含有泛型的类
泛型是一个未知的数据类型，当不确定数据类型时，可以使用泛型，用于接收任意数据
 */
public class GenericClass<E> {
    private E name;

    public E getName() {
        
        return name;
    }

    public void setName(E name) {
        
        this.name = name;
    }
}

 1 package cn.learn.collection.FanXing;
 2 
 3 import java.util.ArrayList;
 4 import java.util.Iterator;
 5 
 6 /*
 7 泛型：E -一种未知的数据类型，例如在集合中，可以放入任何元素，对象也行
 8        -变量，可以用来接受数据类型
 9  */
10 public class FanXing {
11     public static void main(String[] args) {
12         //如下没有规范指定的数据类型，可以存放任意数据类型，每个元素时Object型
13         ArrayList cl = new ArrayList();  //var cl = new ArrayList
14         cl.add(2);  //c1.add(int 2)
15         cl.add("skkkk");
16         //此时遍历不适合增强型for，但可以用迭代器
17         System.out.println(cl);//[2,skkkk]
18         //迭代器遍历
19         Iterator iter=cl.iterator();
20         while(iter.hasNext()){
21             System.out.println(iter.next());
22         }
23         /*
24         没有数据类型的集合
25         优点：可以添加任意数据类型
26         缺点：在使用其他方法是容易报异常
27          */
28         //如下得到字符串，返回的是一个Object类型，若想使用length方法，由于多态，必须向下转型
29         int i =((String)cl.get(1)).length();
30         System.out.println(i);  //5
31 
32 
33         //使用自己定义的泛型类
34         GenericClass text= new GenericClass();
35         text.setName("萝卜头");  //添加的是Object类型，所以不能直接用字符串的length方法
36         System.out.println(((String)text.getName()).length());  //3
37 
38         //使用自己定义的泛型类，接收元素为Integer
39         GenericClass<Integer> gite = new GenericClass<>();
40         //自动装箱
41         gite.setName(1);
42         //返回的是一个integer
43         Integer num = gite.getName();
44         System.out.println(num);  //1
45 
46         //将自己写的类作为E
47         ArrayList<GenericClass> gen= new ArrayList<>();
48         gen.add(text);
49         System.out.println(gen.get(0).getName()); //萝卜头
50 
51 
52         //调用泛型方法
53         GenericMethod name=new GenericMethod();
54         name.method("传递任意类型数据");
55         //调用静态泛型方法
56         GenericMethod.staticMethod("静态泛型方法调用了");
57 
58         //测试泛型接口的实现类
59         //第一种方法：指定了实现类的类型
60         GenericInterfaceImpl gimpl = new GenericInterfaceImpl();
61         gimpl.method("泛型指定实现类实现");
62 
63         //第二种方法：未指定实现类的类型
64         GenericInterfaceImpl2 gimpl2 = new GenericInterfaceImpl2();
65         gimpl2.method("sdas");  //传递的是一个Object对象，不是字符串
66         //在这里指定泛型的数据类型
67         GenericInterfaceImpl2<Integer> gimpl3 = new GenericInterfaceImpl2<>();
68         gimpl2.method(2);  //传递的是一个int
69         System.out.println(gimpl3);  //2
70 
71 
72 
73     }
74 }

package cn.learn.collection.FanXing;

import java.util.ArrayList;
import java.util.Iterator;

/*
泛型的通配符：
    ？：代表任意的数据类型
使用方式：
    不能创建对象使用，定义的时候
    只能作为方法的参数，传递的使用
 */
public class GenericWildcard {
    public static void main(String[] args) {
        ArrayList<Integer> list01= new ArrayList<>();
        list01.add(1);
        list01.add(2);
        list01.add(3);

        ArrayList<String> list02= new ArrayList<>();
        list02.add("ni");
        list02.add("ya");
        list02.add("hao");

        //任意类型的遍历实现
        traverse(list01);
        traverse(list02);
    }
    /*
    定义一个方法来进行遍历未知类型的集合，利用通配符?
     */
    public static void traverse(ArrayList<?> list){
        for (int i = 0; i < list.size() ; i++) {
            System.out.println("for循环遍历"+list.get(i));

        }
        //使用迭代器遍历集合，Iterator
        for (Iterator<?> it=list.iterator();it.hasNext();){
            System.out.println("迭代器遍历"+it.next());
        }
    }
}