进入泛型的世界

原创已于 2024-05-12 17:12:20 修改 · 307 阅读

3 ·

CC 4.0 BY-SA版权

文章标签：

#java #android #开发语言

于 2024-05-11 23:44:27 首次发布

泛型的理解和好处

泛型的好处

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

泛型的介绍

泛型：广泛类型

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

public class Generic01 {
    public static void main(String[] args) {
        //注意：E 具体的数据类型在定义Person对象时指定（即在编译期间），就确定E是什么类型
        Person<Integer> integerPerson = new Person<>(1);//E的数据类型是Integer
        integerPerson.show();
    }
}
//泛型的作用：可以在类声明时通过一个标识表示类中某个属性的类型、某个方法的返回值类型 或 参数类型
class Person<E>{
    E S;//E表示s的数据类型，该数据类型在定义Person对象的时候指定，即在编译期间，就确定E是什么类型

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

结果
在这里插入图片描述

泛型的语法

泛型的声明

interface 接口{} 和 class类<K,V>{}
1，其中 T K V 不代表值，而是表示类型
2，任意字母都可以，常用T表示，是Type的缩写

泛型的实例化

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

1，List strList = new ArrayList();
2，Iterator iterator = customers.iterator();

泛型使用实例

在这里插入图片描述

public class GenericExercise {
    public static void main(String[] args) {
        //使用泛型方式给HashSet放入三个学生对象，遍历时可以直接调用Student1中的方法
        Set<Student1> objects = new HashSet<Student1>();
        objects.add(new Student1("jack"));//当调用add方法时，显示调用Student1 对象
        objects.add(new Student1("tom"));
        objects.add(new Student1("smith"));

        // 遍历
        for(Student1 o:objects){
            System.out.println(o.getName());
        }
        //使用泛型方式给 HashMap 放入 3 个学生对象
        //K -> String V->Student
        //一旦添加了泛型，编译器就会规范调用类型
        Map<String, Student1> map = new HashMap<String, Student1>();
        //public class HashMap<K,V> {}

        Student1 student1 = new Student1("jack");
        Student1 student2 = new Student1("tom");
        Student1 student3 = new Student1("smith");
        map.put("jack",student1);
        map.put("tom",student2);
        map.put("smith",student3);

        //遍历
        //迭代器 EntrySet
        /*
        public Set<Map.Entry<K,V>> entrySet() {
            Set<Map.Entry<K,V>> es;
             return (es = entrySet) == null ? (entrySet = new EntrySet()) : es;
        }
        */
        //1,map.entrySet();
        Set<Map.Entry<String, Student1>> entries = map.entrySet();

        /*
        public final Iterator<Map.Entry<K,V>> iterator() {
                return new EntryIterator();
        }
        */
        //2,调迭代器 entries.iterator()
        Iterator<Map.Entry<String, Student1>> iterator = entries.iterator();
        //3，先判断hasNext  下一个是否还有
        while (iterator.hasNext()) {
            Map.Entry<String, Student1> next = iterator.next();
            System.out.println(next.getKey()+"-"+next.getValue());
        }
    }
}
class Student1{
    private String name;

    public Student1(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

结果
在这里插入图片描述

泛型的注意事项

1，interface List{} public class HashSet{}
说明：T E 只能是引用类型
2，在给泛型指定具体类型后，可以传入该类型或其子类类型
3，泛型使用形式
List list1 = new ArrayList ();
List list1 = new ArrayList <>();
如果我们这样写List list1 = new ArrayList (); 默认他的泛型是 E 就是Object

public class GenericDetail {
    public static void main(String[] args) {
        //1,泛型指向的数据类型是引用类型Integer，不能是基本数据类型int
        List<Integer> list = new ArrayList<Integer>();
        //List<int> list = new ArrayList<int>();  错误

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

        //3，泛型的使用形式
        List<Integer> list1 = new ArrayList <Integer>();
        //实际开发中往往简写为：
        List<Integer> list2 = new ArrayList <>();

        //4，如果我们这样写List list1 = new ArrayList ();  默认他的泛型是 <E> E 就是Object
        List list3 = new ArrayList ();//等价 ArrayList<Object> arrayList = new ArrayList<Object>();
        
    }
}
class A{

}
class B extends A{}
class Pig<E>{
    E e;

    public Pig(E e) {
        this.e = e;
    }
    public void f(){
        System.out.println("Pig类中的f方法");
    }
}

自定义泛型

自定义泛型类

基本语法
class 类名<T,R…>{//…表示可以有多个泛型
成员}
注意细节
1，普通成员可以使用泛型（属性，方法）
2，使用泛型的数组，不能初试化
3，静态方法中不能使用类的泛型
4，泛型类的类型，是在创建对象时确定的（因为创建对象时，需要指定确定类型）
5，如果在创建对象时，没有指定类型默认为Object

public class CustomGeneric {
    public static void main(String[] args) {
        //4，泛型类的类型，是在创建对象时确定的（因为创建对象时，需要指定确定类型）
        //T=Double, R=String, M=Integer
        Tiger<Double, String, Integer> g = new Tiger<Double, String, Integer>("john");
        g.setT(10.9);//ok
        //g.setT("yy");//错误，类型不对
        System.out.println(g);
        //5，如果在创建对象时，没有指定类型默认为Object
        Tiger g2 = new Tiger("john~~~");//ok   T=Object R=Object M=Object
        //等价于  Tiger<Object,Object,Object> g2 = new Tiger<Object,Object,Object>("john~~~")
        g2.setT("yy"); //OK 因为 T=Object  "yy" = String 是 Object 子类
        System.out.println("g2="+g2);
    }
}
//T, R, M 泛型的标识符, 一般是单个大写字母,泛型标识符可以有多个
class Tiger<T,R,M>{
    String name;
    //1，普通成员可以使用泛型 (属性、方法)
    R r;//属性使用到泛型
    M m;
    T t;
//    T[] ts = new T[4];//报错，不能初试化
    //2，使用泛型的数组，不能初试化
    //因为数组在new时，便要去开辟数组的空间，但是 还现在还不能确定T的类型，就无法在内存开空间
    T[] ts;

    public Tiger(String name) {
        this.name = name;
    }

    public Tiger(String name, R r, M m, T t, T[] ts) {
        this.name = name;
        this.r = r;
        this.m = m;
        this.t = t;
        this.ts = ts;
    }

    //3，静态属性和方法中不能使用类的泛型
    //因为：静态是和类相关的，在类加载时，对象还没有创建. 但是泛型是和对象相关，但是泛型类型是在对象创建时指定
    //static R r2; 报错
//    public static void m1(M m){ 报错}

    //方法使用到泛型

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

    public T[] getTs() {
        return ts;
    }

    public void setTs(T[] ts) {
        this.ts = ts;
    }

    @Override
    public String toString() {
        return "Tiger{" +
                "name='" + name + '\'' +
                ", r=" + r +
                ", m=" + m +
                ", t=" + t +
                ", ts=" + Arrays.toString(ts) +
                '}';
    }
}

结果
在这里插入图片描述

自定义泛型接口

基本语法
interface 接口名<T,R…>{//…表示可以有多个泛型
成员}
注意细节
1，接口中，静态成员也不能使用泛型（原因同类：一般是先有类才选择是否创建对象。而静态是与类相关的，泛型是当创建对象时才会指定。）
2，泛型接口的类型，在继承接口或实现接口时确定
3，没有指定对象，默认为Object

public class CustomInterface {
    public static void main(String[] args) {

    }
}

//2,泛型接口的类型，在继承接口时确定
interface IA extends IUsb<String,Double>{

}
//2,BB在实现IUsb接口时，指定了泛型的接口类型
class BB implements IUsb<Integer, Float>{

    @Override
    public Float get(Integer integer) {
        return null;
    }

    @Override
    public void hi(Float aFloat) {

    }
}
//3,CC类，在实现IUsb接口时，因为没有指定泛型类型，，默认为<Object,Object>
class CC implements IUsb{//等价 class CC implements IUsb<Object,Object> {
    @Override
    public Object get(Object o) {
        return null;
    }

    @Override
    public void hi(Object o) {

    }
}
//AA在实现IA接口时，自动确定了U为String  R为Double；因为IA在继承IUsb时确定了接口类型，而AA有实现了IA
class AA implements IA{

    @Override
    public Double get(String s) {
        return null;
    }

    @Override
    public void hi(Double aDouble) {

    }
}

interface IUsb<U,R>{
    int n = 10;
    //U name;报错//1,接口中的属性只能是public static final 修饰的，而静态属性和方法中不能使用接口的泛型
    //普通方法，可以使用接口泛型
    R get(U u); //R表示返回值类型，U表示传入参数类型
    void hi(R r);//R表示传入参数类型

    //在 jdk8 中，可以在接口中，使用默认方法, 也是可以使用泛型
    default R method(U u) {
        return null;
    }
}

自定义泛型方法

基本语法：
修饰符<T,R…>返回类型方法名(参数列表){}
注意事项
1，泛型方法，可以定义在普通类中，也可以定义在泛型类中
2，当泛型方法被调用时，类型会确定
3，public void eat(E e){} 修饰符后没有<T,R…>eat 方法，不是泛型方法，而是使用了泛型

public class CustomMethodGeneric {
    public static void main(String[] args) {
        //T-String, R-Integer
        Car car = new Car();
        //2，当泛型方法被调用时，类型会确定
        car.fly("宝贝", 100);

        //K->String, R-> ArrayList
        Fish<String, ArrayList> fish = new Fish<>();
        fish.hello("zl",new ArrayList());
    }
}

class Car {//普通类

    //普通方法
    public void run() {
    }

    //泛型方法
    // <T,R> 就是泛型，是提供给fly使用的
    public <T, R> void fly(T t, R r) {
        System.out.println("T的类型=" + t.getClass());//String
        System.out.println("R的类型=" + r.getClass());//Integer
    }

}

class Fish<T, R> {//泛型类

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

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

    //3,hi方法不是泛型方法，只是使用了类声明的泛型
    public void hi(T t) {

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

结果
在这里插入图片描述

泛型的继承和通配符

1，泛型不具备继承性
List list = new ArrayList(); 报错
2，<?>：支持任意泛型类型
3，<？ extends A>：支持A类以及A类的子类，规定了泛型的上限
4，<? Super A>：支持A类以及A类的父类，不限于直接父类，规定了泛型的下限

public class GenericExtends {
    public static void main(String[] args) {
        //1,泛型不具备继承性
        //String类是Object的子类
        Object o = new String("xx");//可以
        //但是不能继承
//        List<Object> list = new ArrayList<String>(); 报错
        List<Object> list1 = new ArrayList<>();
        List<String> list2 = new ArrayList<>();
        List<AAA> list3 = new ArrayList<>();
        List<BBB> list4 = new ArrayList<>();
        List<CCC> list5 = new ArrayList<>();

        //2,List<?> c  可以接收任意的泛型类型
        printCollection1(list1);
        printCollection1(list2);
        printCollection1(list3);
        printCollection1(list4);
        printCollection1(list5);

        //3，<? extends A>：支持A类以及A类的子类，规定了泛型的上线
        //printCollection2(list1);//报错，会只限AAA 或者 AAA 子类
        printCollection2(list3);
        printCollection2(list4);
        printCollection2(list5);

        //4，<? Super A>：支持A类以及A类的父类， 不限于直接父类，规定了泛型的下限
        printCollection3(list1);//Object 为所有类的父类
        //printCollection3(list2);// String类 报错
        printCollection3(list3);//AAA类

    }
    //说明: List<?> 表示 任意的泛型类型都可以接受
    public static void printCollection1(List<?> c) {
        for (Object object : c) { // 通配符，取出时，就是 Object
            System.out.println(object);
        }
    }
    // ? extends AA 表示 上限，可以接受 AA 或者 AA 子类
    public static void printCollection2(List<? extends AAA> c) {
        for (Object object : c) {
            System.out.println(object);
        }
    }
    // ? super 子类类名 AA:支持 AA 类以及 AA 类的父类，不限于直接父类，
    //规定了泛型的下限
    public static void printCollection3(List<? super AAA> c) {
        for (Object object : c) {
            System.out.println(object);
        }
    }
}


class AAA {
}

class BBB extends AAA {
}

class CCC extends BBB {
}

JUnit

为什么需要JUnit

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

基本介绍

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

怎么使用

1，不用在主方法中测试
2，在想要测试的方法前加@Test 键入Ait+Enter,

public class JUnit_ {
    public static void main(String[] args) {

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