泛型的回顾

泛型

​ 泛型是一种安全机制，是一种书写的规范，它和接口的作用有着一定的类似，都是在制定规则。提升代码的复用功能，这里不单单对于功能模块进行一定的要求封装，同时也需要对数据类型进行统一的约束。

【重点】

1. 泛型满足数据类型支持多样化
2. 泛型严格遵守数据类型一致化要求
3. 泛型的核心目标是【增强方法】

常见的自定义的占位符
    <T>: 表示的是类型
    <E>：表示的是元素
    <K>：表示的是key键值 
    <V>：表示的是value值
    <N>：表示的是Number
    <?>：表示的是不确定的java类型

泛型的方法声明和其他的方法一样，注意类型只能是代表的引用类型，基本数据类型要写成包装类型

1.1 泛型在方法中的使用

泛型在方法中的使用格式：
    public static <T> 返回值类型[自定义泛型] 方法名称(必须存在一个对应的泛型的参数){
    方法体内能够使用自定义的泛型
}

注意：

​ 1.方法声明的泛型，在方法的参数中必须有一个参数是对应声明的自定义泛型。当前参数是用来约束方法内所有使用到泛型的位置对应的具体数据类型是什么。

​ 2.自定义的泛型声明在返回值之前，已经保证方法的参数和返回值都可以使用对应的泛型。

论证

    public static void main(String[] args) {

        /**
         * 针对于整型的数组，采用的必须是Int类型的包装类，原因泛型采用的只能是引用类型
         */
        Integer test = printArray(123);
        String test1 = printArray("123456");
        //对于对象类型，方法返回的也是对象
        Demo1 test2 = printArray(new Demo1());

        System.out.print(test);
        System.out.print(test1);
        System.out.print(test2);

    }

    /**
     * 泛型在方法中的使用，功能是展示任意数组的方式
     *
     * @param arr 指定的数组，但是没有确定数据类型，或者说数据类型是自定义数据类型
     * @param <T> 自定义泛型无意义占位符
     */
    public static <T> T printArray(T t){
        return t;
    }

1.2 泛型在类中的使用

泛型在类中的使用格式：
    public class 类名<自定义泛型无意义大写字母占位符>{
        在类内部的所有成员方法或者成员变量都是可以使用自定义泛型的。
    }

【注意】:

1. 成员变量不建议使用自定义泛型

2. 类声明泛型结束之后，在类内的所有成员方法中使用的泛型都是类约束的泛型具体数据类型

3. 如果没有约束类声明泛型，所有使用到泛型的位置都是Object，类型直接是祖宗类。

4. 类声明的自定义泛型不能够用于类内的静态方法【没有对象】，并且对于类声明的泛型，在类加载的时候静态方法无法确定类型。

5. 类声明自定义泛型，需要通过创建对象的方式来进行约束；

   Type type = new Type<>();

论证

/**
 * 定义一个带有自定义泛型的类
 *
 * @param <T> 百事得是自定义泛型无意义占位符
 */
class Type<T>{
    public T test1(T t){
        return t;
    }
    public void test2(T t1,T t2){
        System.out.println(t1);
        System.out.println(t2);
    }
}
public class Demo {

    public static void main(String[] args) {
        Type<String> type = new Type<>();
        //字符串类型
        String test1 = type.test1("老北京烤鸭");
        //整型类型
        Type<Integer> integerType = new Type<>();
        Integer integer = integerType.test1(123456);

        /**
         * 明确告知编译器这里的泛型对应的具体的数据类型是Demo2类型
         */
        Type<Demo1> type1 = new Type<>();
    }
}

1.3 泛型在接口中的使用

泛型在接口中的使用格式：
    inferface 接口名称 <自定义泛型无意义占位符>{
    	能够使用泛型的成员方法
}

注意：

  1. 泛型接口中的泛型不能够用于成员变量中，原因：对于接口中的成员变量而言，其缺省属性是public static final ，所以对于final修饰的变量是需要进行初始化操作的，初始化后无法进行修改。但是对于泛型来说是没有办法上来就确定数据的类型，所以是存在错误的，故，接口中的泛型是不能够用于成员变量。接口声明的泛型有且仅能用于类内的成员方法。
  1. 遵从带有自定义泛型的接口类，一种可以遵循从过程中明确告知泛型具体的类型，一种是在创建类对象中明确具体的数据类型（代码见下）
  1. 接口自带的泛型，遵循接口的实现类有两种方案可以implements当前接口：自由、规矩。【规矩】：接口的泛型明确接口中的方法，使用泛型对应的具体数据类型。class Type<T implements A<String> 【自由】：类名之后和接口同名自定义泛型，泛型对应的具体的数据类型是需要在创建当前类对象时进行约束。class Type<T> implements A<T>

论证

/**
 * 定义一个接口A，类型是自定义泛型
 *
 * @param <T> 自定义泛型占位符操作
 */
interface A<T>{
    /**
     * 用来进行检测输出，返回的类型是泛型
     * @param t
     */
    void test(T t);
}

class TypeB<T> implements A<String>{

    @Override
    public void test(String s) {
        System.out.println("采用的是规矩的模式");
    }
}

class TypeA<T> implements A<T>{

    @Override
    public void test(T t) {
        System.out.println("采用的是自由的模式");
    }
}

/**
 * @author sky 
 */
public class Demo1 {
    public static void main(String[] args) {
        /**
         * 自由模式的测试实现
         */
        TypeA<Integer> typeA = new TypeA<>();
        typeA.test(123);
        /**
         * 规矩模式进行测试操作
         */
        TypeB<String> typeB = new TypeB();
        typeB.test("1234566");
    }
}

-----待补充