JavaSE——泛型

时间：2024-10-17 07:13:33

目录

一、泛型的引入

二、泛型的好处

三、泛型介绍

四、泛型的语法

(一)泛型的声明

(二)泛型的实例化

五、泛型使用的注意事项和细节

六、泛型练习题1

七、自定义泛型

(一)自定义泛型类

(二)自定义泛型接口

(三)自定义泛型方法

八、泛型练习题2

九、泛型的继承和通配符

一、泛型的引入

使用传统的集合添加数据的时候，有以下几点弊端：

  1. 不能对加入到集合ArrayList中的数据类型进行约束(不安全)
  2. 遍历的时候，需要进行类型转换，如果集合中的数据量较大，对效率有影响

二、泛型的好处

1.编译时，检查添加元素的类型，提高了安全性

2.减少了类型转换的次数，提高效率

  • 不使用泛型

Dog-加入->Object-取出->Dog        放入到ArrayList中会先转成Object，在取出时，还需要转换成Dog

  • 使用泛型

Dog->Dog->Dog        放入和取出时，不需要类型转换，提高效率

3.不再提示编译警告 

public class Generic01 {
    public static void main(String[] args) {
        // 做一个泛型约束
        ArrayList<Dog> arrayList = new ArrayList<Dog>();
        arrayList.add(new Dog("aa", 1));
        arrayList.add(new Dog("bb", 2));
        arrayList.add(new Dog("cc", 3));

        // 使用泛型遍历，不需要向下转型
        for (Dog dog : arrayList) {
            System.out.println(dog);
        }
    }
}

class Dog {
    private String name;
    private int age;

    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

三、泛型介绍

泛型是一种表示数据类型的数据类型。

  1. 泛型又称参数化类型，是JDK5出现的新特性，解决数据类型的安全性问题
  2. 在类声明或实例化时只要指定好需要的具体的类型即可
  3. Java泛型可以保证如果程序在编译时没有发出警告，运行时就不会产生ClassCastException异常。同时，代码更加简洁、健壮
  4. 泛型的作业是：可以在类声明时通过一个标识，表示类中某个属性的类型，或者是方法的返回值的类型，或者是参数类型。
  5. 注意，特别强调： E具体的数据类型，在定义Person对象的时候指定，即在编译期间，就确定E是什么类型。 
public class Generic03 {
    public static void main(String[] args) {
        Person<String> person = new Person<String>("韩顺平教育");
        person.show(); //String

        /*
            可以这样理解：上面的Person类
            class Person {
                String s ;// E表示 s的数据类型, 该数据类型在定义Person对象的时候指定,即在编译期间，就确定E是什么类型

                public Person(String s) {//E也可以是参数类型
                    this.s = s;
                }

                public String f() {//返回类型使用E
                    return s;
                }
            }
         */

        Person<Integer> person2 = new Person<Integer>(100);
        person2.show();//Integer

        /*
            class Person {
                Integer s ;//E表示 s的数据类型, 该数据类型在定义Person对象的时候指定,即在编译期间，就确定E是什么类型

                public Person(Integer s) {//E也可以是参数类型
                    this.s = s;
                }

                public Integer f() {//返回类型使用E
                    return s;
                }
            }
         */
    }
}

// 泛型的作用是：可以在类声明时通过一个标识表示类中某个属性的类型，
// 或者是某个方法的返回值的类型，或者是参数类型
class Person<E> {
    E s; // E表示 s的数据类型, 该数据类型在定义Person对象的时候指定,即在编译期间，就确定E是什么类型

    public Person(E s) { // E也可以是参数类型
        this.s = s;
    }

    public E f() {//返回类型使用E
        return s;
    }

    public void show() {
        System.out.println(s.getClass()); // 显示s的运行类型
    }
}

四、泛型的语法

(一)泛型的声明

interface接口<T>{} 和 class类<K,V>{}        比如：List，ArrayList

说明：1)其中，T、K、V不代表值，而是表示类型

           2)任意字母都可以。常用T表示，是Type的缩写

(二)泛型的实例化

要在类名后面指定类型参数的值(类型)。如：

List<String> strList = new ArrayList<String>();
Iterator<Customer> iterator = customers.iterator();

        创建3个学生对象，放入到HashSet中使用，放入到HashMap中使用，要求Key是 String name，Value 就是学生对象，使用两种方式遍历。

代码实现：

@SuppressWarnings({"all"})
public class GenericExercise {
    public static void main(String[] args) {
        // 使用泛型方式给HashSet 放入3个学生对象
        HashSet<Student> students = new HashSet<Student>();
        students.add(new Student("jack", 18));
        students.add(new Student("tom", 28));
        students.add(new Student("mary", 19));

        // 增强for遍历
        for (Student student : students) {
            System.out.println(student);
        }
        
        System.out.println("--------------------------");
        // 使用泛型方式给HashMap 放入3个学生对象
        // K -> String V->Student
        HashMap<String, Student> hm = new HashMap<String, Student>();
        /*
            public class HashMap<K,V>  {}
         */
        hm.put("milan", new Student("milan", 38));
        hm.put("smith", new Student("smith", 48));
        hm.put("tom", new Student("tom", 28));

        // 迭代器遍历
        Set<Map.Entry<String, Student>> entrySet = hm.entrySet();
        Iterator<Map.Entry<String, Student>> iterator = entrySet.iterator();
        while (iterator.hasNext()) {
            Map.Entry<String, Student> next = iterator.next();
            System.out.println(next.getKey() + "-" + next.getValue());
        }
    }
}

class Student {
    private String name;
    private int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

五、泛型使用的注意事项和细节

  1. 泛型类型只能是引用数据类型，不可以设置基本数据类型 
    List<Integer> list = new ArrayList<Integer>(); //OK
// List<int> list2 = new ArrayList<int>();//错误
  2. 在指定泛型具体类型后，可以传入该类型或其子类类型 
    Pig<A> aPig = new Pig<A>(new A());
aPig.f();
// class com.testdemo.generic.A

Pig<A> aPig2 = new Pig<A>(new B());
aPig2.f();
// class com.testdemo.generic.B


class A {}
class B extends A {}

class Pig<E> {
    E e;
    public Pig(E e) {
        this.e = e;
    }
    public void f() {
        System.out.println(e.getClass()); // 运行类型
    }
}
  3. 泛型使用形式可以简化 
    ArrayList<Integer> list3 = new ArrayList<>();
List<Integer> list4 = new ArrayList<>();
ArrayList<Pig> pigs = new ArrayList<>();

  4. 不写泛型默认是 Object类型

    ArrayList arrayList = new ArrayList();
// 等价于 ArrayList<Object> arrayList = new ArrayList<Object>();

六、泛型练习题1

代码实现：

MyDate类：

public class MyDate implements Comparable<MyDate> {
    private int year;
    private int month;
    private int day;

    @Override
    public String toString() {
        return "MyDate{" +
                "year=" + year +
                ", month=" + month +
                ", day=" + day +
                '}';
    }

    public int getYear() {
        return year;
    }

    public void setYear(int year) {
        this.year = year;
    }

    public int getMonth() {
        return month;
    }

    public void setMonth(int month) {
        this.month = month;
    }

    public int getDay() {
        return day;
    }

    public void setDay(int day) {
        this.day = day;
    }

    public MyDate(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }

    /**
     * 比较brithday
     * @param o the object to be compared.
     * @return
     */
    @Override
    public int compareTo(MyDate o) {
        // 比较生日
        int yearMinus = year - o.getYear();
        if (yearMinus != 0) {
            return yearMinus;
        }
        int monthMinus = month - o.getMonth();
        if (monthMinus != 0) {
            return monthMinus;
        }
        return day - o.getDay();
    }
}

Employee类：

public class Employee {
    private String name;
    private double sal;
    private MyDate birthday;

    @Override
    public String toString() {
        return "Employee{" +
                "name='" + name + '\'' +
                ", sal=" + sal +
                ", birthday=" + birthday +
                '}';
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getSal() {
        return sal;
    }

    public void setSal(double sal) {
        this.sal = sal;
    }

    public MyDate getBirthday() {
        return birthday;
    }

    public void setBirthday(MyDate birthday) {
        this.birthday = birthday;
    }

    public Employee(String name, double sal, MyDate birthday) {
        this.name = name;
        this.sal = sal;
        this.birthday = birthday;
    }
}

测试类：

public class GenericExercise02 {
    public static void main(String[] args) {
        ArrayList<Employee> employees = new ArrayList<>();
        Employee aa = new Employee("aa", 8000, new MyDate(1980, 2, 4));
        Employee bb = new Employee("张三", 9000, new MyDate(1999, 12, 24));
        Employee ccc = new Employee("张三", 5500, new MyDate(1999, 12, 18));

        employees.add(aa);
        employees.add(bb);
        employees.add(ccc);
        System.out.println("----------排序后：----------");
        for (Employee employee : employees) {
            System.out.println(employee);
        }

        // 排序
        employees.sort(new Comparator<Employee>() {
            @Override
            public int compare(Employee o1, Employee o2) {
                if (!(o1 instanceof Employee && o2 instanceof Employee)) {
                    System.out.println("类型不正确...");
                    return 0;
                }
                // 比较name
                int i = o1.getName().length() - o2.getName().length();
                if (i != 0) {
                    return i;
                }
                return o1.getBirthday().compareTo(o2.getBirthday());
            }
        });
        System.out.println("----------排序后：----------");
        for (Employee employee : employees) {
            System.out.println(employee);
        }
    }
}

运行结果：

七、自定义泛型

(一)自定义泛型类

基本语法：

class 类名<T,R...>{ // ...表示多个
    成员
}

注意细节：

  1. 普通成员可以使用泛型 (属性、方法)

  2. 使用泛型的数组，不能初始化

  3. 静态方法中不能使用类的泛型

  4. 泛型类的类型，是在创建对象时确定的(因为创建对象时，需要指定确定类型)

  5. 如果在创建对象时，没有指定类型，默认为Object

代码示例：

public class CustomGeneric_ {
    public static void main(String[] args) {
        // T=Double, R=String, M=Integer
        Tiger<Double, String, Integer> g = new Tiger<>("john");
        g.setT(10.9); // OK
        // g.setT("yy"); // 错误，类型不对
        System.out.println(g);
        // Tiger{name='john', r=null, m=null, t=10.9, ts=null}

        Tiger g2 = new Tiger("john~~"); // OK T=Object R=Object M=Object
        g2.setT("yy"); // OK ,因为 T=Object "yy"=String 是Object子类
        System.out.println("g2=" + g2);
        // g2=Tiger{name='john~~', r=null, m=null, t=yy, ts=null}
    }
}

// 1. Tiger 后面定义泛型，所以Tiger 就称为自定义泛型类
// 2. T, R, M 泛型的标识符, 一般是单个大写字母
// 3. 泛型标识符可以有多个
class Tiger<T, R, M> {
    String name;
    R r; // 属性使用到泛型
    M m;
    T t;
    // 因为数组在new 不能确定T的类型，就无法在内存开空间，不能new泛型数组
    T[] ts;

    public Tiger(String name) {
        this.name = name;
    }

    public Tiger(R r, M m, T t) { // 构造器使用泛型
        this.r = r;
        this.m = m;
        this.t = t;
    }

    public Tiger(String name, R r, M m, T t) { // 构造器使用泛型
        this.name = name;
        this.r = r;
        this.m = m;
        this.t = t;
    }

    // 因为静态是和类相关的，在类加载时，对象还没有创建
    // 所以，如果静态方法和静态属性使用了泛型，JVM就无法完成初始化
//    static R r2;
//    public static void m1(M m) {
//
//    }

    // 方法使用泛型
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public R getR() {
        return r;
    }

    public void setR(R r) { // 方法使用到泛型
        this.r = r;
    }

    public M getM() { // 返回类型可以使用泛型
        return m;
    }

    public void setM(M m) {
        this.m = m;
    }

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }

    @Override
    public String toString() {
        return "Tiger{" +
                "name='" + name + '\'' +
                ", r=" + r +
                ", m=" + m +
                ", t=" + t +
                ", ts=" + Arrays.toString(ts) +
                '}';
    }
}

(二)自定义泛型接口

基本语法：

interface 接口名<T,R...>{
}

注意细节：

  1. 接口中，静态成员也不能使用泛型(和泛型类规定相同)
  2. 泛型接口的类型，在继承接口或实现接口时确定
  3. 没有指定类型，默认为Object 

代码示例：

public class CustomInterfaceGeneric {
    public static void main(String[] args) {
    }
}
// 在继承接口 指定泛型接口的类型
interface IA extends IUsb<String, Double> {}

// 当我们去实现IA接口时，因为IA在继承IUsu 接口时，指定了U 为String R为Double
// 在实现IUsu接口的方法时，使用String替换U, 是Double替换R
class AA implements IA {
    @Override
    public Double get(String s) {
        return null;
    }

    @Override
    public void hi(Double aDouble) {}

    @Override
    public void run(Double r1, Double r2, String u1, String u2) {}
}

// 实现接口时，直接指定泛型接口的类型
// 给U 指定Integer 给 R 指定了 Float
// 所以，当我们实现IUsb方法时，会使用Integer替换U, 使用Float替换R
class BB implements IUsb<Integer, Float> {

    @Override
    public Float get(Integer integer) {
        return null;
    }

    @Override
    public void hi(Float aFloat) {}

    @Override
    public void run(Float r1, Float r2, Integer u1, Integer u2) {}
}

// 没有指定类型，默认为Object，建议直接写成 IUsb<Object,Object>
class CC implements IUsb { // 等价于 class CC implements IUsb<Object,Object> {
    @Override
    public Object get(Object o) {
        return null;
    }

    @Override
    public void hi(Object o) {}

    @Override
    public void run(Object r1, Object r2, Object u1, Object u2) {}
}

interface IUsb<U, R> {
    int n = 10;
    // U name; 不能这样使用

    // 普通方法中，可以使用接口泛型
    R get(U u);

    void hi(R r);

    void run(R r1, R r2, U u1, U u2);

    // 在jdk8 中，可以在接口中，使用默认方法, 也是可以使用泛型
    default R method(U u) {
        return null;
    }
}

(三)自定义泛型方法

基本语法：

修饰符 <T,R...> 返回类型 方法名(参数列表){
}

注意细节：

  1. 泛型方法，可以定义在普通类中，也可以定义在泛型类中
  2. 当泛型方法被调用时，类型会确定
  3. 修饰符后没有泛型，那么该方法就不是泛型方法，而是使用了泛型

代码示例：

public class CustomMethodGeneric {
    public static void main(String[] args) {
        Car car = new Car();
        car.fly("宝马", 100);// 当调用方法时，传入参数，编译器，就会确定类型
        // class java.lang.String
        // class java.lang.Integer
        System.out.println("=======");
        car.fly(300, 100.1);// 当调用方法时，传入参数，编译器，就会确定类型
        // class java.lang.Integer
        // class java.lang.Double
        
        // 测试
        // T->String, R-> ArrayList
        Fish<String, ArrayList> fish = new Fish<>();
        fish.hello(new ArrayList(), 11.3f);
        // class java.util.ArrayList
        // class java.lang.Float
    }
}

// 泛型方法，可以定义在普通类中, 也可以定义在泛型类中
class Car { // 普通类

    //普通方法
    public void run() {}

    // 说明 泛型方法
    // 1. <T,R> 就是泛型
    // 2. 是提供给 fly使用的
    public <T, R> void fly(T t, R r) { // 泛型方法
        System.out.println(t.getClass()); // String
        System.out.println(r.getClass()); // Integer
    }
}

class Fish<T, R> { // 泛型类

    //普通方法
    public void run() {}

    //泛型方法
    public <U, M> void eat(U u, M m) {}

    // 说明:
    // 1. 下面hi方法不是泛型方法
    // 2. 是hi方法使用了类声明的 泛型
    public void hi(T t) {}

    // 泛型方法，可以使用类声明的泛型，也可以使用自己声明泛型
    public <K> void hello(R r, K k) {
        System.out.println(r.getClass());//ArrayList
        System.out.println(k.getClass());//Float
    }
}

八、泛型练习题2

public class CustomMethodGenericExercise {
    public static void main(String[] args) {
        // T->String, R->Integer, M->Double
        Apple<String, Integer, Double> apple = new Apple<>();
        apple.fly(10); // 10 会被自动装箱 Integer10, 输出Integer
        apple.fly(new Dog()); // Dog
    }
}

class Apple<T, R, M> { // 自定义泛型类
    public <E> void fly(E e) {  // 泛型方法
        System.out.println(e.getClass().getSimpleName()); // 只显示类名：Integer
    }

    // public void eat(U u) {} // 错误，因为U没有声明
    public void run(M m) {} // ok
}
class Dog {}

九、泛型的继承和通配符

  1. 泛型不具备继承性 
    // List<Object> list = new ArrayList<String>(); // 错误写法，编译报错
  2. <?>：支持任意类型泛型
  3. <? extends A>：支持A类以及A类的子类，规定了泛型的上限
  4. <? super A>：支持A类以及A类的父类，不限于直接父类，规定了泛型的下限

代码示例：

public class GenericExtends {
    public static void main(String[] args) {
        Object o = new String("xx");

        // 泛型没有继承性
        // List<Object> list = new ArrayList<String>();

        //举例说明下面三个方法的使用
        List<Object> list1 = new ArrayList<>();
        List<String> list2 = new ArrayList<>();
        List<AA> list3 = new ArrayList<>();
        List<BB> list4 = new ArrayList<>();
        List<CC> list5 = new ArrayList<>();

        //如果是 List<?> c ，可以接受任意的泛型类型
        printCollection1(list1);
        printCollection1(list2);
        printCollection1(list3);
        printCollection1(list4);
        printCollection1(list5);

        //List<? extends AA> c： 表示 上限，可以接受 AA或者AA子类
//        printCollection2(list1);//×
//        printCollection2(list2);//×
        printCollection2(list3);//√
        printCollection2(list4);//√
        printCollection2(list5);//√

        //List<? super AA> c: 支持AA类以及AA类的父类，不限于直接父类
        printCollection3(list1);//√
        //printCollection3(list2);//×
        printCollection3(list3);//√
        //printCollection3(list4);//×
        //printCollection3(list5);//×
    }

    // ? extends AA 表示 上限，可以接受 AA或者AA子类
    public static void printCollection2(List<? extends AA> c) {
        for (Object object : c) {
            System.out.println(object);
        }
    }

    // 说明: List<?> 表示 任意的泛型类型都可以接受
    public static void printCollection1(List<?> c) {
        for (Object object : c) { // 通配符，取出时，就是Object
            System.out.println(object);
        }
    }
    
    // ? super 子类类名AA:支持AA类以及AA类的父类，不限于直接父类，
    // 规定了泛型的下限
    public static void printCollection3(List<? super AA> c) {
        for (Object object : c) {
            System.out.println(object);
        }
    }
}

class AA {}
class BB extends AA {}
class CC extends BB {}

相关文章