注解反射泛型

一、注解 annotation

1、元注解

@Target

@Retention

@Documented

@Inherited

@Demo.MyAnnotation
public class Demo {
    @MyAnnotation
    public void test(){
        List list = new ArrayList();
    }

    //定义一个注解
    //内部类 Target表示我们的注解可以用在哪些地方
    @Target(value = {ElementType.METHOD,ElementType.TYPE})
    //Retention 表示我们的注解在什么地方还有效，RUNTIME>class>source
    @Retention(value = RetentionPolicy.RUNTIME)
    //Documented 表示是否将注解生成在javadoc中
    @Documented
    //Inherited 子类是否可以继承该注解
    @Inherited
    @interface MyAnnotation{

    }
}

public class Test03 {
    //注解可以显示赋值，如果没有赋值，需要给注解赋值
    @MyAnnotation(schools = {"西北",""})
    public void test(){

    }

    @MyAnnotation3("liu")//value="liu", value可以省略
    public void test3(){

    }

}

@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation{
    //注解的参数：参数类型+参数名（）；
    String name() default "";
    int age() default 0;
    int id() default -1;//如果默认值为-1,代表不存在
    String[] schools();
}

@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation3{
    String value();//如果只有一个参数，建议value命名
}

二、反射

package java.reflection;


public class Test01 {
    public static void main(String[] args) throws ClassNotFoundException {

//    通过反射获取类的class对象
        Class c1 = Class.forName("java.reflection.User");
        //一个类在内存中只有一个class对象
        //一个类被加载后，类的整个结构被封装在class中
    }


}

//实体类 pojo
class User{
    private String name;
    private int id;
    private int age;

    public User() {
    }

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

    public String getName() {
        return name;
    }

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

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public int getAge() {
        return age;
    }

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

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

package instruction.reflection;
//测试Class类的创建方式
public class Test02 {
    public static void main(String[] args) throws ClassNotFoundException {
        Person person = new Student();
        System.out.println(person.name);
        //方式一：通过对象获得
        Class c1 = person.getClass();
        //方式二：forNam获得
        Class c2 = Class.forName("instruction.reflection.Student");
        //方式三：通过类名.class获得的
        Class<Student> c3 = Student.class;
        System.out.println(c1.hashCode());
        System.out.println(c2.hashCode());
        System.out.println(c3.hashCode());
    }
}

class Person{
    public String name;

    public Person() {
    }

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

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

class Student extends Person{
    public Student() {
        this.name="学生";
    }
}

class Teacher extends Person{
    public Teacher() {
        this.name="老师";
    }
}

//反射操作注解
//模拟对象和数据库表
public class Test3 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
        //反射操作注解
        Student3 stu = new Student3();
        //通过反射获得注解
        Class c1 = Class.forName("instruction.reflection.Student3");
        Annotation[] annotations = c1.getAnnotations();//获得注解
        for (Annotation annotation:annotations){
            System.out.println(annotation);//@instruction.reflection.MyTable(value=tb_stu)
        }
        //获得类的注解
        MyTable myTable = (MyTable)c1.getAnnotation(MyTable.class);
        System.out.println(myTable.value());//tb_stu
        //获得类方法的注解
        Field field = c1.getDeclaredField("name");
        MyField annotation = field.getAnnotation(MyField.class);
        System.out.println(annotation.column()+","+annotation.type()+","+annotation.length());//name,varchar,20
    }
}
@MyTable(value = "tb_stu")
class Student3{
    @MyField(column = "id",type = "int",length = 10)
    private int id;
    @MyField(column = "age",type = "int" ,length = 10)
    private int age;
    @MyField(column = "name",type = "varchar",length = 20)
    private String name;
    public Student3() {
    }
    public Student3(int id, int age, String name) {
        this.id = id;
        this.age = age;
        this.name = name;
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public String toString() {
        return "student{" +
                "id=" + id +
                ", age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}
//注解
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface MyTable{
    String value();
}
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface MyField {
    String column();
    String type();
    int length();
}

三、泛型

1、泛型类

package instruction.mygeneric;

public class Generic<T> {
    private T key;//T 室友外部使用时定义的

    public Generic() {
    }

    public Generic(T key) {
        this.key = key;
    }

    public T getKey() {
        return key;
    }

    public void setKey(T key) {
        this.key = key;
    }

    @Override
    public String toString() {
        return "Generic{" +
                "key=" + key +
                '}';
    }
}

package instruction.mygeneric;
public class Demo {
    public static void main(String[] args) {
        Generic<String> stringGeneric = new Generic<>("wwww");
        String key = stringGeneric.getKey();
        System.out.println(key);
        System.out.println("------------------");
        Generic<Integer> integerGeneric = new Generic<>(100);
        Integer integer = integerGeneric.getKey();
        System.out.println(integer);
        System.out.println("------------------");
        //泛型类在创建时没有指定类型的话，将按照Object类型处理

        //同一泛型类，根据不同类型创建得对象。本质上是同一种类型
        System.out.println(integerGeneric.getClass()==stringGeneric.getClass());
    }
}

public class Product<T> {
    //抽奖的物品既可以设置为将近 Integer 类型的奖金
    // 也可以设置为String 类型的物品名称
    Random random = new Random();
    //抽奖
    private T product;
    //抽奖池
    ArrayList<T> list= new ArrayList<>();
    //添加
    public void addProduct(T t){
        list.add(t);
    }
    //获取
    public T getProduct(){
        list.get(random.nextInt(list.size()));
        return product;
    }
}

2、泛型接口

3、泛型方法

4、类型通配符

package generic;

public class GenericDemo<T> {
	private T first;

	public T getFirst() {
		return first;
	}

	public void setFirst(T first) {
		this.first = first;
	}

	
}

5、类型通配符上限

6、实参类型下限

7、泛型擦除

8、泛型数组

ArrayList<String>[] lists = new ArrayList[4];