java进阶教程：2023.3.12第十四天，java进阶集合（Collection、数据结构、List、泛型深入）

前言

记录时间：2023.3.12

已坚持的第十四天

java从入门到精通

学习java时间历程记录打卡

早上6：00到 12：00

下午1：00到 7：00

完成代码练习

1.d1_collection

1.明确Collection集合体系的特点

package cn.vqqc.d1_collection;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;

/**
 目标：明确Collection集合体系的特点
 */
public class CollectionDemo1 {
    public static void main(String[] args) {
        // 有序 可重复 有索引
        Collection list = new ArrayList();
        list.add("Java");
        list.add("Java");
        list.add("Mybatis");
        list.add(23);
        list.add(23);
        list.add(false);
        list.add(false);
        System.out.println(list);

        // 无序 不重复  无索引
        Collection list1 = new HashSet();
        list1.add("Java");
        list1.add("Java");
        list1.add("Mybatis");
        list1.add(23);
        list1.add(23);
        list1.add(false);
        list1.add(false);
        System.out.println(list1);

        System.out.println("-----------------------------");
        // Collection<String> list2 = new ArrayList<String>();
        Collection<String> list2 = new ArrayList<>(); // JDK 7开始之后后面类型申明可以不写
        list2.add("Java");
        // list2.add(23);
        list2.add("try");

        // 集合和泛型不支持基本数据类型，只能支持引用数据类型
        // Collection<int> list3 = new ArrayList<>();
        Collection<Integer> list3 = new ArrayList<>();
        list3.add(23);
        list3.add(233);
        list3.add(2333);

        Collection<Double> list4 = new ArrayList<>();
        list4.add(23.4);
        list4.add(233.0);
        list4.add(233.3);
    }
}

2.d2_collection_api

package cn.vqqc.d2_collection_api;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;

/**
 目标：Collection集合的常用API
 Collection是集合的祖宗类，它的功能是全部集合都可以继承使用的，所以要学习它
 Collection API如下:
 - public boolean add(E e)：  把给定的对象添加到当前集合中
 - public void clear() :清空集合中所有的元素。
 - public boolean remove(E e): 把给定的对象在当前集合中删除。
 - public boolean contains(Object obj): 判断当前集合中是否包含给定的对象
 - public boolean isEmpty(): 判断当前集合是否为空
 - public int size(): 返回集合中元素的个数
 - public Object[] toArray(): 把集合中的元素，存储到数组中
 小结：
 记住以上API。
 */
public class CollectionDemo {
    public static void main(String[] args) {
        // HashSet:添加的元素是无序，不重复，无索引
        Collection<String> c = new ArrayList<>();
        // 1.添加元素, 添加成功返回true
        c.add("Java");
        c.add("HTML");
        System.out.println(c.add("HTML"));
        c.add("MySQL");
        c.add("Java");
        System.out.println(c.add("try"));
        System.out.println(c); // [Java, HTML, HTML, MySQL, Java, try]

        // 2.清空集合的元素
        // c.clear();
        // System.out.println(c);

        // 3.判断集合是否为空 是空返回true,反之
        // System.out.println(c.isEmpty());

        // 4.获取集合的大小
        System.out.println(c.size());

        // 5.判断集合中是否包含某个元素
        System.out.println(c.contains("Java"));  // true
        System.out.println(c.contains("java")); // false
        System.out.println(c.contains("try")); // true

        // 6.删除某个元素:如果有多个重复元素默认删除前面的第一个
        System.out.println(c.remove("java")); // false
        System.out.println(c);
        System.out.println(c.remove("Java")); // true
        System.out.println(c);

        // 7.把集合转换成数组  [HTML, HTML, MySQL, Java, try]
        Object[] arrs = c.toArray();
        System.out.println("数组：" + Arrays.toString(arrs));

        System.out.println("----------------------拓展----------------------");
        Collection<String> c1 = new ArrayList<>();
        c1.add("java1");
        c1.add("java2");
        Collection<String> c2 = new ArrayList<>();
        c2.add("赵敏");
        c2.add("殷素素");
        // addAll把c2集合的元素全部倒入到c1中去。
        c1.addAll(c2);
        System.out.println(c1);
        System.out.println(c2);
    }
}

3.d3_collection_traversal

1.集合遍历案例

package cn.vqqc.d3_collection_traversal;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

/**
 目标：Collection集合的遍历方式

 什么是遍历? 为什么开发中要遍历？
 遍历就是一个一个的把容器中的元素访问一遍
 开发中经常要统计元素的总和，找最值，找出某个数据然后干掉等等业务都需要遍历

 Collection集合的遍历方式是全部集合都可以直接使用的，所以我们学习它
 Collection集合的遍历方式有三种:
 （1）迭代器
 （2）foreach(增强for循环)
 （3）JDK 1.8开始之后的新技术Lambda表达式(了解)

 a.迭代器遍历集合
 -- 方法：
 public Iterator iterator(): 获取集合对应的迭代器，用来遍历集合中的元素的
 boolean hasNext():判断是否有下一个元素，有返回true ,反之
 E next():获取下一个元素值
 --流程：
 1.先获取当前集合的迭代器
 Iterator<String> it = lists.iterator();
 2.定义一个while循环，问一次取一次
 通过it.hasNext()询问是否有下一个元素，有就通过
 it.next()取出下一个元素
 小结：
 记住代码
 */
public class CollectionDemo01 {
    public static void main(String[] args) {
        ArrayList<String> lists = new ArrayList<>();
        lists.add("赵敏");
        lists.add("小昭");
        lists.add("素素");
        lists.add("灭绝");
        System.out.println(lists);
        // [赵敏, 小昭, 素素, 灭绝]
        //   it

        // 1、得到当前集合的迭代器对象
        Iterator<String> it = lists.iterator();
//        String ele = it.next();
//        System.out.println(ele);
//        System.out.println(it.next());
//        System.out.println(it.next());
//        System.out.println(it.next());
        // System.out.println(it.next()); // NoSuchElementException 出现无此元素异常的错误

        // 2、定义while循环
        while (it.hasNext()){
            String ele = it.next();
            System.out.println(ele);
        }
        System.out.println("-----------------------------");

    }
}

2.集合遍历案例

package cn.vqqc.d3_collection_traversal;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
/**
 目标：Collection集合的遍历方式

 什么是遍历? 为什么开发中要遍历？
 遍历就是一个一个的把容器中的元素访问一遍。
 开发中经常要统计元素的总和，找最值，找出某个数据然后干掉等等业务都需要遍历

 Collection集合的遍历方式是全部集合都可以直接使用的，所以我们学习它
 Collection集合的遍历方式有三种:
 （1）迭代器。
 （2）foreach(增强for循环)
 （3）JDK 1.8开始之后的新技术Lambda表达式

 b.foreach(增强for循环)遍历集合
 foreach是一种遍历形式，可以遍历集合或者数组
 foreach遍历集合实际上是迭代器遍历集合的简化写法
 foreach遍历的关键是记住格式：
 for(被遍历集合或者数组中元素的类型 变量名称 : 被遍历集合或者数组){

 }
 */
public class CollectionDemo02 {
    public static void main(String[] args) {
        Collection<String> lists = new ArrayList<>();
        lists.add("赵敏");
        lists.add("小昭");
        lists.add("殷素素");
        lists.add("周芷若");
        System.out.println(lists);
        // [赵敏, 小昭, 殷素素, 周芷若]
        //  ele

        for (String ele : lists) {
            System.out.println(ele);
        }

        System.out.println("------------------");
        double[] scores = {100, 99.5 , 59.5};
        for (double score : scores) {
            System.out.println(score);
//            if(score == 59.5){
//                score = 100.0; // 修改无意义，不会影响数组的元素值
//            }
        }
        System.out.println(Arrays.toString(scores));

    }
}

3.集合遍历案例

package cn.vqqc.d3_collection_traversal;

import java.util.ArrayList;
import java.util.Collection;
import java.util.function.Consumer;

/**
 目标：Collection集合的遍历方式

 什么是遍历? 为什么开发中要遍历？
 遍历就是一个一个的把容器中的元素访问一遍
 开发中经常要统计元素的总和，找最值，找出某个数据然后干掉等等业务都需要遍历

 Collection集合的遍历方式是全部集合都可以直接使用的，所以我们学习它
 Collection集合的遍历方式有三种:
 （1）迭代器。
 （2）foreach(增强for循环)。
 （3）JDK 1.8开始之后的新技术Lambda表达式
 c.JDK 1.8开始之后的新技术Lambda表达式
 */
public class CollectionDemo03 {
    public static void main(String[] args) {
        Collection<String> lists = new ArrayList<>();
        lists.add("赵敏");
        lists.add("小昭");
        lists.add("殷素素");
        lists.add("周芷若");
        System.out.println(lists);
        // [赵敏, 小昭, 殷素素, 周芷若]
        //  s
        lists.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });

//        lists.forEach(s -> {
//                System.out.println(s);
//        });

        // lists.forEach(s ->  System.out.println(s) );

        lists.forEach(System.out::println );

    }
}

4.d4_collection_object

1.定义类

package cn.vqqc.d4_collection_object;

public class Movie {
    private String name;
    private double score;
    private String actor;

    public Movie() {
    }

    public Movie(String name, double score, String actor) {
        this.name = name;
        this.score = score;
        this.actor = actor;
    }

    public String getName() {
        return name;
    }

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

    public double getScore() {
        return score;
    }

    public void setScore(double score) {
        this.score = score;
    }

    public String getActor() {
        return actor;
    }

    public void setActor(String actor) {
        this.actor = actor;
    }

    @Override
    public String toString() {
        return "Movie{" +
                "name='" + name + '\'' +
                ", score=" + score +
                ", actor='" + actor + '\'' +
                '}';
    }
}

2.定义一个集合对象存储3部电影对象

package cn.vqqc.d4_collection_object;

import java.util.ArrayList;
import java.util.Collection;

public class TestDemo {
    public static void main(String[] args) {
        // 1、定义一个电影类
        // 2、定义一个集合对象存储3部电影对象
        Collection<Movie> movies = new ArrayList<>();
        movies.add(new Movie("《你好，李焕英》", 9.5, "张小斐,贾玲,沈腾,陈赫"));
        movies.add(new Movie("《唐人街探案》", 8.5, "王宝强,刘昊然,美女"));
        movies.add(new Movie("《刺杀小说家》",8.6, "雷佳音,杨幂"));

        System.out.println(movies);

        // 3、遍历集合容器中的每个电影对象
        for (Movie movie : movies) {
            System.out.println("片名：" + movie.getName());
            System.out.println("得分：" + movie.getScore());
            System.out.println("主演：" + movie.getActor());
        }

    }
}

5.d5_collection_list

1.ArrayList集合

package cn.vqqc.d5_collection_list;

import java.util.ArrayList;
import java.util.Collection;
import java.util.LinkedList;
import java.util.List;

/**
 目标：ArrayList集合

 Collection集合的体系
 Collection<E>(接口)
 /                                                \
 Set<E>(接口)                                         List<E>(接口)
 /                  \                               /                     \                  \
 HashSet<E>(实现类)    TreeSet<E>(实现类)          LinkedList<E>(实现类)  Vector(线程安全)     ArrayList<E>(实现类)
 /
 LinkedHashSet<E>(实现类)

 Collection集合体系的特点:
 Set系列集合： 添加的元素，是无序，不重复，无索引的
 -- HashSet：添加的元素，是无序，不重复，无索引的
 -- LinkedHashSet：添加的元素，是有序，不重复，无索引的
 List系列集合：添加的元素，是有序，可重复，有索引的
 -- LinkedList： 添加的元素，是有序，可重复，有索引的
 -- ArrayList： 添加的元素，是有序，可重复，有索引的
 -- Vector 是线程安全的，速度慢，工作中很少使用

 1、List集合继承了Collection集合的全部功能，"同时因为List系列集合有索引"，
 2、因为List集合多了索引，所以多了很多按照索引操作元素的功能:
 3、ArrayList实现类集合底层基于数组存储数据的，查询快，增删慢
 - public void add(int index, E element): 将指定的元素，添加到该集合中的指定位置上
 - public E get(int index):返回集合中指定位置的元素
 - public E remove(int index): 移除列表中指定位置的元素, 返回的是被移除的元素
 - public E set(int index, E element):用指定元素替换集合中指定位置的元素,返回更新前的元素值
 小结：
 ArrayList集合的底层是基于数组存储数据。查询快，增删慢！（相对的）
 */
public class ListDemo01 {
    public static void main(String[] args) {
        // 1.创建一个ArrayList集合对象：
        // List:有序，可重复，有索引的
        ArrayList<String> list = new ArrayList<>(); // 一行经典代码！
        list.add("Java");
        list.add("Java");
        list.add("HTML");
        list.add("HTML");
        list.add("MySQL");
        list.add("MySQL");

        // 2.在某个索引位置插入元素
        list.add(2, "try");
        System.out.println(list);

        // 3.根据索引删除元素,返回被删除元素
        System.out.println(list.remove(1));
        System.out.println(list);

        // 4.根据索引获取元素:public E get(int index):返回集合中指定位置的元素
        System.out.println(list.get(1));

        // 5.修改索引位置处的元素: public E set(int index, E element)
        System.out.println(list.set(1, "try栈"));
        System.out.println(list);
    }
}

2.ArrayList集合

package cn.vqqc.d5_collection_list;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/*
    拓展：List系列集合的遍历方式有：4种

    List系列集合多了索引，所以多了一种按照索引遍历集合的for循环

    List遍历方式：
        （1）for循环(独有的，因为List有索引)
        （2）迭代器
        （3）foreach
        （4）JDK 1.8新技术
 */
public class ListDemo02 {
    public static void main(String[] args) {
        List<String> lists = new ArrayList<>();
        lists.add("java1");
        lists.add("java2");
        lists.add("java3");

        /** （1）for循环。 */
        System.out.println("-----------------------");

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


        /** （2）迭代器。 */
        System.out.println("-----------------------");
        Iterator<String> it = lists.iterator();
        while (it.hasNext()){
            String ele = it.next();
            System.out.println(ele);
        }

        /** （3）foreach */
        System.out.println("-----------------------");
        for (String ele : lists) {
            System.out.println(ele);
        }

        /** （4）JDK 1.8开始之后的Lambda表达式  */
        System.out.println("-----------------------");
        lists.forEach(s -> {
            System.out.println(s);
        });

    }
}

3.ArrayList集合

package cn.vqqc.d5_collection_list;


import java.util.LinkedList;
import java.util.List;

/**
 目标：LinkedList集合

 Collection集合的体系:
 Collection<E>(接口)
 /                                       \
 Set<E>(接口)                             List<E>(接口)
 /                                   /                    \               \
 HashSet<E>(实现类)                   LinkedList<E>(实现类) Vector(实现类)  ArrayList<E>(实现类)
 /
 LinkedHashSet<E>(实现类)

 Collection集合体系的特点:
 Set系列集合： 添加的元素，是无序，不重复，无索引的
 -- HashSet：添加的元素，是无序，不重复，无索引的
 -- LinkedHashSet：添加的元素，是有序，不重复，无索引的
 List系列集合：添加的元素，是有序，可重复，有索引的
 -- LinkedList： 添加的元素，是有序，可重复，有索引的
 -- Vector： 添加的元素，是有序，可重复，有索引的。线程安全（淘汰了）
 -- ArrayList： 添加的元素，是有序，可重复，有索引的

 LinkedList也是List的实现类：底层是基于双链表的，增删比较快，查询慢！！
 LinkedList是支持双链表，定位前后的元素是非常快的，增删首尾的元素也是最快的
 所以LinkedList除了拥有List集合的全部功能还多了很多操作首尾元素的特殊功能：
 - public void addFirst(E e):将指定元素插入此列表的开头
 - public void addLast(E e):将指定元素添加到此列表的结尾。
 - public E getFirst():返回此列表的第一个元素
 - public E getLast():返回此列表的最后一个元素
 - public E removeFirst():移除并返回此列表的第一个元素
 - public E removeLast():移除并返回此列表的最后一个元素
 - public E pop():从此列表所表示的堆栈处弹出一个元素
 - public void push(E e):将元素推入此列表所表示的堆栈

 小结：
 LinkedList是支持双链表，定位前后的元素是非常快的，增删首尾的元素也是最快的
 所以提供了很多操作首尾元素的特殊API可的实以做栈和队列现

 如果查询多而增删少用ArrayList集合。(用的最多的)
 如果查询少而增删首尾较多用LinkedList集合
 */
public class ListDemo03 {
    public static void main(String[] args) {
        // LinkedList可以完成队列结构，和栈结构 （双链表）
        // 1、做一个队列：
        LinkedList<String> queue = new LinkedList<>();
        // 入队
        queue.addLast("1号");
        queue.addLast("2号");
        queue.addLast("3号");
        System.out.println(queue);
        // 出队
        // System.out.println(queue.getFirst());
        System.out.println(queue.removeFirst());
        System.out.println(queue.removeFirst());
        System.out.println(queue);

        // 2、做一个栈
        LinkedList<String> stack = new LinkedList<>();
        // 入栈 压栈 (push)
        stack.push("第1颗子弹");
        stack.push("第2颗子弹");
        stack.push("第3颗子弹");
        stack.push("第4颗子弹");
        System.out.println(stack);

        // 出栈  弹栈 pop
        System.out.println(stack.pop());
        System.out.println(stack.pop());
        System.out.println(stack.pop());
        System.out.println(stack);

    }
}

6.d6_collection_update_delete

1.研究集合遍历并删除元素可能出现的：并发修改异常问题

package cn.vqqc.d6_collection_update_delete;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/**
 目标：研究集合遍历并删除元素可能出现的：并发修改异常问题
 */
public class Test {
    public static void main(String[] args) {
        // 1、准备数据
        ArrayList<String> list = new ArrayList<>();
        list.add("try");
        list.add("Java");
        list.add("Java");
        list.add("赵敏");
        list.add("赵敏");
        list.add("素素");
        System.out.println(list);
        // [try, Java, Java, 赵敏, 赵敏, 素素]
        //        it

        // 需求：删除全部的Java信息。
        // a、迭代器遍历删除
        Iterator<String> it = list.iterator();
//        while (it.hasNext()){
//            String ele = it.next();
//            if("Java".equals(ele)){
//                // 删除Java
//                // list.remove(ele); // 集合删除会出毛病
//                it.remove(); // 删除迭代器所在位置的元素值（没毛病）
//            }
//        }
//        System.out.println(list);

        // b、foreach遍历删除 (会出现问题，这种无法解决的，foreach不能边遍历边删除，会出bug)
//        for (String s : list) {
//            if("Java".equals(s)){
//                list.remove(s);
//            }
//        }

        // c、lambda表达式(会出现问题，这种无法解决的，Lambda遍历不能边遍历边删除，会出bug)
//        list.forEach(s -> {
//            if("Java".equals(s)){
//                list.remove(s);
//            }
//        });

        // d、for循环(边遍历边删除集合没毛病，但是必须从后面开始遍历删除才不会出现漏掉应该删除的元素)
        for (int i = list.size() - 1; i >= 0 ; i--) {
            String ele = list.get(i);
            if("Java".equals(ele)){
                list.remove(ele);
            }
        }
        System.out.println(list);
    }
}

7.d7_genericity

1.泛型的概述

package cn.vqqc.d7_genericity;

import java.util.ArrayList;
import java.util.List;

/**
 目标：泛型的概述

 什么是泛型？
 泛型就是一个标签：<数据类型>
 泛型可以在编译阶段约束只能操作某种数据类型

 注意：
 JDK 1.7开始之后后面的泛型申明可以省略不写
 小结：
 泛型就是一个标签
 泛型可以在编译阶段约束只能操作某种数据类型
 泛型只能支持引用数据类型
 */
public class GenericityDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("Java");
        list.add("Java2");
        // list.add(23);

        List<String> list1 = new ArrayList();
        list1.add("Java");
//        list1.add(23.3);
//        list1.add(false);
        list1.add("Spring");

//        for (Object o : list1) {
//            String ele = (String) o;
//            System.out.println(ele);
//        }

        for (String s : list1) {
            System.out.println(s);
        }

        System.out.println("---------------------");
        // 存储任意类型的元素
        List<Object> list2 = new ArrayList<>();
        list2.add(23);
        list2.add(23.3);
        list2.add("Java");

        // List<int> list3 = new ArrayList<>();
        List<Integer> list3 = new ArrayList<>();
    }
}

8.d8_genericity_class

1.模拟ArrayList定义一个MyArrayList

package cn.vqqc.d8_genericity_class;

import java.util.ArrayList;

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 cn.vqqc.d8_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.add("MySQL");
        list.remove("MySQL");
        System.out.println(list);

        MyArrayList<Integer> list2 = new MyArrayList<>();
        list2.add(23);
        list2.add(24);
        list2.add(25);
        list2.remove(25);
        System.out.println(list2);
    }
}

9.d9_genericity_method

1.自定义泛型方法

package cn.vqqc.d9_genericity_method;

/**
 目标：自定义泛型方法

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

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

 }
 注意：方法定义了是什么泛型变量，后面就只能用什么泛型变量。
 泛型类的核心思想：是把出现泛型变量的地方全部替换成传输的真实数据类型。

 需求：给你任何一个类型的数组，都能返回它的内容。Arrays.toString(数组)的功能！

 小结：
 泛型方法可以让方法更灵活的接收数据，可以做通用技术！
 */
public class GenericDemo {
    public static void main(String[] args) {
        String[] names = {"小璐", "蓉容", "小何"};
        printArray(names);

        Integer[] ages = {10, 20, 30};
        printArray(ages);

        Integer[] ages2 = getArr(ages);
        String[]  names2 = getArr(names);
    }

    public static <T> T[] getArr(T[] arr){
        return arr;
    }

    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);
        }
    }
}

10.d10_genericity_interface

1.定义接口

package cn.vqqc.d10_genericity_interface;


public interface Data<E> {
    void add(E e);
    void delete(int id);
    void update(E e);
    E queryById(int id);
}

2.泛型接口

package cn.vqqc.d10_genericity_interface;

/**
 目标：泛型接口

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

 }

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

 小结：
 泛型接口可以约束实现类，实现类可以在实现接口的时候传入自己操作的数据类型
 这样重写的方法都将是针对于该类型的操作。
 */
public class GenericDemo {
    public static void main(String[] args) {

    }
}

3.定义类

package cn.vqqc.d10_genericity_interface;

public class Student {
}

package cn.vqqc.d10_genericity_interface;

public class StudentData implements Data<Student>{
    @Override
    public void add(Student student) {

    }

    @Override
    public void delete(int id) {

    }

    @Override
    public void update(Student student) {

    }

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

4.定义类

package cn.vqqc.d10_genericity_interface;

public class Teacher {
}

package cn.vqqc.d10_genericity_interface;

public class TeacherData implements Data<Teacher>{
    @Override
    public void add(Teacher teacher) {

    }

    @Override
    public void delete(int id) {

    }

    @Override
    public void update(Teacher teacher) {

    }

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

11.d11_genericity_limit

1.泛型通配符 ?

package cn.vqqc.d11_genericity_limit;

import java.util.ArrayList;

/**
 目标：泛型通配符 ?

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

 注意：
 虽然BMW和BENZ都继承了Car
 但是ArrayList<BMW>和ArrayList<BENZ>与ArrayList<Car>没有关系的！!
 通配符：？
 ？可以在“使用泛型”的时候代表一切类型
 E T K V 是在定义泛型的时候使用的
 泛型的上下限：
 ？ extends Car : ?必须是Car或者其子类  泛型上限
 ? super 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());
        go(bmws);

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

        ArrayList<Dog> dogs = new ArrayList<>();
        dogs.add(new Dog());
        dogs.add(new Dog());
        dogs.add(new Dog());
        // go(dogs);
    }

    /**
     所有车比赛
     */
    public static void go(ArrayList<? extends Car> cars){
    }
}

class Dog{

}

class BENZ extends Car{
}

class BMW extends Car{
}

// 父类
class Car{
}