java-泛型、

泛型（重点难点）

    概念：
        为什么要使用泛型？
            在实际开发中对于数据的一致性要求是比较重要的。
            ArrayList<E>:其实就是一个泛型类，可以在编译阶段约束集合对象只能操作某种数据类型。
            例如：
ArrayList  list = new  ArrayList();   
数组的容器，可以往里面放数据。
            但是没有对list这个集合进行数据约束。存放的数据任意类型都可以，等到获取的时候，需要强转。强转就不安全。
            这个时候可以加泛型：
ArrayList<String> list = new ArrayList<String>();
只能放String类型的数据。
1.数据一致性。
2.避免强转出错。
3.避免数据类型不一致的问题。
4.操作统一化。
                //  目标：能够使用泛型约束ArrayList集合操作的数据类型
public class Test2 {
    public static void main(String[] args) {
      //  ArrayList<String> list = new ArrayList<String>();
        ArrayList<String> list = new ArrayList<>();//JDK1.7开始，泛型后面的类型申明可以不写
        list.add("java");
        list.add("MySQL");
       // list.add(20);报错

        ArrayList<Integer> list2 = new ArrayList<>();
        list2.add(23);
        list2.add(100);
    }
}
            注意⚠️：集合中只能存储引用类型，不支持基本数据类型
举例：
Arraylist<String>：此集合只能操作字符串类型的元素。
Arraylist<Integer>：此集合只能操作整数类型的元素。（备注：如果非要填写整数因改写为Integer）
    最基本的泛型格式：
        泛型：
            <无意义的字符>  一般放<T>   <E>  <?>
泛型中可以写任何东西。
                T：type
E： element
K：key
V：value
    自定义泛型在方法中如何定义的？
        如果一个方法使用了泛型，会让该方法具有普适性。
        语法格式：
            权限修饰符 [ static ] <无意义的字符占位>  返回值类型 方法名字(){}
 (中括号的static可要可不要)
                public class Demo1 {
    public static void main(String[] args) {
        test("呵呵哒");
        test(10);
        test(false);
        test(35.5);

        test1("啦啦啦");
        //test1(12);  报错

        test2("字符串");
        test(false);

        test3(1 ,"hhh",false);

    }
    //  之前写的方法 没有泛型
    public static  void  test1(String str){
        System.out.println(str);
    }

      //  带有泛型的方法更加具有灵活性和普适性
      //   无返回值的  有参数的泛型方法
    public static <T>  void test(T t){
        System.out.println(t);
    }

     //有返回值  有参数的方法
    //有返回值的时候，返回值可以写T（方法名前面的T：返回值类型）；也可以写数据类型；看需求。
    public  static  <T> T test2 (T t){
        return t;
    }

    public static  <T> T test3(T t1, T t2, T t3){
        System.out.println(t1);
        System.out.println(t2);
        System.out.println(t3);
        return  t2;
    }

    //无参数 有返回值的
    public static <T> T test4(){
        T t = null;
        return  t; // 没有意义 确定不了T是什么类型数据，一旦确定就写死了 T就是具体的数据类型了
    }
    
    /**
     *  泛型方法也是有一定的约束的，不能理所当然的写方法。
     *  无参数无返回值的    没写过，因为没有任何意义
     *  有参数无返回值的    这个可以的
     *  无参数有返回值的    这个也没有任何意义
     *  有参数有返回值的    这个是可以的，但是要注意返回值类型和参数有点关系
     */
}
                    class  Dog{
    int age ;
    String nameString;

    //toString方法 重写Object的  返回的是一段字符串类型的数据
    //这个方法在new对象的时候会自动调用，
    //如果不写这个方法的时候，打印的是对象的地址；
    //如果写这个toString 就会将地址打印成字符串进行输出
    @Override
    public String toString() {
        return "Dog{" + "age=" + age + ", nameString='" + nameString + '\'' + '}';
    }
}

class Person{
    //T t 这个数据类型是不限制的 什么都可以
    public <T> void  printArgs(T t){
        System.out.println(t);
    }
}
public class Demo2 {
    public static void main(String[] args) {
        Person person = new Person();
        person.printArgs("肉夹馍");
        person.printArgs(true);
        person.printArgs(3.4);

       // person.printArgs(new Dog());//匿名对象 打印的是地址 @7a81197d

        Dog dog = new Dog();
        dog.nameString = "阿黄";
        dog.age = 12;
        person.printArgs(dog);//打印的是地址 @5ca881b5
    }
}
    泛型总结：
        1.使用场合：
            1.首先在我们创建集合的时候，直接写在接口名称或者类名之后<类型>，表示规范约束我们当前集合中的数据统一。
            2.在类声明的时候使用<T>，这种方式表示创建当前类对象的时候，可以传入一个具体的类型，供当前类中的所有方法使用，起到一个约束并且便捷操作的效果。 
            3.声明接口的时候使用<E>，这种方式表示 在创建实现类的时候可以传入一个具体的类型，供当前接口中的所有方法使用。起到一个约束并且便捷操作的效果。 
            4.形参列表中使用泛型
                1. <?>表示可以是任何类型
                2. <？extends 类型A>  表示可以传入的泛型的规则为可以是类型A或者是A的子类或者实现类。
                3. <? sunper 类型B> 表示可以传入的泛型的规则为可以是类型B或者是类型B的父类。