Java泛型通过代码进行快速理解

泛型

通过ArrayList集合了解泛型

    public class AttayListTest {
        public static void main(String[] args) {
            ArrayList arrayList1 = new ArrayList();
            //此时添加的数据为object类型
            arrayList1.add(" ");
            //如果加上泛型(泛型必须是引用类型)
            ArrayList<String> strings = new ArrayList<>();
            //此时集合只能添加字符串
            strings.add("aaa");
            //所以这里泛型起到约束集合存储类型的作用
        }
    }

泛型类

不使用泛型的Student类

    public class Student {
        private String StringNumber;
        private Integer IntegerNumber;
        public Student() {
        }
        public Student(String stringNumber, Integer integerNumber) {
            StringNumber = stringNumber;
            IntegerNumber = integerNumber;
        }
        public String getStringNumber() {return StringNumber;}
        public void setStringNumber(String stringNumber) {StringNumber = stringNumber;}
        public Integer getIntegerNumber() {return IntegerNumber;}
        public void setIntegerNumber(Integer integerNumber) {IntegerNumber = integerNumber;}
    }

使用泛型的Teacher类

    /**
     * T为任意字符，这里只是一个类型占位符。
     *在实例化 Teacher 类时指定任意类型
     */
    public class Teacher<T> {
        private T idNumber;
        public Teacher(T t) {this.idNumber = t;}
        public Teacher() {}
        public T getT() {return idNumber;}
        public void setT(T t) {this.idNumber = t;}
    }

实例化Student和Teacher进行对比泛型类

  public class Test {
        public static void main(String[] args) {
            Student student = new Student();
            //此时学生的学号只能输入字符方式
            student.setStringNumber("123456");
            //如果想用数字的方式输入学号需要重新定义一个变量和方法
            student.setIntegerNumber(123456);
    
            //如果想只一种变量能够输入两种或多种类型的就可以使用泛型类
            //1.如果想要输入字符串学号就在定义对象的时候约束为字符串
            Teacher<String> stringTeacher = new Teacher<>();
            stringTeacher.setT("123456");
            //2.如果先要输入整型学号就在定义对象的时候约束为整型
            Teacher<Integer> integerTeacher = new Teacher<>();
            integerTeacher.setT(123456);
            //3.也可以不约束，这样可以输入任意object类型
            Teacher teacher = new Teacher();
            teacher.setT("123456");
            teacher.setT(123456);
        }
    }

泛型方法

不使用泛型

    public class ShowPrint {
        public String show(String s){
            return s;
        }
        public Integer show(Integer i){
            return i;
        }
    }

使用泛型类不使用泛型方法

    public class Showp<T> {
        public T show(T t){
            return t;
        }
    }

使用泛型方法

    public class Show {
        //public<T> 返回值类型 方法名(T t)
        public<T> T show(T t){
            return t;
        }
    }

对比三种的实现

   public class Test {
        public static void main(String[] args) {
            ShowPrint showPrint = new ShowPrint();
            //1.在方法重载的时候，使用不同的参数类型就需要定义一个新的方法
            String show = showPrint.show("123456");
            Integer show1 = showPrint.show(123456);
            //那么使用泛型类能否解决呢?
            //2.1.直接使用不约束
            Showp showp = new Showp();
            //此时代码返回值类型为object类型，如果需要赋值需要强转
            Object show4 = showp.show("123456");
            //2.2.约束泛型，虽然实体类代码减少了，但是定义约束的代码多了
            Showp<String> stringShowp = new Showp<>();
            String show2 = stringShowp.show("123456");
            Showp<Integer> integerShowp = new Showp<>();
            Integer show3 = integerShowp.show(123456);
            //3.所以出现了泛型方法
            Show show5 = new Show();
            //3.1参数输入什么，程序自动进行对泛型进行约束
            String string = show5.show("123456");
            Integer integer = show5.show(123456);
        }
    }

泛型接口

  public interface PersonTest<T> {
        T show(T t);
    }

如果不约束泛型

  public class PersonTestImpl implements PersonTest{
        @Override
        public Object show(Object o) {
            return null;
        }
    }

约束泛型-普通类

    public class PersonTestImpl implements PersonTest<String>{
        @Override
        public String show(String s) {
            return null;
        }
    }

约束泛型-泛型类

    public class PersonTestImpl<T> implements PersonTest<T>{
        @Override
        public T show(T t) {
            return null;
        }
    }

泛型具有就近原则

    public interface PersonTest<T> {
        <T>T show(T t);
    }
    方法参数的T指的是泛型方法的T