JavaSE-泛型

概述：

泛型的本质是参数化类型，把类型作为参数传递

常见形式有泛型类，泛型接口，泛型方法

语法：

<T...> T称为类型占位符，表示一种引用类型

好处：

1.提高代码的重用性

2.防止类型转换异常，提高代码安全性

泛型类

//泛型
public class Demo8 {
    public static void main(String[] args) {
        //使用泛型类创建对象,后面的<>可写可不写，在jdk1.7之前得写，在jdk1.7之后不用写
        Cat<String> c = new Cat<>();
        c.t = "小猫";
        c.show("大猫");
        System.out.println(c.display());//输出小猫

        Cat<Integer> c2 = new Cat<>();
        c2.t = 5;
        c2.show(6);
        System.out.println(c2.display());//输出5

        /*
        泛型类型不同的引用类型不能相互赋值，尽管引用类型相同，如
        Cat<String> c3 = c2;
         */

    }
}

//
/*
1.泛型类，T是类型占位符，表示一种引用类型，如果编写多个使用逗号隔开
 */
class Cat<T>{
    T t;
    //2.泛型作为方法的参数
    public void show(T t){
        //T t = new T();
        /*
        不能用泛型创建对象，因为不能确定这个类型的构造器是不是私有的，私有的构造器在单例模式中使用
        所以干脆不允许用泛型创建对象
         */
    }
    //3.泛型作为方法的返回值类型
    public T display(){

        return t;
    }
}

代码简述：泛型类的简单应用，类的泛型的确定是在创建对象的时候。注意一点，类的泛型不能应用到静态方法中，静态方法是在类初始化阶段被初始化。

泛型接口

/*
语法：
    接口名<T>
注意：
    不能创建泛型静态常量 public static final T t = new T();

 */
interface MyInterface<T>{
    public static final String name = "盖伦";
    //创建泛型抽象方法，参数也是泛型
    public abstract T show(T t);
}

//情况1：在实现接口时，把泛型指定
class Testx implements MyInterface<String>{
    @Override
    public String show(String s) {
        return s;
    }
}
//情况2：在实现接口时，确定不了泛型类型,则什么时候确定呢？在创建Test对象时才去确定
class Testz<T> implements MyInterface<T>{
    @Override
    public T show(T t) {
        return t;
    }
}


public class Demo9 {
    public static void main(String[] args) {
        //情况1演示
        MyInterface myInterface = new Testx();
        System.out.println(myInterface.show("aaaa"));//输出aaaa
        //情况2演示
        MyInterface<Integer> myInterface1 = new Testz<>();
        System.out.println(myInterface1.show(5));//输出5
    }
}

代码简述：在使用泛型接口的时候，有两种情况，第一种创建实现类也就是实现接口的时候去指定泛型类型，另一种时创建实现类时不能确定接口的泛型类型，此时将实现类也用泛型，在创建实现类对象的时候再确定泛型类型

泛型方法

/*
泛型方法
语法:
    <T>返回值类型
 */


public class Demo10 {
    public static void main(String[] args) {
        MyGenericMethod m = new MyGenericMethod();

        m.show(5);
        System.out.println(m.display(5));
        System.out.println(MyGenericMethod.method("静态方法"));
    }
}
class MyGenericMethod{
    //泛型方法
    /*
    泛型类和泛型接口中的泛型T在整个类或接口中都能用，而泛型方法的T只能在当前方法中使用
    方法自己使用泛型，意思是方法的参数类型任意，这个泛型可以应用到返回值上，也可应用到参数类型上
    所以此时这个方法所应用到的泛型不再受类或接口泛型的影响了
     */
    public <T> void show(T t){
        System.out.println("泛型方法");
    }

    //方法的返回值类型也为泛型
    public <T> T display(T t){
        return t;
    }
    //静态方法使用泛型
    public static <T> T method(T t){
        return t;
    }

}

代码简述：

泛型类和泛型接口中的泛型T在整个类或接口中都能用，而泛型方法的T只能在当前方法中使用
方法自己使用泛型，意思是方法的参数类型任意，这个泛型可以应用到返回值上，也可应用到参数类型上
所以此时这个方法所应用到的泛型不再受类或接口泛型的影响了