小白学习笔记（泛型）

最新推荐文章于 2025-12-02 21:20:38 发布

原创最新推荐文章于 2025-12-02 21:20:38 发布 · 141 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java #笔记 #学习

泛型只能用引用类型充当，不能使用基本数据类型

使用举例:

public class EmployeeTest {


    public static void main(String[] args) {
        Employee[] employees = new Employee[5];
        employees[1] = new Employee(19, "Jerry", new MyDate(2025, 12, 4));
        employees[2] = new Employee(20, "Mike", new MyDate(2024, 11, 2));
        employees[3] = new Employee(19, "Luci", new MyDate(2355, 5, 4));
        employees[4] = new Employee(25, "Luciy", new MyDate(1941, 5, 5));
        employees[0] = new Employee(38, "Rei", new MyDate(2014, 12, 15));

        TreeSet<Employee> treeSet = new TreeSet<Employee>();
        for (Object o : employees) {
            Employee employee = (Employee) o;
            treeSet.add(employee);
        }
        Iterator<Employee> iterator = treeSet.iterator();
        while (iterator.hasNext()) {
            Employee employee = (Employee) iterator.next();
            System.out.println(employee);
        }


    }



    //按生日顺序来排
    @Test
    public void test() {
        TreeSet<Employee> treeSet = new TreeSet<>(new Comparator<Employee>() {
            @Override
            public int compare(Employee e1, Employee e2) {
                int yearDistance = e1.getBirthday().getYear() - e2.getBirthday().getYear();
                if (yearDistance != 0) {
                    return yearDistance;
                }
                int monthDistance = e1.getBirthday().getMonth() - e2.getBirthday().getMonth();
                if (monthDistance != 0) {
                    return monthDistance;
                }
                int dayDistance = e1.getBirthday().getDay() - e2.getBirthday().getDay();
                return dayDistance;

            }
        });
        Employee[] employees1 = new Employee[5];
        employees1[1] = new Employee(19, "Jerry", new MyDate(2025, 12, 4));
        employees1[2] = new Employee(20, "Mike", new MyDate(2024, 11, 2));
        employees1[3] = new Employee(19, "Luci", new MyDate(2355, 5, 4));
        employees1[4] = new Employee(25, "Luciy", new MyDate(1941, 5, 5));
        employees1[0] = new Employee(38, "Rei", new MyDate(2014, 12, 15));

        for(int i = 0;i < employees1.length;i++) {
            treeSet.add(employees1[i]);
        }

        for (Employee employee : treeSet) {
            System.out.println(employee);
        }
    }
}

自定义泛型类，泛型方法：

代码测试:

public class Order<T> {
    //声明了类的泛型参数后，就可以在类的内部使用此泛型参数
    T t;
    int orderId;
    public Order(int orderId, T t) {
        this.orderId = orderId;
        this.t = t;
    }
    public Order() {}

    public T getT() {
        return t;
    }

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

    public int getOrderId() {
        return orderId;
    }

    public void setOrderId(int orderId) {
        this.orderId = orderId;
    }
}

public class OrderTest {
    @Test
    public void test(){
        //实例化时，就可以指明类的泛型参数的类型
        Order order = new Order();
        Object obj  = order.getT();

        //泛型参数在指明时，是不可以使用基本数据类型的，但是可以使用包装类代替基本数据类型
        Order<Integer> order2 = new  Order<>();
        Integer T = order2.getT();
        Order<String> order3 = new  Order<>();
        order3.setT("AA");


    }

    //测试Order的子类
    @Test
    public void test2(){
        //实例化SubOrder1
        SubOrder1 subOrder1 = new SubOrder1();
        Object obj  = subOrder1.getT();

        //SubOrder1<Integer> sub2 = new SubOrder1<>();这样写就报错，因为SubOrder1不是泛型类
    }
    @Test
    public void test3(){
        SubOrder2 subOrder2 = new SubOrder2();
        Integer integer = subOrder2.getT();//这个时候的类型只能是Integer，因为继承时，父类的类型已经指定了是Integer
    }
    @Test
    public void test4(){
        SubOrder3<String> subOrder3 = new SubOrder3<>();
        String t = subOrder3.getT();//此时就确定类型为String类型
        subOrder3.show("aa");

    }
    @Test
    public void test5(){
        SubOrder4<String> sub4 = new SubOrder4<>();
        Integer t = sub4.getT();//getT得到的是父类的类型
        String e = sub4.getE();//getE得到的就是子类自己的类型
    }


    @Test
    public void test6(){
        SubOrder5<String,Integer> subOrder5 = new SubOrder5();
        String t = subOrder5.getT();//此时就得到的是父类中的类型
        Integer e = subOrder5.getE();//这个得到的是子类中的类型
    }
}

继承类：

package corn.atguigu02.selfdefine.exer1;

/**
 * ClassName:SubOrder
 * Package:corn.atguigu02.selfdefine.exer1
 * Description:
 *
 * @Author 妄汐霜
 * @Create 2025/11/29 19:17
 * @Version 1.0
 */

//子类是不是泛型类就看它带不带尖括号，有尖括号就是泛型类，没有就不是泛型类

public class SubOrder1 extends Order{

}

package corn.atguigu02.selfdefine.exer1;

/**
 * ClassName:SubOrder2
 * Package:corn.atguigu02.selfdefine.exer1
 * Description:
 *SubOrder2不是泛型类
 * @Author 妄汐霜
 * @Create 2025/11/29 19:22
 * @Version 1.0
 */
public class SubOrder2 extends Order<Integer> {
}

package corn.atguigu02.selfdefine.exer1;

/**
 * ClassName:SubOrder3
 * Package:corn.atguigu02.selfdefine.exer1
 * Description:
 *
 * @Author 妄汐霜
 * @Create 2025/11/29 19:27
 * @Version 1.0
 */
public class SubOrder3<T> extends Order<T>{
    public void show(T t){
        System.out.println(t);
    }
}

package corn.atguigu02.selfdefine.exer1;

/**
 * ClassName:SubOrder4
 * Package:corn.atguigu02.selfdefine.exer1
 * Description:
 *此时的SubOrder是泛型类
 * @Author 妄汐霜
 * @Create 2025/11/29 19:31
 * @Version 1.0
 */
//这样的声明方式就表示继承的父类类型已经确定是Integer，从父类继承过来的方法就是Integer类型，但是子类自己还有不确定的类型
public class SubOrder4<E> extends Order<Integer>{
    E e;
    public SubOrder4(E e) {}

    public SubOrder4() {}
    public SubOrder4(int orderId, Integer integer, E e) {
        super(orderId, integer);
        this.e = e;
    }

    public E getE() {
        return e;
    }

    public void setE(E e) {
        this.e = e;
    }
}

package corn.atguigu02.selfdefine.exer1;

/**
 * ClassName:SubOrder5
 * Package:corn.atguigu02.selfdefine.exer1
 * Description:
 *
 * @Author 妄汐霜
 * @Create 2025/11/29 19:45
 * @Version 1.0
 */
public class SubOrder5<T,E> extends Order<T>{
    //这种声明方式就是父类不清楚的类型，继承时还是不清楚，此外，子类自己也有不清楚的类型
    E e;
    public SubOrder5(){}

    public SubOrder5(int orderId, T t, E e) {
        super(orderId, t);
        this.e = e;
    }

    public SubOrder5(E e) {
        this.e = e;
    }

    public E getE() {
        return e;
    }

    public void setE(E e) {
        this.e = e;
    }
}

自定义泛型方法：

举例：

public class Method {
    public <T> T method(T t){
        System.out.println(t);
        return t;
    }
    //不能在静态方法中使用类的泛型
//    public static void method(){
//        System.out.println("t: "  + t);
//    }



    //定义泛型方法，将E[]数组元素添加到对应的ArrayList中，并返回、
    public <E> ArrayList<E> copyFromArrayTolist(E[] array){
        ArrayList<E> list = new ArrayList<>();
        for(E e:array){
            list.add(e);
        }
        return list;
    }

}

测试：

public class MethodTest {
    @Test
    public void test(){
        Method method = new Method();
        Integer[] arr = new  Integer[]{1,2,3,4,5};
        ArrayList<Integer> list =method.copyFromArrayTolist(arr);
        System.out.println(list);
    }
}

练习：

DAO类：

public class DAO<T> {
    Map<String, T> map = new HashMap();

    public void save(String id, T entity) {
        map.put(id, entity);
    }

    public T get(String id) {
        return map.get(id);
    }

    public void update(String id, T entity) {
        if (map.containsKey(id)) {
            map.put(id, entity);
        }
    }

    public List<T> list() {
        Collection<T> values = map.values();
        ArrayList<T> list = new ArrayList<>();
        list.addAll(values);


        return list;
}

public void delete(String id) {
    map.remove(id);
}



}

User类：

public class User {
    private int id;
    private String name;
    private int age;
    public User(int id, String name, int age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }
    public User(){};

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public boolean equals(Object o) {
        if (o == null || getClass() != o.getClass()) return false;
        User user = (User) o;
        return id == user.id && age == user.age && Objects.equals(name, user.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(id, name, age);
    }

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

测试：

public class DAOTest {
    public static void main(String[] args) {
        DAO<User> dao  = new DAO<>();
        dao.save("1001",new User(123,"妄汐霜",19));
        dao.save("1002",new User(2,"妄竹",209));
        dao.update("1002",new User(3,"奈",12));
        dao.delete("1002");

        List<User> list = dao.list();
        for(User u:list){
            System.out.println(u);
        }

    }
}

Student类：

public class Student<T> {
    private String name;
    private T score;

    public Student() {}

    public Student(String name, T score) {
        this.name = name;
        this.score = score;
    }

    public String getName() {
        return name;
    }

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

    public T getScore() {
        return score;
    }

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

    @Override
    public boolean equals(Object o) {
        if (o == null || getClass() != o.getClass()) return false;
        Student<?> student = (Student<?>) o;
        return Objects.equals(name, student.name) && Objects.equals(score, student.score);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, score);
    }

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

测试：

public class StudentTest {
    public static void main(String[] args) {
        Student<String> s = new  Student<>("妄汐霜","优秀");
        Student<Double> s1 = new Student<>("妄竹",99.5);
        Student<Character> s2 = new Student<>("妄攸",'A');


        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s);
    }
}

public class GenericTest {
    @Test
    public void test1() {
        Object obj = null;
        String str = "AA";
        obj = str;//基于继承性的多态的体现


        //2.
        Object[] arr = null;
        String[] strs = null;
        arr = strs;//基于继承性的多态的体现
    }
    @Test
    public void test2() {
        ArrayList<String> list = null;
        ArrayList<Object> list2 = null;

         //list2 = list;  报错，泛型的类型不同
    }

    @Test
    public void test3(){
        List<String> list = null;
        ArrayList<String> list2 = null;
        list = list2;//这个不会报错，因为泛型类型相同


    }
}

通配符：

public class GenericTest1 {
    //关于通配符？的使用

    @Test
    public void test1() {
        List<?> list = null;
        List<String> list1 = null;
        List<Object> list2 = null;
        //因为通配符的作用，所以此时可以把list1和list2赋值给lsit


        list = list1;
        list = list2;


        //同理，因为通配符的作用，list1和list2都可以调用method
        method(list1);
        method(list2);

    }

    public void method(List<?> list) {
    }

    @Test
    public void test2(){
        List<?> list = null;
        List<String> list1 = new ArrayList<>();
        list1.add("AA");

        list = list1;

        //通过list读取数据
        Object o = list.get(0);
        System.out.println(o);

        //通过list添加数据，会报错
        //list.add("BB");//报错，类型不确定
        System.out.println(list);

    }
}