java 泛型

 在实际开发中对于数据一致性的要求是比较重要的
 例如：
            int[] arr = new int[5];

 ​            在向arr这个数组容器中添加数据的时候，必须要放int类型的数据，不能放其他类型的数据

            这就是数据一致性的特点。

            咱们以后还会将一个集合，集合类似数组就是可以向集合中添加数据的。数组有一个对数据个数的限制，所以开中一般不用数组，用集合

            那么接下来，咱们需要看一下数组存数据和集合存数据的不同之处。

 ​    1.保证数据一致性

 ​    2.操作统一化

​    3.具有普适性

package com.qfedu.a_fanxing;

import java.util.ArrayList;

public class Demo1 {
    public static void main(String[] args) {
        int[] arr = new int[4];
        //可以向arr这个数组中存放 int类型的数据
        //java 对数据一致性的要求的是比较看重的
        String[] strings = new String[5];
        //strings这个变量只能存放String类型的数据
        //在开发中很实用数组，因为数组在定义的时候指定数组的容量，所以很少用
        //一般使用集合，集合你就把它想象成一个容器，这个容器是可以存方法数据的
        ArrayList arrayList = new ArrayList();
        //arrayList集合对象，可以存放数据的
        arrayList.add(34);//int类型的数据
        arrayList.add("xixida");//string类型的数据
        arrayList.add(false);//存放布尔类型的数据
    
        //以上在存值不好的
        //接下来我想取值
        //通过索引下标进行取值
        //get方法的返回值是Object类型的数据，为啥是Object类型的数据
        //Object 是所有的类的父类，因为我在存数据的时候，我的数据
        //类型存的不一致，干脆放一个参数Object 多态的一种体现形式
        //将Object类型的数据转为String类型的数据  向下转型  强转
        String string = (String)arrayList.get(1);
        System.out.println(string);
        //这样是不行的
        //java 给咱们提供了一个东西叫泛型，用来保证数据一致性的操作的
        // 就是泛型的一种体现形式，要求集合strsList  存放的
        //数据必须是统一的  String类型的数据
        ArrayList  strsList = new ArrayList();
        strsList.add("gd");
        strsList.add("mh");
        //以上在赋值
        //取值  不需要强转
        String srString = strsList.get(0);
        System.out.println(srString);
    }

}

泛型的语法格式

<无意义的字符>
    无意义的字符一般放的是    

自定义泛型在方法中如何定义的

如果一个方法使用了泛型，会让该方法具有普适性

 语法格式：

权限修饰符  [static] <无意义的占位符> 返回值的类型   方法名字 (参数类型) {

}
 public void get(T t){}

package com.qfedu.a_fanxing;

public class Demo2 {
    public static void main(String[] args) {
        test("qwer");
        test1(23);//传参是一个int类型的数据
        test1("abcdsef");//字符串类型的数据
        test1(false);//布尔类型数据
        String string = test2("aa");
        System.out.println(string);
        int a = test2(34);
        System.out.println(a);
        //System.out.println(true + false);
        test4();
    }
    public static void test (String str) {
        System.out.println(str);
    }
    //带有泛型的方法  无返回值 有参数的方法
    //在static和void中间必须写这个声明了当前的方法是带有泛型的方法
    //参数就可以直接使用当前泛型了
    //这种写法到底有什么好处？具有普适性 
    //如果不用泛型的话，上面调用这个方法的时候，最起码得写三个方法
    //现在使用了泛型以后，只需要写一个方法即可
    //这个T只是一个占位，通过你传参类型来决定的。就不用再写方法的重载了，很nice啊
    public static void test1 (T t) {
        System.out.println(t);
    }
    //有参数 有返回值的方法
    //因为参数是和返回值保持一致的，所以需要使用当前的参数
    //用来返回一些数据，从这个地方可以发现一些问题，咱们泛型方法
    //的时候，是有局限性的
    public static T test2(T t) {
        return t;
    }
//    public static T test2(T t, T t1) {
//    //t + t1我现在不确定是什么类型的数据,int string double float  但是博哦了按不行
//        return t + t1;
//    }
//    public static T test2 (T t, T t1) {
//        return t && t1;
//    }
    public static T test3 (T t1, T t2, T t3) {
        System.out.println(t1);
        System.out.println(t2);
        System.out.println(t3);
        //使用运算符对两个泛型进行操作的时候是不行的
        //System.out.println(t1 + t2 + t3);
        //语法格式，如果你不按照这种写法是错误的
        return t3;
    }
    //无参数 无返回值的方法  想象有没有意义？  无意义的
    public static void test4 () {
        System.out.println("xixida");
    }
    //有返回值无参数的方法，想想有没有意义? 也是没有任何意义的
    public static T test5() {
        return null;
    }
    //总结：
    

    
}

 语法格式：

 class 类名<无意义的占位符>  {
 属性
方法（带有泛型的）
 }

【注意事项】：

            1.在泛型类中，成员方法不用带  因为一旦带了，这个方法约束的数据和当前类约束的就不一样了

            2.在泛型类中，带有泛型的静态方法和类的泛型没有关系

package com.qfedu.a_fanxing;

//带有泛型的类
class Dog {
    //属性可以不写，泛型是不影响咱们的属性的
    //成员方法
    //1.能不能写普通的成员方法？ 能
    public void eat () {
        System.out.println("狗吃狗粮");
    }
    //2.能不能写带有泛型的方法？能
    //这种写法 方法的参数和上面类的泛型有关系吗？没有
    //这种写法是没有必要，起不到一个约束的作用
    //类要求的泛型是啥，就必须给我传个啥
//    public void draw(T t) {//狗在画画
//        System.out.println(t);
//    }
    //以后记住，在泛型类中书写泛型方法的时候  不写，
    //当前方法可以直接使用类中的泛型进行约束
    public  void draw(T t) {//狗在画画
        System.out.println(t);
    }
    //能不能写静态的方法？能，但是无意义。属于自娱自乐
    //静态方法的泛型和当前类定一的泛型没有半毛线关系 为啥？
    //和上面的 没有关系的
    public static void testStatic (E e) {
        System.out.println(e);
    }
}
public class Demo3 {
    public static void main(String[] args) {
//        Dog dog = new Dog();
//        dog.eat();
        //这个一旦这样写的话  draw（T t） 这个方法必须传的值是STring类型的
        Dog dog = new Dog();
        dog.draw("画画");
        
        //dog.draw(12);//不能写int类型的数据，在newDog 的时候
    }

}

语法格式：

 interface 接口名字 {

 } 

package com.qfedu.a_fanxing;

interface A {
    //成员方法 抽象方法
    public  void test (T t);//有参数 没有返回值的
    public T test1(T t);//有参数 有返回值
    //大家知道我为啥不写没有参数的方法吗？
    
    
}
//要写一个类去实现当前的接口
//接口带有泛型,那么它的实现类必须带有泛型
//而且带有的泛型是和接口保持一致
class TestA implements A {

    @Override
    public void test(T t) {
        // TODO Auto-generated method stub
        System.out.println(t);
    }

    @Override
    public T test1(T t) {
        // TODO Auto-generated method stub
        return t;
    }
    
}
public class Demo4 {
    public static void main(String[] args) {
        //int 的包装类  Integer
        //boolean的包装类 Boolean
        //double的包装类 Double
        //char包装类  Character
        TestA testA = new TestA(); 
        testA.test(12);
        testA.test1(45);
    }

}

 语法格式

abstract 类名<无意义的占位符> {
     
}

package com.qfedu.a_fanxing;

abstract class B {
    public abstract void get(T t);
    public void getArgs(T t) {
        System.out.println(t);
    }
}
class TestB extends B {

    @Override
    public void get(T t) {
        // TODO Auto-generated method stub
        System.out.println(t);
    }
    
}
public class Demo5 {
    public static void main(String[] args) {
        TestB testB = new TestB();
        testB.get(12);
        TestB testB2 = new TestB();
        testB2.get("qwer");
    }

}