泛型

collection泛型

---

泛型的概述和优势

1. 定义类的同时定义了泛型的类就是泛型类

2. 泛型类的格式：修饰符 class 类型<泛型变量>{ }

注意泛型只能支持引用数据类型

public class MyArrayList<T>{ } 

此处泛型变量T可以随便写为任意表示，常见的如E、T、K、V等

3. 作用：编译阶段可以指定数据类型，类似于集合的作用

4. 泛型的好处

1. 统一数据类型

2. 把运行时间的问题提前到了编译期间，避免了强制类型转换可能出现的异常，因为编译阶段类型九年确定下来

5. 泛型类的核心思想：

把出现泛型变量的地方全部替换成传输的真实数据类型

6. 模拟ArrayList集合自定义一个集合MyArrayList集合，完成添加和删除功能的泛型设计即可

Test类

package com.itheima.d9_genericity_class;
​
import java.util.ArrayList;
import java.util.Arrays;
​
public class MyArrayList <E>{
    private ArrayList lists = new ArrayList();
​
    public void add(E e){
        lists.add(e);
    }
    public void remove(E e){
        lists.remove(e);
    }
​
    @Override
    public String toString() {
        return lists.toString();
    }
}
​

测试类

package com.itheima.d9_genericity_class;
​
public class Test {
    public static void main(String[] args) {
​
        //需求：模拟ArrayList定义一个MyArrayList<>();
        MyArrayList<String> list = new MyArrayList<>();
        list.add("java");
        list.add("java");
        list.remove("java");
        System.out.println(list);
        MyArrayList<Integer> list1 = new MyArrayList<>();
        list1.add(1);
        list1.add(3);
        list1.add(2);
        list1.remove(23);
        System.out.println(list1);
    }
}
​

---

---

泛型方法的概述

1. 定义方法时同时定义了泛型的方法就是泛型方法

2. 泛型方法的格式：修饰符 <泛型变量> 方法返回值 方法名称(形参列表){}

public <T> void show(T t){ }

3. 作用：方法中可以使用泛型接受一切实际类型的参数，方法更具备通用性

   ---

   课程案例导学

   给你任何一个类型的数组，都能返回它的内容，也就是实现Array.toString(数组)的功能！

   代码如下

   package com.itheima.d10_genericity_method;
   ​
   public class GenericDemo {
       public static void main(String[] args) {
           String[] name = {"赵云","吕布","刘备"};
           printArray(name);
           Integer[] ages = {13, 20, 95};
           printArray(ages);
   ​
       }
   ​
       public static <T> void printArray(T[] arr){
           if(arr != null){
               StringBuilder sb = new StringBuilder("[");
               for (int i = 0; i < arr.length; i++) {
                   sb.append(arr[i]).append(i == arr.length -1?"" : ",");
               }
               sb.append("]");
               System.out.println(sb);
           }else {
               System.out.println(arr);
           }
       }
   }
   ​

   ---

   泛型接口

   概述

   1. 使用了泛型定义的接口就是泛型接口

   2. 泛型接口的格式：修饰符 interface 接口名称<泛型变量>{}

      public interface Data<E>{}

      ---

   课程案例导学

   教务系统，提供一个接口可约束一定要完成数据（学生，老师）的增删改查操作

   泛型接口的原理

   实现类可以在实现接口的时候传入自己操作的数据类型，这样重写的方法都将是针对于该类型的操作

   Data接口

   package com.itheima.d11_genericity_interface;
   ​
   public interface Data <E>{
       void add(E e);
       void delete(E e);
       int id(int id);
       E queryId(int id);
   }

   StudentData

   package com.itheima.d11_genericity_interface;
   ​
   public class StudentData implements Data{
       @Override
       public void add(Object o) {
   ​
       }
   ​
       @Override
       public void delete(Object o) {
   ​
       }
   ​
       @Override
       public int id(int id) {
   ​
           return id;
       }
   ​
       @Override
       public Object queryId(int id) {
           return null;
       }
   }

   TeacherData

   package com.itheima.d11_genericity_interface;
   ​
   public class TeacherData implements Data<Teacher> {
   ​
       @Override
       public void add(Teacher teacher) {
   ​
       }
   ​
       @Override
       public void delete(Teacher teacher) {
   ​
       }
   ​
       @Override
       public int id(int id) {
   ​
           return id;
       }
   ​
       @Override
       public Teacher queryId(int id) {
           return null;
       }
   }

   Test类

   package com.itheima.d11_genericity_interface;
   ​
   public class GenericDemo {
       public static void main(String[] args) {
           Teacher t = new Teacher();
           t.id(123);
           System.out.println(t.id(123));
           System.out.println("-------------------------");
           Student s = new Student();
           s.add(s);
           System.out.println(s.id(123));
       }
   }

   Student类

   package com.itheima.d11_genericity_interface;
   ​
   public class Student implements Data{
       @Override
       public void add(Object o) {
   ​
       }
   ​
       @Override
       public void delete(Object o) {
   ​
       }
   ​
       @Override
       public int id(int id) {
   ​
           return id;
       }
   ​
       @Override
       public Object queryId(int id) {
           return null;
       }
   }

   Teacher类

   package com.itheima.d11_genericity_interface;
   ​
   public class Teacher implements Data{
       @Override
       public void add(Object o) {
   ​
       }
   ​
       @Override
       public void delete(Object o) {
   ​
       }
   ​
       @Override
       public int id(int id) {
   ​
           return id;
       }
   ​
       @Override
       public Object queryId(int id) {
           return null;
       }
   }

   ---

   ---

   通配符： ？

   1. ？ 可以在“使用泛型”的时候代表一切类型

   2. E T K V是在定义泛型的时候使用的

   泛型通配符：案例导学

   开发一个极品飞车的游戏，所有的骑车都能一起参与比赛

   注意:

   虽然benz和audi都继承了car但是ArrayList<benz>和ArrayList<audi>与ArrayList<car>没有关系

   package com.itheima.d12_genericity_limit;
   ​
   import java.util.ArrayList;
   ​
   public class GenericDemo {
       public static void main(String[] args) {
       ArrayList<Benz> benzs = new ArrayList<>();
       benzs.add(new Benz());
       benzs.add(new Benz());
       benzs.add(new Benz());
   ​
       ArrayList<Audi> audis = new ArrayList<>();
       audis.add(new Audi());
       audis.add(new Audi());
       audis.add(new Audi());
   ​
       ArrayList<Dog> dogs = new ArrayList<>();
       dogs.add(new Dog());
       dogs.add(new Dog());
       dogs.add(new Dog());
       }
   ​
       /**
        * 所有车比赛
        */
       public static void go(ArrayList<? extends Car> cars){
   ​
       }
   }
   class Dog{
   ​
   }
   class Benz extends Car{
   ​
   }
   class Audi extends Car{
   ​
   }
   //父类
   class Car{
   ​
   }

    

   泛型的上下限：

   1. ？ extend Car: ?必须是Car或者其子类 泛型上限

   2. ？ super Car:   ?必须是Car或者其父类 泛型下限