Java-泛型

Neo丶

已于 2023-03-20 19:39:56 修改

阅读量412

点赞数

文章标签： java 学习 jvm

于 2022-09-06 21:16:17 首次发布

本文链接：https://blog.csdn.net/Ego_Ekko/article/details/126703457

版权

泛型的引出

测试代码

package com.pero.generic;

import java.util.ArrayList;

/**
 * 在ArrayList中添加3个Dog对象
 * Dog对象含有name和age，并输出name和age
 *
 * @author Pero
 * @version 1.0
 */
@SuppressWarnings({"all"})

public class Test {
    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList();
        arrayList.add(new Dog("小灰", 2));
        arrayList.add(new Dog("小白", 3));
        arrayList.add(new Dog("小黑", 5));
        arrayList.add(new Cat("小花",4));

        for (Object object : arrayList) {
            Dog dog = (Dog) object;  //遇到Cat类的小花时，报错ClassCastException
            System.out.println(dog);
        }

    }
}

class Dog {
    private String name;
    private int age;

    public Dog(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 "Dog{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
class Cat {
    private String name;
    private int age;

    public Cat(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 "Dog{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

问题分析

1）不能对加入集合的数据类型进行约束，不安全！

2）便利的时候需要对类型转换，如果集合中的数据量比较大，会影响效率；

使用泛型的好处

1）编译时，检查添加元素的类型提高安全性；

2）减少了类型转换提高效率；

不使用泛型时：Dog -加入-> Object -取出-> Dog;添加进ArrayList中会先转成Object，取出时需要转成Dog，才能调用Dog的方法；

使用泛型时：Dog -加入-> Dog -取出-> Dog;存放和取出都是Dog，不需要在转型。

3）不再提示编译警告；

添加泛型之后代码

package com.pero.improve;

import java.util.ArrayList;

/**
 * @author Pero
 * @version 1.0
 */
public class Generic_ {
    public static void main(String[] args) {

        //ArrayList<Dog>表示存放到ArrayList集合集合中的元素时Dog类型
        //编译器如果发现存放的类型不满足条件就会报错
        //在遍历时，直接取出Dog类型，而不是Object类型
        ArrayList<Dog> arrayList = new ArrayList<Dog>();
        arrayList.add(new Dog("小灰", 2));
        arrayList.add(new Dog("小白", 3));
        arrayList.add(new Dog("小黑", 5));
        //arrayList.add(new Cat("小花",4));  //编译器发现存放的类型不满足条件，报错
        for (Dog dog :arrayList) {
            System.out.println(dog.getName()+dog.getAge());
        }

    }
}

基本介绍

1）泛型又称为参数化类型，是jdk5.0出现的新特性，解决数据类型的安全问题；

2）在类声明或实例化时指定需要的具体类型；

3）Java泛型可以保证如果程序在编译时没有发出警告，则运行时就不会产生；

4）泛型的作用是：可以在类声明时通过一个标识表示类中某个属性的类型，或者是某个方法的返回值的类型，或者是参数类型。

package com.pero.generic;

import java.util.Objects;

/**
 * @author Pero
 * @version 1.0
 */
@SuppressWarnings({"all"})

public class Generic01 {
    public static void main(String[] args) {
        Person<String, Integer> person = new Person<String, Integer>("jack",28);
        //new Person<String,Integer>(100,30);   //此时就会报错，在编译时就已经明确了参数的类型规定
        person.show();  //class java.lang.String
    }

}

//在类声明时定义泛型，通过一个标识符表示类中某个属性的类型，
// 创建Person对象时确定泛型类型（比如Person<String,Integer>，
// String类型替换了Person类的E,Integer类型替换了Person类的T），
// 在编译期间就确定E的类型！
class Person<E,T>{
    E name;      //规范name的类型，在创建对象时明确类型
    T age;      //规范age的类型，在创建对象时明确类型

    public Person(E name, T age) {
        this.name = name;
        this.age = age;
    }

    public void show(){
        System.out.println(name.getClass());
    }

    public E getName() {
        return name;
    }

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

    public T getAge() {
        return age;
    }

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

    public E e(){
        return name;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person<?, ?> person = (Person<?, ?>) o;
        return Objects.equals(name, person.name) && Objects.equals(age, person.age);
    }

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

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

泛型的声明

interface 接口<T>{}和class 类<K,V>{}
例如：List，ArrayList
说明：
1）其中K，T，V并不代表值，而是表示类型；
2）任意字母都可以作为泛型的表示，通常用T（Type）。
3）要在类名后面指定类型参数的值（类型）：
①List<String> strList = new ArrayList<String>();
②Iterator<Customer> iterator = customer.iterator();

package com.pero.generic;

import java.util.*;

/**
 * 创建三个学生对象
 * 放到HashMap中，要求Key是String name，Value就是学生对象
 * 使用两种方式遍历
 *
 * @author Pero
 * @version 1.0
 */


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

        //3个学生对象
        Student<String> jack = new Student<String>("jack");
        Student<String> tom = new Student<String>("tom");
        Student<String> lucy = new Student<String>("lucy");

        //HashMap
        HashMap<String, Student> hashMap = new HashMap<String, Student>();

        hashMap.put("jack", jack);
        hashMap.put("tom", tom);
        hashMap.put("lucy", lucy);

        //先取出EntrySet
        /*
        public Set<Map.Entry<K（替换成String）,V（替换成Person）>> entrySet() {
            Set<Map.Entry<K,V>> es;
            return (es = entrySet) == null ? (entrySet = new EntrySet()) : es;
        }
        */
        Set<Map.Entry<String, Student>> entries = hashMap.entrySet();
        //迭代器遍历
        /*  //EntrySet类是HashMap的内部类
        final class EntrySet extends AbstractSet<Map.Entry<K,V>> {
            //entries.iterator()会调用该方法，<K（替换成String）,V（替换成Person）>
            public final Iterator<Map.Entry<K,V>> iterator() {
                return new EntryIterator();
            }
        }
        */
        Iterator<Map.Entry<String, Student>> iterator_ = entries.iterator();
        while (iterator_.hasNext()) {
            Map.Entry<String, Student> entry = iterator_.next();
            System.out.println(entry.getKey() + "-" + entry.getValue());
        }

        //遍历增强for遍历
        for (Object object : entries) {
            Map.Entry entry = (Map.Entry) object;
            System.out.println(entry.getKey() + "-" + entry.getValue());
        }

        //HashSet
        HashSet<Student> students = new HashSet<Student>();
        students.add(jack);
        students.add(tom);
        students.add(lucy);
        //迭代器遍历
        Iterator<Student> iterator = students.iterator();
        while (iterator.hasNext()) {
            Student student = iterator.next();
            System.out.println(student);
        }
        //增强for遍历
        for (Student student : students) {
            System.out.println(student);
        }


    }
}

class Student<T> {
    private T name;

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

    public T getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "Student:" + name;
    }
}

泛型使用细节

1）interface List <T>{}，public class HashSet<E>{}...等

T，E只能是引用类型，不能是基本数据类型

2）在指定泛型具体类型后，可以传入该类型或者其子类类型

3）泛型使用形式：

①List<Integer> list1 = new ArrayList<Integer>();

②List<Integer> list2 = new ArrayList<>();

4)List list3 = new ArrayList();默认泛型<E>是Object;

package com.pero.generic;

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

/**
 * @author Pero
 * @version 1.0
 */
public class GenericDetail {
    public static void main(String[] args) {

        //给泛型指定数据类型时，要求是引用类型不能是基本数据类型
        List<Integer> list = new ArrayList<Integer>();
        //List<int> list1 = new ArrayList<int>();  //编译报错

        //在指定泛型具体类型后，可以传入该类型或者其子类类型
        List<Animal> animals = new ArrayList<Animal>();
        animals.add(new Animal());  //可以添加泛型规定的类型
        animals.add(new Tiger());   //可以添加泛型规定类型的子类型
        //animals.add(new Persons());   //不能添加

        //泛型使用形式
        List<Integer> list1 = new ArrayList<Integer>();
        ArrayList<Integer> integers = new ArrayList<Integer>();
        //简写(日常使用，编译器会进行类型推断)
        ArrayList<Integer> integers1 = new ArrayList<>();
        List<Integer> list2 = new ArrayList<>();

        //默认泛型是Object
        ArrayList arrayList = new ArrayList();
        //等价于ArrayList<Object> arrayList = new ArrayList<Object>();
        Persons persons = new Persons();
        /*  上面的对象创建，相当于其类如下：
        class Persons{
            Object name;
            public Persons(){};
            public Persons(Object name){
                this.name = name;
            }
        }
        */

    }
}
class Animal {}
class Tiger extends Animal{}

class Persons<E>{
    E name;
    public Persons(){};
    
    public Persons(E name){
        this.name = name;
    }
}

练习代码

package com.pero.generic;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.Iterator;

/**
 * 定义Employee类
 * 1）该类包含：private成员变量name、salary、birthday，其中birthday为MyData类的对象；
 * 2）为每一个属性定义getter和setter方法；
 * 3）重写toString方法，输出name、salary、birthday；
 * 4）MyDate类包含：private成员变量month，day，year；并为每一个属性定义getter和setter方法；
 * 5）创建该类的3个对象，并把这些对象放入ArrayList集合中（ArrayList需要用泛型定义），
 * 对集合中的元素进行排序，并遍历输出（排序方法：调用ArrayList的sort()方法，传入Comparator对象【使用泛型】），
 * 先按照name排序，如果name相同，则按照生日日期排序。
 *
 * @author Pero
 * @version 1.0
 */
@SuppressWarnings({"all"})

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

        Employee jack = new Employee("jack", 2300, new MyDate(1995, 12, 1));
        Employee tom = new Employee("tom", 3300, new MyDate(1996, 1, 20));
        Employee lucy = new Employee("lucy", 4300, new MyDate(1997, 1, 28));

        ArrayList<Employee> employees = new ArrayList<Employee>();
        employees.add(jack);
        employees.add(tom);
        employees.add(lucy);
        employees.add(new Employee("smith",3600,new MyDate(2002,3,2)));
        employees.add(new Employee("smith",5900,new MyDate(2002,3,1)));
        employees.add(new Employee("jack",8800,new MyDate(1996,1,20)));


        employees.sort(new Comparator<Employee>() {
            @Override
            public int compare(Employee o1, Employee o2) {
                if (!(o1 instanceof Employee && o2 instanceof Employee)) {
                    System.out.println("类型不匹配");
                    return 0;
                }
                int i = o1.getName().compareTo(o2.getName());   //名字排序
                if (i != 0) {
                    return i;
                } else {
                    return o1.getMyDate().minDate(o2.getMyDate());  //调用年龄比较方法，早出生的放在前面
                }

            }
        });

        Iterator<Employee> iterator = employees.iterator();
        while (iterator.hasNext()) {
            Employee employee = iterator.next();
            System.out.println(employee);
        }

    }
}

class Employee {
    private String name;
    private double salary;
    private MyDate myDate;

    public Employee(String name, double salary, MyDate myDate) {
        this.name = name;
        this.salary = salary;
        this.myDate = myDate;
    }

    public String getName() {
        return name;
    }

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

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    public MyDate getMyDate() {
        return myDate;
    }

    public void setMyDate(MyDate myDate) {
        this.myDate = myDate;
    }

    @Override
    public String toString() {
        return "name='" + name + ", salary=" + salary + ", myDate=" + myDate;
    }
}

class MyDate {
    private int year;
    private int month;
    private int day;

    public MyDate(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }

    public int getYear() {
        return year;
    }

    public void setYear(int year) {
        this.year = year;
    }

    public int getMonth() {
        return month;
    }

    public void setMonth(int month) {
        this.month = month;
    }

    public int getDay() {
        return day;
    }

    public void setDay(int day) {
        this.day = day;
    }

    @Override
    public String toString() {
        return year + "-" + month + "-" + day;
    }

    public int minDate(MyDate myDate) {
        int yearMinus = this.getYear() - myDate.getYear();
        int monthMinus = this.getMonth() - myDate.getMonth();
        int dayMinus = this.getDay() - myDate.getDay();

        if (yearMinus != 0) {
            return yearMinus;
        }
        if (monthMinus != 0) {
            return monthMinus;
        }
        return dayMinus;
    }
}

自定义泛型类

基本语法

class 类名 <T，R，...>{

成员

}

注意细节

1）普通成员可以使用泛型（属性、方法）；

2）使用泛型的数组，不能初始化；

3）静态方法中不能使用类的泛型；

4）泛型类的类型，是在创建对象时确定的（因为创建对象时，需要指定确定类型）；

5）如果在创建对象时，没有指定类型，默认为Object；

package com.pero.customgeneric;

/**
 * 自定义泛型类
 *
 * @author Pero
 * @version 1.0
 */


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

    }
}
//Tiger后面有泛型，Tiger称为自定义泛型类
//一般是单个的大写字母作为泛型的标识符，例如：R，S，T...
//泛型的标识符可以有多个
class Tiger<R,S,T>{
    String name;
    R r;
    S s;
    T t;

    //数组在new时不能确定T的类型，无法在内存中分配空间
    T[] ts;
    //T[] ts = new T[8];  //可以声明，不能初始化

    //静态属性和方法中不能使用类的泛型,静态方法是和类相关的，在类加载时对象还没有创建，
    // 如果静态方法和静态属性中使用泛型，泛型不能确定，JVM就无法完成初始化；
//    private static T t1;
//    public static void s(S s){
//
//    }

    public Tiger(String name, R r, S s, T t) {
        this.name = name;
        this.r = r;
        this.s = s;
        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 S getS() {
        return s;
    }

    public void setS(S s) {
        this.s = s;
    }

    public T getT() {
        return t;
    }

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

}

练习代码

package com.pero.customgeneric;

/**
 * @author Pero
 * @version 1.0
 */
public class Test_ {
    public static void main(String[] args) {
        MyGeneric<Double, String, Integer> john = new MyGeneric<>("john");
        john.setR(10.9);
        //john.setR("jack"); setR(R r)方法内的参数必须是R泛型类型的，这里是Double类型
        System.out.println("john:"+john);

        //这里相当于MyGeneric<Object,Object,Object> myGeneric = new MyGeneric<>();
        MyGeneric myGeneric = new MyGeneric("john~~");
        //setR(R r)方法类泛型的类型现在是Object类，"yy"是String类，
        // String类是Object的子类，所以可以传进去
        myGeneric.setT("yy");
        System.out.println("myGeneric:"+myGeneric);
    }
}
class MyGeneric<R,S,T>{
    R r;
    S s;
    T t;

    public MyGeneric(S s){
        this.s = s;
    }

    public MyGeneric(R r, S s, T t) {
        this.r = r;
        this.s = s;
        this.t = t;
    }

    public R getR() {
        return r;
    }

    public void setR(R r) {
        this.r = r;
    }

    public S getS() {
        return s;
    }

    public void setS(S s) {
        this.s = s;
    }

    public T getT() {
        return t;
    }

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

自定义泛型接口

基本语法

interface 接口名<R,S,T...>{

}

注意细节

1）接口中，静态成员不能使用泛型；

2）泛型接口的类型，在继承接口或者实现接口时确定；

3）没有指定类型，默认为Object。

package com.pero.customgeneric;

/**
 * @author Pero
 * @version 1.0
 */


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

    }
}

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

}

//在类实现接口时，接口所指定的泛型类型，在类中会直接进行替换
class AA implements IA{
    @Override
    public Double get(String s) {
        return null;
    }

    @Override
    public void hi(Double aDouble) {

    }

    @Override
    public void run(Double r1, Double r2, String u1, String u2) {

    }  //必须实现接口的所有抽象方法，否则编译器报错

}

//在实现接口时，直接指定泛型接口的类型
//类中实现接口方法时，泛型会直接进行替换
class BB implements IUsb<Integer,Float>{

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

    @Override
    public void hi(Float aFloat) {

    }

    @Override
    public void run(Float r1, Float r2, Integer u1, Integer u2) {

    }
}

//自定义泛型接口
interface IUsb<U,R>{
    int n = 10;
    //U u;      //接口中的成员都是静态属性的，不能使用泛型声明成员

    //普通方法中，可以使用接口泛型
    R get(U u);

    void hi(R r);

    void run(R r1,R r2,U u1,U u2);

    //在jdk8中，可以在接口中，使用默认方法,也是可以使用泛型
    //default是在java8中引入的关键字，在接口内部包含了一些默认的方法实现，
    //从而使得接口在进行扩展的时候，不会破坏与接口相关的实现类代码。
    default R method(U u){
        return null;
    }
}

//如果没有指定泛型类型，默认用Object替换泛型
//如果不明确泛型定义什么都不写，则会提醒警告
class CC implements IUsb<Object,Object>{  

    @Override
    public Object get(Object o) {
        return null;
    }

    @Override
    public void hi(Object o) {

    }

    @Override
    public void run(Object r1, Object r2, Object u1, Object u2) {

    }
}

自定义泛型方法

基本语法

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

}

注意细节

1）泛型方法，可以定义在普通类中，也可以定义在泛型类型中；

）当泛型方法被调用时，类型会确定；

3）public void eat(E e){},修饰符后没有<R,S,T...>,方法不是泛型方法，而是使用了泛型；

package com.pero.customgeneric;

/**
 * @author Pero
 * @version 1.0
 */
public class CustomMethodGeneric {
    public static void main(String[] args) {
        Car car = new Car();
        car.fly("宝马",2330); //当调用方法时，传入参数，编译器就会确定类型
        System.out.println("=================================");
        car.fly(25330,2210);

        Fish<String, Integer> stringIntegerFish = new Fish<>();
        stringIntegerFish.eat("jack",126.6,'s');
    }
}

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

    }
    //<T,V>就是泛型，提供给fly()方法使用
    public <T, V> void fly(T t, V v) {   //泛型方法
        System.out.println(t.getClass());
        System.out.println(v.getClass());
    }

//使用泛型的普通方法,普通类中不能这样使用，编译报错(S s)
//    public void swimming(S s){        //没有声明S泛型，无法找到
//
//    }
}

//泛型类
class  Fish<T,V>{
    public void run(){  //普通方法

    }
    //泛型方法，可以使用类声明的泛型，也可以使用方法自己定义的泛型
    public <R,S> void eat(T t,R r,S s){
        System.out.println(t.getClass());
        System.out.println(r.getClass());
        System.out.println(s.getClass());

    }
    //使用泛型的普通方法，不是泛型方法
    //使用类定义声明的泛型T
    public void swimming(T t){

    }
}

练习代码

package com.pero.customgeneric;

/**
 * @author Pero
 * @version 1.0
 */

public class CustomMethodGenericExercise {
    public static void main(String[] args) {
        Apple<String, Integer, Double> apple = new Apple<>();
        apple.fly(10);
        apple.fly(new Dog());
    }
}
class Apple<T,R,M>{ //泛型类
    public <E> void fly(E e){   //泛型方法
        System.out.println(e.getClass().getSimpleName());
    }
    //public void eat(U u){}    //查找不到泛型U，没有声明报错
    public void run(M m){}
}
class Dog{}

泛型的继承和通配符

1）泛型不具备继承性；//List<Object> list = new ArrayList<String>();这样写错误

2）<?>：支持任意泛型类型；

3）<? entends A>支持A类以及A的子类，规定了泛型类型的范围上限

4）<? super A>支持A类以及A的父类，不限于直接父类，规定了泛型的下限；

package com.pero.customgeneric;

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

/**
 * @author Pero
 * @version 1.0
 */

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

        Object object = new String("pero");

        //泛型没有继承性
        //List<Object> list = new ArrayList();

        List<Object> list1 = new ArrayList<>();
        List<String> list2 = new ArrayList<>();
        List<Animal> list3 = new ArrayList<>();
        List<Monkey> list4 = new ArrayList<>();
        List<Person> list5 = new ArrayList<>();
        
        //printCollection1(可以接受任意类型)
        printCollection1(list1);
        printCollection1(list2);
        printCollection1(list3);
        printCollection1(list4);
        printCollection1(list5);

        //printCollection2(只能接收Animal类型和Animal的子类类型)
        //printCollection2(list1);  //报错，Object类是Animal的父类
        //printCollection2(list2);  //报错，String类与Animal类不相关
        printCollection2(list3);
        printCollection2(list4);
        printCollection2(list5);
        
        //只能接收Animal类型和Animal的父类
        printCollection3(list1);
        //printCollection3(list2);  //报错，String类与Animal类不相关
        printCollection3(list3);
        //printCollection3(list4);  //报错，Monkey类是Animal类的子类
        //printCollection3(list5);  //报错，person类是Animal类的子类
        
    }
    //List<?>表示任意泛型类型都可以接收
    public static void printCollection1(List<?> c) { //<?>通配符
        for (Object o : c) {
            System.out.println(o);
        }
    }
    //? extends Animal 表示泛型可以接收Animal和Animal的子类类型，确定范围上限
    public static void printCollection2(List<? extends Animal> c) {
        for (Object o : c) {
            System.out.println(o);
        }
    }
    //？ super Animal 表示泛型可以接收Animal和Animal 的父类，确定范围下限
    public static void printCollection3(List<? super Animal> c) {
        for (Object o : c) {
            System.out.println(o);
        }
    }
}

class Animal {}

class Monkey extends Animal {}

class Person extends Monkey {}

JUnit单元测试类

为什么使用JUnit

1）一个类有很多功能代码需要测试，为了测试，就需要写到main方法中；

2）如果有多个功能代码测试，就需要来回注销，切换很麻烦；

3）如果可以直接运行一个方法，就方便很多，并且可以给出相关信息。

基本介绍

1）JUnit是一个Java语言的单元测试框架；

2）多数Java的开发环境都已经集成了Junit作为单元测试的工具

使用步骤：

1）在测试方法上一行添加@Test；

2)然后点击Alt+Enter，然后选择Add 'JUnit5.8.1' to classpath；

3）跟随引导添加即可。

package com.pero.junit_;

import org.junit.jupiter.api.Test;

/**
 * @author Pero
 * @version 1.0
 */
public class JUnit_ {
    public static void main(String[] args) {

        //传统方式
        //new JUnit_().m1();
        //new JUnit_().m2();
    }
    
    //JUnit单元测试，可以对方法进行单独测试
    @Test
    public void m1(){
        System.out.println("m1()被调用");
    }
    @Test
    public void m2(){
        System.out.println("m2()被调用");
    }
}