泛型-注解-枚举的小小用法

泛型

泛型好处

1. 把运行时期的问题提前到了编译期间，可以在开发时发现，写不是要求的泛型，会报错
2. 避免了强制类型转换
3. 返参通用性

泛型类

package fanxing;

public class ClassFanXing<T> {
    private T t;
    private String name;
    private Integer age;

    public T getT() {
        return t;
    }

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

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

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

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


package fanxing;

public class Test01 {
    public static void main(String[] args) {
        ClassFanXing<String> fanxing01 = new ClassFanXing<String>();
        fanxing01.setT("2311");
        fanxing01.setAge(21);
        fanxing01.setName("zhangsan");
        System.out.println(fanxing01);
        System.out.println("============================");

        ClassFanXing<PeopleInfo> fanXing02 = new ClassFanXing<PeopleInfo>();
        PeopleInfo peopleInfo = new PeopleInfo();
        peopleInfo.setAddr("好贼王");
        peopleInfo.setBrithday("1990-10-10");
        fanXing02.setT(peopleInfo);
        fanXing02.setAge(21);
        fanXing02.setName("zhangsan");
        System.out.println(fanXing02);
    }
}

泛型方法

用法：远程调用时，牵涉到掉用返回不一致，但是整个逻辑代码是共用的，可以这么操作，特别是json转换为对象时,只需要传一个class类型进来就可以jsontoobject了；

package fanxing;

public class MethodFanXing {
    public <T> T getT(BaseRequest request,Class<T> clazz){
        T t = (T) request;
        return t;
    }
}


package fanxing;

public class BaseRequest {
}


package fanxing;

public class TestBaseRequest extends BaseRequest {
    private String name;
    private String age;

    public TestBaseRequest() {
    }

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

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

    public String getName() {
        return name;
    }

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

    public String getAge() {
        return age;
    }

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


package fanxing;

public class Test02BaseRequest extends BaseRequest {
    private Double price;
    private Integer num;

    public Test02BaseRequest() {
    }

    public Test02BaseRequest(Double price, Integer num) {
        this.price = price;
        this.num = num;
    }

    public Double getPrice() {
        return price;
    }

    public void setPrice(Double price) {
        this.price = price;
    }

    public Integer getNum() {
        return num;
    }

    public void setNum(Integer num) {
        this.num = num;
    }

    @Override
    public String toString() {
        return "Test02BaseRequest{" +
                "price=" + price +
                ", num=" + num +
                '}';
    }
}


package fanxing;


public class Test01 {
    public static void main(String[] args) {
        MethodFanXing methodFanXing = new MethodFanXing();
        TestBaseRequest testBaseRequest = new TestBaseRequest("张三","23");
        Test02BaseRequest test02BaseRequest = new Test02BaseRequest(11.11,12);
        TestBaseRequest t1 = methodFanXing.getT(testBaseRequest, TestBaseRequest.class);
        System.out.println(t1);
        System.out.println("--------------------------------------");
        Test02BaseRequest t2 = methodFanXing.getT(test02BaseRequest, Test02BaseRequest.class);
        System.out.println(t2);
    }
}

泛型接口定义格式

package fanxing;

public interface FanXingInterface<T> {
    void getT(T t);
}

注意：实现该接口的类要么指定具体泛型，要么在创建实际对象时指定

package fanxing;

public class FanXingImpl<String> implements FanXingInterface<String> {

    public void getT(String string) {
        
    }
}

类型通配符

• 类型通配符: <?>
  • ArrayList<?>: 表示元素类型未知的ArrayList,它的元素可以匹配任何的类型
  • 但是并不能把元素添加到ArrayList中了,获取出来的也是父类类型
• 类型通配符上限: <? extends 类型>
  • ArrayListList <? extends Number>: 它表示的类型是Number或者其子类型
• 类型通配符下限: <? super 类型>
  • ArrayListList <? super Number>: 它表示的类型是Number或者其父类型

使用举例：可作为统一入参校验；

package fanxing;


import java.util.ArrayList;

public class Test01 {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        list.add(new BaseRequest());
        list.add(new TestBaseRequest());
        get(list);
        get("123");//  报错，不支持类型
    }
    public static void get(ArrayList<? extends BaseRequest> list){

    }
}

注解

简单示例

package zhujie;

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;

@Retention(value = RetentionPolicy.RUNTIME) // 注解什么时候生效
public @interface AnnoClass {

}


package zhujie;

public class TestClass {
    public void mthod01(){
        System.out.println("未使用注解");
    }

    @AnnoClass
    public void mthod02(){
        System.out.println("使用注解");
    }
}


package zhujie;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class Test {
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, InvocationTargetException {
        // 类加载
        Class<?> aClass = Class.forName("zhujie.TestClass");
        // 反射创建对象
        TestClass testClass = (TestClass) aClass.newInstance();
        // 获得所有方法
        Method[] declaredMethods = aClass.getDeclaredMethods();
        for (Method declaredMethod : declaredMethods) {
            if(declaredMethod.isAnnotationPresent(AnnoClass.class)){
                declaredMethod.invoke(testClass);
            }
        }
    }
}

枚举

作用：间接表示固定的值，且变量的值只局限于所列出的范围内

主要是规定死的且有限制的值，做到统一入参，对落库又有比较好的长度压缩；

package enums;

public enum MyEnum {
    ZG_BANK(1,"中国银行"),
    ZG_ZS_BANK(2,"中国招行银行"),
    ZG_JS_BANK(3,"中国建设银行"),
    ;


    private Integer code;
    private String desc;

    MyEnum(Integer code, String desc) {
        this.code = code;
        this.desc = desc;
    }

    Integer getCode(){
        return this.code;
    }
}


package enums;

public class Test03 {
    public static void main(String[] args) {
        System.out.println(MyEnum.ZG_BANK.getCode());
    }
}