Java 入门 36 泛型深入 泛型的概述和优势 自定义泛型类 自定义泛型方法 自定义泛型接口 泛型通配符 上下限

package com.itheima.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<>();
    }
}

 

 

 MyArrayList类(自定义泛型类)

package com.ITheima.Collection;

import java.util.ArrayList;

public class MyArrayList<E> {
    //目前没学过数据库 先用Arraylist模拟
    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 "MyArrayList{" +
                "lists=" + lists +
                '}';
    }
}

Test类

package com.ITheima.Collection;

public class Test8 {
    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);

    }
}

自定义泛型方法

package com.ITheima.Collection;

import java.util.Arrays;
import java.util.Iterator;

/**
 * 目标：自定义泛型方法。
 * <p>
 * 什么是泛型方法？
 * 定义了泛型的方法就是泛型方法。
 * <p>
 * 泛型方法的定义格式:
 * 修饰符 <泛型变量> 返回值类型 方法名称(形参列表){
 * <p>
 * }
 * 注意：方法定义了是什么泛型变量，后面就只能用什么泛型变量。
 * 泛型类的核心思想：是把出现泛型变量的地方全部替换成传输的真实数据类型。
 * <p>
 * 需求：给你任何一个类型的数组，都能返回它的内容。Arrays.toString(数组)的功能！
 * <p>
 * 小结：
 * 泛型方法可以让方法更灵活的接收数据，可以做通用技术！
 */
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);

    }

    /**
     * 修饰符 <泛型变量> 返回值类型 方法名称(形参列表){
     * <p>
     * }
     */

    public static <T> T[] getArr(T[] arr){
        System.out.println(Arrays.toString(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]+(i==arr.length-1?"":","));
            }
            sb.append("]");
            System.out.println(sb);
        }else{
            System.out.println(arr);
        }
    }
}

自定义泛型接口

Data 自定义泛型接口

package com.ITheima.genericity_interface;

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

StudentData 实现Data接口

package com.ITheima.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 quaryByid(int id) {
        return null;
    }
}

TeacherData 实现Data接口

package com.ITheima.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 quaryByid(int id) {
        return null;
    }
}

Student类

package com.ITheima.genericity_interface;

public class Student {
}

Teacher类

package com.ITheima.genericity_interface;

public class Teacher {
}

泛型通配符 上下限

package com.ITheima.genericity_interface;


import java.util.ArrayList;

/**
 * 目标：泛型通配符。?
 * <p>
 * 需求：开发一个极品飞车的游戏，所有的汽车都能一起参与比赛。
 * <p>
 * 注意：
 * 虽然BMW和BENZ都继承了Car
 * 但是ArrayList<BMW>和ArrayList<BENZ>与ArrayList<Car>没有关系的！!
 * 通配符：？
 * ？可以在“使用泛型”的时候代表一切类型。
 * E T K V 是在定义泛型的时候使用的。
 * 泛型的上下限：
 * ？ extends Car : ?必须是Car或者其子类  泛型上限
 * ? super Car ：？必须是Car或者其父类   泛型下限
 * 小结：
 * 通配符：？
 * ？可以在“使用泛型”的时候代表一切类型。
 */
public class Car {
    public static void main(String[] args) {
        ArrayList<BMW> bows = new ArrayList<>();
        bows.add(new BMW());
        bows.add(new BMW());
        bows.add(new BMW());
        bows.add(new BMW());
        go(bows);

        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> Car) {

    }
}

class Dog {

}

class BMW extends Car {

}

class BENZ extends Car {

}