泛型

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;
    }
}

package cn.learn.collection.FanXing;

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

/*
泛型：E -一种未知的数据类型，例如在集合中，可以放入任何元素，对象也行
       -变量，可以用来接受数据类型
 */
public class FanXing {
    public static void main(String[] args) {
        //如下没有规范指定的数据类型，可以存放任意数据类型，每个元素时Object型
        ArrayList cl = new ArrayList();  //var cl = new ArrayList
        cl.add(2);  //c1.add(int 2)
        cl.add("skkkk");
        //此时遍历不适合增强型for，但可以用迭代器
        System.out.println(cl);//[2,skkkk]
        //迭代器遍历
        Iterator iter=cl.iterator();
        while(iter.hasNext()){
            System.out.println(iter.next());
        }
        /*
        没有数据类型的集合
        优点：可以添加任意数据类型
        缺点：在使用其他方法是容易报异常
         */
        //如下得到字符串，返回的是一个Object类型，若想使用length方法，由于多态，必须向下转型
        int i =((String)cl.get(1)).length();
        System.out.println(i);  //5


        //使用自己定义的泛型类
        GenericClass text= new GenericClass();
        text.setName("萝卜头");  //添加的是Object类型，所以不能直接用字符串的length方法
        System.out.println(((String)text.getName()).length());  //3

        //使用自己定义的泛型类，接收元素为Integer
        GenericClass<Integer> gite = new GenericClass<>();
        //自动装箱
        gite.setName(1);
        //返回的是一个integer
        Integer num = gite.getName();
        System.out.println(num);  //1

        //将自己写的类作为E
        ArrayList<GenericClass> gen= new ArrayList<>();
        gen.add(text);
        System.out.println(gen.get(0).getName()); //萝卜头


        //调用泛型方法
        GenericMethod name=new GenericMethod();
        name.method("传递任意类型数据");
        //调用静态泛型方法
        GenericMethod.staticMethod("静态泛型方法调用了");

        //测试泛型接口的实现类
        //第一种方法：指定了实现类的类型
        GenericInterfaceImpl gimpl = new GenericInterfaceImpl();
        gimpl.method("泛型指定实现类实现");

        //第二种方法：未指定实现类的类型
        GenericInterfaceImpl2 gimpl2 = new GenericInterfaceImpl2();
        gimpl2.method("sdas");  //传递的是一个Object对象，不是字符串
        //在这里指定泛型的数据类型
        GenericInterfaceImpl2<Integer> gimpl3 = new GenericInterfaceImpl2<>();
        gimpl2.method(2);  //传递的是一个int
        System.out.println(gimpl3);  //2



    }
}

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());
        }
    }
}