【无标题】

#一、泛型

#####（一）、泛型介绍

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

#####（二）、泛型的好处

1.编译时，检查添加元素的类型，提高了安全性
2.减少了类型转换的次数，提高效率
3.不再提示编译警告

#####（三）、泛型使用细节

1.interface List{}，public class HashSet{}…等等
说明：T、E只能是引用类型
2.在指定泛型具体类型后，可以传入该类型或者其子类型

package com.szhstd_.Exercise_;

import java.util.*;

public class GenericExercise01 {
    public static void main(String[] args) {
        HashSet<Student> objects = new HashSet<>();
        objects.add(new Student("苏子豪", 21));
        objects.add(new Student("韩顺平老师", 41));
        objects.add(new Student("张飞", 21));
        for (Student o : objects) {//这里Student本来应该是Object，但是因为我们指定了泛型Student，所以可以直接使用
            System.out.println(o);
        }
        System.out.println("===================HashMap==============");
        HashMap<String, Student> hashMap = new HashMap<>();
        hashMap.put("苏子豪", new Student("苏子豪", 21));
        hashMap.put("韩顺平老师", new Student("韩顺平老师", 41));
        hashMap.put("张飞", new Student("张飞", 21));
        Set<Map.Entry<String, Student>> entries = hashMap.entrySet();
        Iterator<Map.Entry<String, Student>> iterator = entries.iterator();
        while (iterator.hasNext()) {
            Map.Entry<String, Student> next = iterator.next();
            System.out.println(next);
        }
    }
}

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 +
                '}';
    }
}
输出结果：
Student{name='韩顺平老师', age=41}
Student{name='苏子豪', age=21}
Student{name='张飞', age=21}
===================HashMap==============
张飞=Student{name='张飞', age=21}
韩顺平老师=Student{name='韩顺平老师', age=41}
苏子豪=Student{name='苏子豪', age=21}

#二、自定义泛型

#####（一）、自定义泛型类

1.基本语法
class 类名<T,R>{
成员
}
2.注意细节
①普通成员可以使用泛型（属性、方法）
②使用泛型的数组，不能初始化
③静态方法中不能使用类的泛型
④泛型类的类型，是在创建对象时确定的（因为创建对象时，需要指定确定类型）
⑤如果在创建对象时，没有指定类型，默认为Object

#####（二）、自定义泛型接口

1.基本语法
interface 接口名<T,R…>{
}
2.注意细节
①接口中，静态成员也不能使用泛型
②泛型接口的类型，在继承接口或者实现接口时确定
③没有指定类型，默认为Object

#####（三）、自定义泛型方法

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

package com.szhstd_.generic_;

import java.util.ArrayList;

public class CustomMethodGeneric {
    public static void main(String[] args) {
        Car car = new Car();
        car.hello("宝马",100000);//这里会自动判断参数的类型
        Pig<Double, String> pig = new Pig<Double, String>();
        pig.hello("123",123);
        Pig<ArrayList, Float> pig1 = new Pig<>();
        pig1.run(new ArrayList<>(),"szh");//所以这里调用方法时，前面的u需要用类的泛型ArrayList，后面那个自己传
    }
}
class Car{
    public void hi(){

    }
    public <U,T> void hello(U u,T t){
    }
}
class Pig<U,T>{
    public void hi(){

    }
    public <U,T> void hello(U u,T t){
    }
    public <E> void run(U u,E e){//这里方法里面的泛型可以使用类的比如这个U，也可以使用自己的，比如E

    }
}

#三、泛型的继承和通配符

#####（一）、说明

1.泛型不具备继承性
2.<?>:支持任意泛型类型
3.<? extends A>:支持A类以及A类的子类，规定了泛型的上限
3.<? super A>:支持A类以及A类的父类，不限于直接父类，规定了泛型的下限

package com.szhstd_.generic_;

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

public class GenericExtends {
    public static void main(String[] args) {
        ArrayList<Object> list1= new ArrayList<>();
        ArrayList<String> list2 = new ArrayList<>();
        ArrayList<SS> list3 = new ArrayList<>();
        ArrayList<BB> list4 = new ArrayList<>();
        ArrayList<CC> list5 = new ArrayList<>();
        f1(list1);
        f1(list2);
        f1(list3);
        f1(list4);
        f1(list5);
        System.out.println("==================");
        //f2(list1); 这两个不是SS的子类型
        //f2(list2);
        f2(list3);
        f2(list4);
        f2(list5);
        System.out.println("==================");
        f3(list1);
        //f3(list2);这三个不是SS以及SS的父类类型
        f3(list3);
        //f3(list4);
        //f3(list5);
    }
    //方法一
    public static void f1(List<?> c){//表示可以接收所有类型

    }
    //方法二
    public static void f2(List<?extends SS> c){//可以接收SS以及SS的子类类型

    }
    //方法三
    public static void f3(List<?super SS> c){//可以接收SS以及SS的父类类型

    }
}
class SS{

}
class BB extends SS{

}
class CC extends BB{

}

#四、JUnit

#####（一）、基本介绍

1.JUnit是一个Java语言的单元测试框架
2.可以直接运行方法进行测试，不需要在主方法中运行

package com.szhstd_.junit_;

import org.junit.jupiter.api.Test;

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

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