java泛型

参考网页

package com.test;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Vector;
/**
 * @author caoxuekun
 * @time 2018年4月19日
 * @function:
 *      java泛型的学习
 *      参考网页:https://blog.csdn.net/s10461/article/details/53941091
 *      泛型：方法中传入的值不确定，用变量形参来顶替，同理如果传入的类型不确定，用类型形参来顶替
 *      这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。
 *
 *      重点：泛型只存在于编译阶段，不存在与运行阶段，在编译阶段会用实际的类型去代替
 */
public class Test1{
    public static void main(String[] args) {
        //泛型方法
        GenericClass<String> gc = new GenericClass<String>("曹雪坤");
        //也可以不指定具体的泛型的类型，让编译器自动去解析
        GenericClass gc2 = new GenericClass("曹雪坤");
        System.out.println(gc.getT());


        //泛型方法
        Generator_1 g1 = new Generator_1();
        Generator_2 g2 = new Generator_2();
        Generator_3 g3 = new Generator_3();
        System.out.println(g1.next());
        System.out.println(g2.next());
        System.out.println(g3.next());

        /**
         * Integer 源码：public final class Integer extends Number implements Comparable<Integer>
         *  但是下面的代码报错，为了解决这个问题
         */
        //Generator_3 g4 = new Generator_2(); 泛型无法继承 

        Generator_class g_c_1 = new Generator_class();
        g_c_1.show("曹雪坤");
        String g_value = g_c_1.show_k("caoxuekun");
        System.out.println("----g_value----"+g_value);

        ArrayList<String> list = new ArrayList<String>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        g_c_1.show_g(list);

        Generator_class_2<String>  g_c_2 = new Generator_class_2<String>();
        g_c_2.show_g_4("aaa","bbb","ccc");
        g_c_2.show_static(2);


        //泛型数组不知道有什么作用
        List<?>[] ls = new ArrayList<?>[10];  

        List<String>[] ls2 = new ArrayList[10];

    }

}

//泛型类
class GenericClass<T>{
    private T t;
    public GenericClass(T t){
        this.t = t;
    }
    public T getT(){
        return t;
    }
}

//定义一个泛型接口
interface Generator<T> {
  public T next();
}

//实现多种不同类型的Generator接口
class Generator_1 implements Generator<String>{
    private String next = "泛型接口";
    @Override
    public String next() {
        return next;
    }
}
class Generator_2 implements Generator<Integer>{
    private Integer next = 1;
    @Override
    public Integer next() {
        return next;
    }
}

class Generator_3 implements Generator<Number>{
    private Number next = 2;
    @Override
    public Number next() {
        return next;
    }       
}


//泛型方法
class Generator_class{

    //泛型方法
    public <T> void show(T t){
        System.out.println(t.toString());
    }

    //定义返回
    public <K>K show_k(K k){
        System.out.println(k.toString());
        return k;
    }

    //泛型方法继承
    public <T extends List> void show_g(T t){
        System.out.println("泛型-继承");
        System.out.println(t.toString());
    }


}

class Generator_class_2<E>{
    //?代表实际的类型
    public void show_g_2(Collection<? extends ArrayList> c){
        System.out.println(c.toString());
    }

    public void show_g_3(Collection<? extends E> c){
        System.out.println(c.toString());
    }

    //参数类型为泛型，且参数的个数为可变
    public <T> void show_g_4(T... c){
        for(T t:c){
            System.out.println(t.toString()+"=============");
        }
    }

    //定义静态类型的泛型方法
    public static <S> void show_static(S s){
        System.out.println(s.toString());
    }
}