泛型、自定义泛型----java进阶1

一、泛型的概念

什么是泛型？
泛型就是一个标签：<数据类型>
泛型可以在编译阶段约束只能操作某种数据类型。
注意：JDK 1.7开始之后，泛型后面的申明可以省略不写!!
泛型和集合都只能支持引用数据类型，不支持基本数据类型。（如果要使用基本数据类型，那么需要进行装箱）

二、泛型的好处

目标：泛型的好处。
泛型在编译阶段约束了操作的数据类型，从而不会出现类型转换异常。
体现的是Java的严谨性和规范性，数据类型,经常需要进行统一！

public class GenericityDemo {
   public static void main(String[] args) {
       ArrayList<String> lists = new ArrayList<>();
       lists.add("赵敏");
       lists.add("张无忌");
//        lists.add(false);
//        lists.add(99.9);

       for(int i = 0 ; i < lists.size() ; i++ ){
           String ele = lists.get(i);
           System.out.println(ele);
       }

   }
}

三、自定义泛型类

目标：自定义泛型类。

引入：
    我们之前用的泛型都是别人写好的，接下来我们来自定义泛型类使用。

泛型类的概念：
    使用了泛型定义的类就是泛型类。

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

        }
        泛型变量建议使用 E , T , K , V

需求：模拟ArrayList集合自定义一个集合MyArrayList集合。
泛型类的 **核心思想**：是把出现泛型变量的地方全部替换成传输的真实数据类型。

public class GenericDemo {
   public static void main(String[] args) {
       MyArrayList<String> lists = new MyArrayList<String>();

       MyArrayList<String> lists1 = new MyArrayList<>();
       lists1.add("java");
       lists1.add("mysql");
       lists1.remove("java");
       System.out.println(lists1);
   }
}
//自定义泛型类
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();
   }
}

四、自定义泛型方法

目标：自定义泛型方法。

什么是泛型方法？
    定义了泛型的方法就是泛型方法。

  泛型方法的定义格式:
      修饰符 <泛型变量> 返回值类型 方法名称(形参列表){

      }
      注意：方法定义了是什么泛型变量，后面就只能用什么泛型变量。

    泛型类的核心思想：是把出现泛型变量的地方全部替换成传输的真实数据类型。

需求：给你任何一个类型的数组，都能返回它的内容。

小结：
    泛型方法和泛型类可以做通用技术架构。

public class GenericDemo {
   public static void main(String[] args) {
       Integer[] nums = {10 , 20 , 30 , 40 , 50};
       String rs1  = arrToString(nums);
       System.out.println(rs1);

       String[] names = {"贾乃亮","王宝绿","陈羽凡"};
       String rs2  = arrToString(names);
       System.out.println(rs2);
   }
//自定义泛型方法
   public static <T> String arrToString(T[] nums){
       StringBuilder sb = new StringBuilder();
       sb.append("[");
       if(nums!=null && nums.length > 0){
           for(int i = 0 ; i < nums.length ; i++ ){
               T ele = nums[i];
               sb.append(i == nums.length-1 ? ele : ele+", ");
           }
       }
       sb.append("]");
       return sb.toString();
   }
}

五、自定义泛型接口

目标：泛型接口。

什么是泛型接口？
    使用了泛型定义的接口就是泛型接口。
泛型接口的格式：
    修饰符 interface 接口名称<泛型变量>{

    }

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

小结：
    泛型接口的核心思想，在实现接口的时候传入真实的数据类型
    这样重写的方法就是对该数据类型进行操作!

1.泛型接口

// 泛型接口
public interface Data<E> {
    void add(E stu);
    void delete(E stu);
    void update(E stu);
    E query(int id);
}

2.操作学生数据

// 操作学生数据
public class StudentData implements Data<Student> {
    @Override
    public void add(Student stu) {
        System.out.println("添加学生！");
    }

    @Override
    public void delete(Student stu) {
        System.out.println("删除学生！");
    }

    @Override
    public void update(Student stu) {

    }

    @Override
    public Student query(int id) {
        return null;
    }
}

3.操作教师数据

public class TeacherData implements Data<Teacher> {
    @Override
    public void add(Teacher stu) {
        System.out.println("添加老师！");
    }

    @Override
    public void delete(Teacher stu) {
        System.out.println("删除老师！");
    }

    @Override
    public void update(Teacher stu) {

    }

    @Override
    public Teacher query(int id) {
        return null;
    }
}

4.测试代码

public class GenericDemo {
    public static void main(String[] args) {
        StudentData data = new StudentData();
        data.add(new Student());
        data.delete(new Student());

        TeacherData data1 = new TeacherData();
        data1.add(new Teacher());
        data1.delete(new Teacher());
    }
}

6.泛型的通配符

目标：泛型通配符。

需求：开发一个极品飞车的游戏，所有的汽车都能一起参与比赛。

注意：
    虽然BMW和BENZ都继承了Car
    但是ArrayList<BMW>和ArrayList<BENZ>与ArrayList<Car>没有关系的！**泛型没有继承关系!**

通配符：？
    ?可以用在使用泛型的时候代表一切类型。
    E , T , K , V是在定义泛型的时候使用代表一切类型。

泛型的上下限：
    ? extends Car : 那么?必须是Car或者其子类。(泛型的上限)
    ? super  Car :那么?必须是Car或者其父类。（泛型的下限。不是很常见）
小结：
    通配符：?可以用在使用泛型的时候代表一切类型。
    ? extends Car : 那么?必须是Car或者其子类。(泛型的上限)

public class GenericDemo {
    public static void main(String[] args) {
        ArrayList<BMW> bmws = new ArrayList<>();
        bmws.add(new BMW());
        bmws.add(new BMW());
        bmws.add(new BMW());
        run(bmws);

        ArrayList<BENZ> benzs = new ArrayList<>();
        benzs.add(new BENZ());
        benzs.add(new BENZ());
        benzs.add(new BENZ());
        run(benzs);

        ArrayList<Dog> dogs = new ArrayList<>();
        dogs.add(new Dog());
        dogs.add(new Dog());
        dogs.add(new Dog());
        // run(dogs); // 就进不来了！
    }

    // 定义一个方法，可以让很多汽车一起进入参加比赛
    public static void run(ArrayList<? extends Car> cars){

    }
}

class Car{
}
class BMW extends Car{

}
class BENZ extends Car{

}
class Dog{

}