泛型浅析

1.泛型

1.1为什么要使用泛型

在实际的开发中，对于数据一致化的要求是比较重要的

例如：

​ ArrayList list = new ArrayList();//构建了一个容器 int[] arr = new int[10];

​ 如果咱们对可以保存到ArrayList中的数据类型没有进行约束的话，就是导致你容器里面放了各式各样的数据

​ 如果需要取数据的话，有可能需要强制类型转换。浪费时间浪费执行效率甚至数据丢失。

为了解决这样的数据乱的情况，咱们要使用泛型里面的数据约束。

​ ArrayList list = new ArrayList();

​ 就是泛型的约束。约束数据类型的。要求咱们这个容器里面保存的数据必须是String 类型的数据

​ 1.数据一致化

​ 2.避免了没有必要的强制类型转换

​ 3.避免了因数据类型不一致导致的问题

​ 4.操作统一化

1.2最基本的泛型格式

泛型：

​ <无意义的占位符英文大写字母>

​ 使用泛型用来进行约束数据类型，同时能够让代码具有普适性（泛型：广泛的类型）

格式：

​ ArrayList list = new ArrayList();idea

​ ArrayList list = new ArrayList();Eclipse

错误格式：

​ ArrayList list = new ArrayList();要求前后保持一致

1.3自定义泛型在方法中如何使用

如果一个方法使用了泛型，会让该方法变得非常自由，具有普适性

语法格式：

​ 权限修饰符 [static] <自定义的泛型无意义的占位符> 返回值类型【可以使用自定义的泛型】 方法名字 （必须有一个带有自定义的参数） {}

带有自定义泛型的方法，是依赖于方法的参数来确定泛型的返回值的

package com.qfedu.a_fanxing;

/**
 * @author wangbo
 * @version 1.0
 * @date 2021/3/11 9:55
 */
public class Demo2 {
    public static void main(String[] args) {
        //String s = test1("123");
        Integer integer = test1(23);
        Dog dog = test1(new Dog());
        Integer integer1 = printArray(new Integer[]{1, 3, 5, 7, 9});
        printArray(new Dog[]{new Dog(), new Dog(), new Dog()});
    }
    public static int test(int num) {
        return num;
    }

    /**
     * 带有自定义泛型的方法
     * @param t  参数用于约束泛型的具体类型
     * @param <T>  自定义泛型的占位符
     * @return
     */
    public static <T> T test1(T t) {
        System.out.println(t);
        return t;
    }

    public static <T> T printArray(T[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
        return arr[0];
    }

}

1.4自定义泛型在类中如何使用

语法格式：

​ class 类名<自定义泛型无意义的的占位符> {

​ //类内的非静态成员变量和非静态成员方法可以使用类声明的自定义泛型

}

自定义泛型在类内使用的总结：

​ 1.在类名之后使用自定义的占位符，声明当前类带有泛型

​ 2.类声明的自定义的泛型，就是创建对象的时候对象确定的具体的泛型是哪一个

​ Test1 stringTest1 = new Test1<>();

​ 在类内方法中凡是使用到的都会被替换成String

​ 3.一个类带有自定义的泛型，但是在创建当前类对象的时候没有约束泛型的具体的数据类型。在类内使用

的所有的泛型 都会被Object替代

​ 4.类声明了自定义的泛型以后。不能用于静态的成员方法，HashSet

package com.qfedu.a_fanxing;

/**
 * @author wangbo
 * @version 1.0
 * @date 2021/3/11 10:39
 */
class Test1<T>{
    /**
     * 该方法使用了在类名上声明的自定义的泛型
     * @param t
     * @return
     */
    public  T getType(T t) {
        return t;
    }
    public void testArgs(T t) {
        System.out.println(t);
    }
    public boolean testBoolean(T t) {
        System.out.println(t);
        return true;
    }
    /*
    * why?为什么类的静态的成员变量和成员方法不能使用类的自定义的泛型
    * 静态的成员方法在类加载的时候，就已经在内存的数据区加载完毕
    * 泛型具体数据类型是在创建的对象的时候确定的
    * */
//    public static T testStatic (T t) {
//        System.out.println(t);
//        return t;
//    }
    /*自娱自乐  自己定义一个泛型和类的泛型没有关系的*/
    public static <E> E testStatic(E e) {
        return e;
    }

}
public class Demo3 {
    public static void main(String[] args) {
        Test1<String> stringTest1 = new Test1<String>();
        String type = stringTest1.getType("123");
        System.out.println(type);
        Test1<Dog> dogTest1 = new Test1<>();
        Dog type1 = dogTest1.getType(new Dog());
        System.out.println(type1);
        dogTest1.testArgs(new Dog());
        Integer integer = Test1.testStatic(12);
        System.out.println(integer);
        Test1 stringTest2 = new Test1();
        //stringTest2.testArgs();
    }

}

https://www.cnblogs.com/coprince/p/8603492.html
这个是一篇关于泛型的文章

1.5自定义泛型在接口中的使用

语法格式：

​ interface 接口名字 {

​ //有且只有成员方法才能使用泛型

​ //接口里面的成员变量public static final

​

​ }

package com.qfedu.a_fanxing;

/**
 * @author wangbo
 * @version 1.0
 * @date 2021/3/11 14:34
 */
interface  A<T> {
    public void  test(T t);
}
/*
* 当前类去实现一个接口，这个类名字后面必须和接口后面的泛型保持一致
*
* */
class TestA<T>  implements A<T> {

    @Override
    public void test(T t) {
        System.out.println(t);
    }
}

public class Demo6 {
    public static void main(String[] args) {
        //int===> Integer
        //char===>Character
        //boolean==>Boolean
        TestA<String> booleanTestA = new TestA<>();
        booleanTestA.test("goudan");


    }
}