05.java面向对象-泛型

发布时间：2024年01月11日

05. java面向对象-泛型

01. 泛型引入

1. 看一个需求

请编写程序，在ArrayList中，添加3个Dog对象
Dog对象含有name 和 age ，并输出name和age（要求使用getXxx()）
先使用传统方式来解决 – 引出泛型

import java.util.ArrayList;

@SuppressWarnings("all")
public class Generic01 {
    public static void main(String[] args) {
        //使用传统方式来解决
        ArrayList list = new ArrayList();
        list.add(new Dog("旺财", 10));
        list.add(new Dog("发财", 1));
        list.add(new Dog("小黄", 2));

        //假如我们程序员，不小心添加了一只猫
        list.add(new Cat("招财猫", 8));

        //遍历
        for (Object obj : list) {
            //向下转型
            Dog dog = (Dog) obj;
            System.out.println(dog.getName() + "-" + dog.getAge());
        }

    }
}
class Dog {
    private String name;
    private int age;

    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }

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

    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;
    }
}
class Cat { //Cat类
    private String name;
    private int age;

    public Cat(String name, int age) {
        this.name = name;
        this.age = age;
    }

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

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

代码中我们添加了三个Dog类型，但是也添加了Cat类型。编译器无法发现，运行后会出现异常ClassCastException

2. 使用传统方法的问题解析

不能对假如到集合 ArrayList中的数据类型进行约束（不安全）
遍历的时候，需要进行类型转换，如果结合中的数据量过大，对效率有影响

3. 用泛型来解决前面的问题

import java.util.ArrayList;

/**
 * 02. 用泛型解决问题
 **/
@SuppressWarnings("all")
public class Generic02 {
    public static void main(String[] args) {
        //使用泛型来解决问题
        //1. 当我们 ArrayList<Dog> 表示存放到 ArrayList 集合中的元素是Dog类型
        //2. 如果编译器发现添加的类型，不满足要求，就会报错
        //3. 在遍历时，可以直接取出Dog类型而不是 Object
        ArrayList<Dog> list = new ArrayList<Dog>();
        list.add(new Dog("旺财", 10));
        list.add(new Dog("发财", 1));
        list.add(new Dog("小黄", 2));

//        list.add(new Cat("招财猫", 8)); //加入不进去
        //使用泛型
        for (Dog dog : list) {
            System.out.println(dog.getName() + "-" + dog.getAge());
        }
    }
}
class Dog {
    private String name;
    private int age;

    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }

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

    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;
    }
}
class Cat { //Cat类
    private String name;
    private int age;

    public Cat(String name, int age) {
        this.name = name;
        this.age = age;
    }

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

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

02. 泛型的理解和好处

1. 泛型的好处

编译时，检查添加元素类型，提高了安全性
减少了类型转换的次数，提高效率
1. 不使用泛型 Dog - 加入 -> Object - 取出 -> Dog//放入到ArrayList 会先转成 Object，在取出时，还需要转换成Dog
2. Dog -> Dog ->Dog//放入时，和取出时，不需要类型转换，提高效率
3. 不再提示编译警告

2. 泛型介绍

泛型又称参数化类型，是jdk5.0 出现的新特性，解决数据类型的安全性问题
在类声明或实例化时只要指定好需要的具体类型即可
java 泛型可以保证如果程序在编译时没有发出警告，运行时就不会产生ClassCastException异常，同时，代码更加简洁、健壮
泛型的作用是：可以在类声明时通过一个标识表示类中某个属性的类型，或者是某个方法的返回值类型，或者是参数类型。

public class Generic03 {
    public static void main(String[] args) {
        //注意：特别强调：E具体的数据类型在定义Person对象的时候指定，即在编译期间，就确定E是什么类型
        Person<String> yzj = new Person<>("yzj");
        yzj.show();
        /*
        可以这样理解：上面的这个Person类
        class Person{
            String s;//E 表示 s 的数据类型，该数据类型在定义Person对象的时候指定，即在编译几件，就确定E是什么类型

            public Person(String s) {//E也可以是参数类型
                this.s = s;
            }
            public String f() {//返回类型也可以是 E
                return s;
            }
        }
         */
        Person<Integer> integerPerson = new Person<>(21);
        integerPerson.show();
        /*
        可以这样理解：上面的这个Person类
        class Person{
            Integer s;//E 表示 s 的数据类型，该数据类型在定义Person对象的时候指定，即在编译几件，就确定E是什么类型

            public Person(Integer s) {//E也可以是参数类型
                this.s = s;
            }
            public Integer f() {//返回类型也可以是 E
                return s;
            }
        }
         */
    }
}

//泛型的作用是：可以在类声明时通过一个标识表示类中某个属性的类型，
// 或者是某个方法的返回值类型，或者是类型参数。
class Person<E> {
    E s;//E 表示 s 的数据类型，该数据类型在定义Person对象的时候指定，即在编译几件，就确定E是什么类型

    public Person(E s) {//E也可以是参数类型
        this.s = s;
    }
    public E f() {//返回类型也可以是 E
        return s;
    }
    public void show() {
        System.out.println(s.getClass());//显示s的运行类型
    }
}

3. 泛型的语法

1. 泛型的声明

interface 接口 <T> {} 和 class 类 <K, V> {}
//比如：List, ArrayList

说明：

其中，T,K,V不代表值，而是表示类型
任意字母都可以。常用T表示，是Type的缩写

2. 泛型的实例化

要在类名后面指定类型参数的值（类型）。如：

List<String> strList = new ArrayList<String>();
iterator<Customer> iterator = customers.iterator():

3. 泛型使用举例

创建三个学生对象
放入到HashSet中学生对象，使用
放入到HashMap中，要求 Key 是 String name，Value 就是学生对象
使用两种方式遍历

import java.util.*;
@SuppressWarnings("all")
public class TestGeneric01 {
    public static void main(String[] args) {
        //使用泛型的方式给HashSet放入三个学生对象
        HashSet<Student> students = new HashSet<>();
        students.add(new Student("jack", 18));
        students.add(new Student("tom", 18));
        students.add(new Student("jack", 18));

        //遍历
        for (Student student : students) {
            System.out.println(student);
        }
        Iterator<Student> iterator = students.iterator();
        while (iterator.hasNext()) {
            Student next = iterator.next();
            System.out.println(next);
        }

        //使用泛型的方式给HashMap 放入3个学生对象
        HashMap<String, Student> hm = new HashMap<>();
        hm.put("tom",new Student("tom", 28));
        hm.put("smith",new Student("smith", 48));
        hm.put("hsp",new Student("hsp", 28));

        //迭代器遍历
        /*
            public Set<Map.Entry<K,V>> entrySet() {
                Set<Map.Entry<K,V>> es;
                return (es = entrySet) == null ? (entrySet = new EntrySet()) : es;
            }
         */
        Set<Map.Entry<String, Student>> entries = hm.entrySet();
        /*
         public final Iterator<Map.Entry<K,V>> iterator() {
                return new EntryIterator();
            }
         */
        System.out.println("===============================");
        Iterator<Map.Entry<String, Student>> iterator1 = entries.iterator();
        while (iterator1.hasNext()) {
            Map.Entry<String, Student> next = iterator1.next();
            System.out.println(next.getKey() + "-" + next.getValue());
        }

    }
}

/**
 * 1. 创建三个学生对象
 * 2. 放入到HashSet中学生对象，使用
 * 3. 放入到HashMap中，要求 Key 是 String name，Value 就是学生对象
 * 4. 使用两种方式遍历
 */
class Student {
    private String name;
    private int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    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 String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

4. 泛型使用的注意事项和细节

interface List<T> {} , public class HashSet<E>… 等等
说明：T, E 只能是引用类型
看看下面语句是否正确？
List<Integer> list = new ArrayList<Integer>();
List<int> list2 = new ArrayList<int>();
第二个是错误的：它没有满足引用类型的条件
在给泛型指定具体类型后，可以传入该类型或者其子类类型
泛型的使用形式
List<Integer> list1 = new ArrayList<Integer>();
List<Integer> list2 = new ArrayList<>();
如果我们这样写 List list3 = new ArrayList(); 默认给它的泛型是[<E> E就是 Object]

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

/**
 * 05. 泛型细节
 **/
@SuppressWarnings("all")
public class GenericDetail {
    public static void main(String[] args) {
        //1. 给泛型指向数据类型，要求是引用类型，不是能是基本数据类型
        ArrayList<Integer> integers = new ArrayList<>();
//        ArrayList<int> ints = new ArrayList<int>();//错误的

        //2. 在给泛型指定具体类型后，可以传入该类型或者其子类类型
        //  因为 E 指定了 A 类型 ，构造器传入了 new(A)
        Pig<A> aPig = new Pig<A>(new A());
        aPig.show();
        Pig<A> aPig1 = new Pig<A>(new B());
        aPig1.show();

        //3. 泛型的使用形式
        ArrayList<Integer> list1 = new ArrayList<Integer>();
        List<Integer> list2 = new ArrayList<Integer>();
        //在实际开发中，我们往往简写
        //编译器会进行类型推断，推荐
        ArrayList<Object> list3 = new ArrayList<>();
        List<Integer> list4 = new ArrayList<>();
        ArrayList<Pig> pigs = new ArrayList<>();

        //4. 如果是这样写 泛型默认是 Object
        ArrayList list = new ArrayList();//等价 ArrayList<Object> list = new ArrayList<>();
        list.add("xx");
        /*
            public boolean add(Object e) {
                ensureCapacityInternal(size + 1);  // Increments modCount!!
                elementData[size++] = e;
                return true;
            }
         */
        Tiger tiger = new Tiger();
        /*
        等价于
        class Tiger {
            Object e;
            public Tiger() {

            }
            public Tiger(Object e) {
                this.e = e;
            }
        }
         */

    }
}
class A {}
class B extends A{}
class Tiger<E> {
    E e;
    public Tiger() {

    }
    public Tiger(E e) {
        this.e = e;
    }
}
class Pig<E> {
    E e;

    public Pig(E e) {
        this.e = e;
    }
    public void show() {
        System.out.println(getClass());
    }
}

03. 自定义泛型

1. 基本语法

class 类名 <T, R…> { //也可以是接口，…表示可以有多个泛型
成员
}

2. 注意细节

普通成员可以使用泛型（属性、方法）
使用泛型的数组，不能初始化
静态方法中不能使用类的泛型
泛型类的类型，是在创建对象时确定的（因为创建对象时，需要指定确定的类型）
如果在创建对象时，没有指定类型，默认为Object

package com.yzjedu.customgeneric_;

/**
 * 01. 自定义泛型
 **/
public class CustomGeneric01 {
    public static void main(String[] args) {

    }
}
//解读
//1. Tiger 后面泛型，所以我们把Tiger 就称为自定义泛型类
//2. T, R, M 泛型的标识符，一般是单个大写字母
//3. 泛型标识符可以有多个。
//4. 普通成员可以使用泛型（属性、方法）
//5. 使用泛型的数组，不能初始化
//6. 静态方法中不能使用类的泛型

class Tiger<T, R, M> {
    String name;
    R r;
    M m;
    T t;
    //    5.错误：因为数组在new 不能确定确定T的类型，就无法在内存开辟空间
//    T[] ts = new T[8];

    //6. 错误，一位静态是和类相关的，在类加载的时，对象还没有创建
    //所以，如果静态方法和静态属性使用了泛型，JVM无法完成初始化
//    public static void  m1(M m) {
//
//    }


    public Tiger(String name, R r, M m, T t) { //构造器使用泛型
        this.name = name;
        this.r = r;
        this.m = m;
        this.t = t;
    }

    public String getName() {
        return name;
    }

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

    public R getR() {
        return r;
    }

    public void setR(R r) { //方法使用到泛型
        this.r = r;
    }

    public M getM() {//返回类型可以使用泛型
        return m;
    }

    public void setM(M m) {
        this.m = m;
    }

    public T getT() {
        return t;
    }

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

04. 自定义泛型方法

1. 语法

修饰符 <T, R> 返回类型方法名(参数列表 ){
}

2. 注意细节

泛型方法，可以定义在普通类中，也可以定在泛型类中
当方法被调用时，类型会确定
public void eat (E e) {}, 修饰符后没有<T, T…> eat 方法不是泛型方法，而是使用了泛型

import java.util.ArrayList;


public class CustomMethodGeneric {
    public static void main(String[] args) {
        //2. 当方法被调用时，类型会确定
        Car car = new Car();
        car.fly("宝马", 100);//当调用方法时，传入参数，编译器就会确定类型
        car.fly("300", 100.1);//当调用方法时，传入参数，编译器就会确定类型
        //4. 测试
        //  1. T - String  R - ArrayList
        Fish<String, ArrayList> fish = new Fish<>();
        fish.hello(new ArrayList(), 11.3f);

    }
}
//1. 泛型方法，可以定义在普通类中，也可以定在泛型类中
class Car { //普通类
    public void run() {//普通方法

    }
    public <T, R> void fly(T t, R r) { //泛型方法
        //说明泛型方法
        //1. <T, R> 就是泛型
        //2. 是提供给fly使用的
        System.out.println(t.getClass());
        System.out.println(r.getClass());
    }
}
class Fish<T, R> { //泛型类
    public void run(){//普通方法

    }
    public<U,M> void eat(U u, M m) { //泛型方法

    }
    //4. 说明：
    //  1. 下面是hi方法不是泛型方法
    //  2. 是hi方法使用了类声明的泛型
     public void hi(T t) {

        }
        //4. 泛型方法，可以使用类声明的泛型，也可以使用自己声明的泛型
    public<K> void hello(R r, K k) {
        System.out.println(r.getClass() + " " + k. getClass());
    }
}

05. 泛型的继承和通配符

1. 泛型的继承和通配符说明

泛型不具备继承性
List<Object> list = new ArrayList<String>();//对吗？
<?>: 支持任意类型的泛型
<? extends A>: 支持A类以及A类的子类, 规定了泛型的上限
<? super>: 支持A类以及A类的父类, 不限于直接父类,规定了泛型的下限

2. 应用案例

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

/**
 * 03. Generic的通配符和继承
 **/
public class GenericExtends {
    public static void main(String[] args) {
        Object o = new String("xx");

        //1. 泛型没有继承性
//        List<Object> list = new ArrayList<String>(); 错误的

        //举例说明下面三个方法的使用
        ArrayList<Object> list1= new ArrayList<>();
        ArrayList<String> list2= new ArrayList<>();
        ArrayList<AA> list3= new ArrayList<>();
        ArrayList<BB> list4= new ArrayList<>();
        ArrayList<CC> list5= new ArrayList<>();
        //如果是 List<?> c, 可以接收任意的泛型类型
        printCollection1(list1);
        printCollection1(list2);
        printCollection1(list3);
        printCollection1(list4);
        printCollection1(list5);
        
        //List<? extends AA> c 表示上限，可以接受 AA或者AA子类
//        printCollection2(list1); ×
//        printCollection2(list2); ×
        printCollection2(list3);
        printCollection2(list4);
        printCollection2(list5);
        
        //List<? super> 子类类名 AA:支持 AA 类以及 AA 类的父类，不限于直接父类，
        printCollection3(list1);
//        printCollection3(list2); ×
        printCollection3(list3);
//        printCollection3(list4); ×
//        printCollection3(list5); ×
    }

    //2. 编写几个方法
    //说明：List<?> 表示任意的泛型类型可以接受
    public static void printCollection1(List<?> c) {
        for (Object object : c) {
            System.out.println(object);
        }
    }

    //3. ? extends AA 表示上限，可以接受 AA或者AA子类
    public static void printCollection2(List<? extends AA> c) {
        for (Object object : c) {
            System.out.println(object);
        }
    }
    //4. List<? super> 子类类名 AA:支持 AA 类以及 AA 类的父类，不限于直接父类，
    //规定了泛型的下限
    public static void printCollection3(List<? super AA> c) {
        for (Object object : c) {
            System.out.println(object);
        }
    }
}
class AA {

}

class BB extends AA {

}

class CC extends BB {

}

06. JUnit

1. 为什么需要Junit

一个类有很多功能代码需要测试，为了测试，就需要写入到main方法中
如果有多个功能代码测试，就需要来回注销, 切换很麻烦
如果可以直接运行一个方法, 就方便很多, 并且可以给出相关信息, 就好了 -> JUnit

2. 基本介绍

JUnit是一个Java语言的单元测试框架
多数Java开发环境都已经集成了JUnit作为单元测试的工具

3. JUnit加入方式

JUnit有很多种加入方式，这里我只讲解最常见的加入方式
1. 假如你写了两个方法分别是m1和m2
2. 你可以在方法前加上@Test
3. 第一次加入@Test 需要alt＋ Enter快捷键引入 JUnit5.4
4. 等待下载完成即可

import org.junit.jupiter.api.Test;

public class JUnit_ {
    public static void main(String[] args) {
        //传统方式
        new JUnit_().m1();
    }

    @Test
    public void m1() {
        System.out.println("m1方法被调用");
    }
    @Test
    public void m2() {
        System.out.println("m2方法被调用");
    }
}

文章来源:https://blog.csdn.net/m0_54915265/article/details/135444018
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若内容造成侵权/违法违规/事实不符，请联系我的编程经验分享网邮箱：chenni525@qq.com进行投诉反馈，一经查实，立即删除！