反射与注解

反射：

     反射是一种在程序运行过程中，根据类的名称或者已有对象来获取类的属性，方法，父类等有关信息，以及对象实例的创建和实例类型的判断的一种机制。 

     反射中常用的类Class，Class类其实表示的是正在运行的Java应用程序中的类和接口。其中Class的forName()方法可以获得Class对象的实例，再通过newInstance()方法即可获得该类的一个新实例。

1.获取一个类Class对象的三种方法:  Class类的forName()方法；类的class属性；对象的getClass()方法。以及基本数据类型及其包装类的Class对象；数据类型相同并维度相同时，其对象共享一个Class对象。具体见如下实例：

class.forName();

对象.getClass():

类.class;

public class Test1 {
    public static void main(String[] args) throws ClassNotFoundException {
        //1.采用目标类的.class属性-->每个类都有包装类(Type属性)：
        Class c1 = Users.class;
        System.out.println(c1);

        //2.Object类的getClass()方法：
        Users users = new Users();
        Class c2 = users.getClass();
        //getSimpleClass():只获得类的名称，不包含包名
        System.out.println(users);
        System.out.println(c2);

        //3.Class类的forName()方法：
        Class c3 = Class.forName("TestMyself.Users");
        System.out.println(c2);

        //4.基本数据类型的Class对象，与其包装类的Class对象是Type属性获得
        Class i1 = int.class;
        Class i2 = Integer.TYPE;
        System.out.println(i1==i2);
    }
}

 

2.通过Class对象获得类的：名称；属性；方法；构造方法；

主要方法：

class.getName():获得类名；

class。getDeclaredField():获得属性；

class。getDeclaredConstructor()：获得无参构造方法；

class.getDeclaredMethod():获得方法；

//通过反射获得类的信息(通过Class对象)：
//名称;属性;方法;构造；
public class Test5 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException {
        Class c1 = Class.forName("TestMyself.Users"); //获得Class对象
        Class c2 = Class.forName("java.lang.String");

        //1.获得类名：
        String name = c1.getName();
        String simpleName = c1.getSimpleName();
        System.out.println("name:"+name+"   simpleName:"+simpleName);
        System.out.println("=================================================");

        //2.获得属性：
        Field[] fields = c1.getFields();   //getFields():只能获得public属性
        for (Field field : fields) {
            System.out.println(field);
        }
        Field[] declaredFields = c1.getDeclaredFields(); //获得全部的属性
        for (Field declaredField : declaredFields) {
            System.out.println(declaredField);
        }
        System.out.println("============================================================");
        
        //3.获得方法：
        Method[] methods = c1.getMethods(); //getMethods():获得本类和父类的所有public方法
        for (Method method : methods) {
            System.out.println("public 方法："+method);
        }

        Method[] Methods = c1.getDeclaredMethods();//获得本类的所有方法
        for (Method declaredMethod : Methods) {
            System.out.println("本类方法："+declaredMethod);
        }
        //对于要获得重载方法：如果只知道方法名字是找不到具体方法的
        //("方法名"，参数的Class对象)
        System.out.println("==================================================");
        Method getAge = c1.getMethod("getAge", null);
        Method setName = c1.getMethod("setName", String.class);
        System.out.println(getAge);
        System.out.println(setName);

        //4.获得构造器：
        //获得无参构造
        System.out.println("=====================================================");
        Constructor constructor = c1.getConstructor();

        //获得有参构造：(参数的Class对象)
        Constructor constructor1 = c1.getConstructor(String.class, int.class, int.class);

        System.out.println("无参构造："+constructor);
        System.out.println("有参构造："+constructor1);


    }
}

3.通过Class对象来创建对象，并调用执行方法；获得属性并设置属性：

用到的主要方法：

newInstance():使用无参构造创建对象；

getDeclaredConstructor(形参的Class对象。。。)获得有参构造器->construcctor.newInstance(实参。。。)：来创建对象；

getDeclaredMethod（“方法名”，形参Class对象。。。）：获得一个方法-->method.invoke（对象，实参。。。）:执行这个方法；

getDeclaredFiled("属性名")：获得属性；field.setAccessible(true):设置权限来访问私有属性，field.set(对象，实参)；

public class Test06 {
    public static void main(String[] args) throws
            ClassNotFoundException,
            IllegalAccessException,
            InstantiationException,
            NoSuchMethodException,
            InvocationTargetException,
            NoSuchFieldException {
        //1.使用Class对象来获得构造方法，并创建对象
        Class<?> c = Class.forName("TestMyself.Users");   //创建Class对象

        //用无参构造创建对象  c.newInstance()
        Users u1 = (Users) c.newInstance();
        System.out.println(u1);               //重写toString()方法

        //用有参构造创建对象： constructor.newInstance("张三","001","18")
        Constructor<Users> declaredConstructor = (Constructor<Users>) c.getDeclaredConstructor(String.class, int.class, int.class);
        Users u2 = declaredConstructor.newInstance("张三", 001, 18);
        System.out.println(u2);

        //2.通过反射来调用普通方法：
        Users u3 = (Users) c.newInstance();  //使用无参构造创建一个对象
        Method getAge = c.getDeclaredMethod("getAge");       //获得方法("方法名",Class对象。。。)
        Method setAge = c.getDeclaredMethod("setAge", int.class);
        setAge.invoke(u3,19);
        getAge.invoke(u3);    //invoke(对象，实参)来执行方法
        System.out.println(u3.getAge());

        //3.通过反射来获得(私有)属性，并给属性赋值
        Users u4 = (Users) c.newInstance();  //创建一个对象
        Field field = c.getDeclaredField("name");
        field.setAccessible(true);    //设置权限，从而可以访问private属性
        field.set(u4,"王五");
        System.out.println(u4.getName());
}
}

 注解：

1.常见的三种注解： 

 

@SuppressWarnings("all")  //取消警告的注解

public class Test1 extends Thread {


    @Override  //@Override:方法重写的注解
    public void run() {
        System.out.println("@Override");
    }

    public static void main(String[] args) {


        Test();
        new Test1().start();


    }

    @Deprecated  //方法过时的注解
    public static void Test(){
        System.out.println("@Deprecated");

    }
}

2.自定义注解：

//自定义
public class Test2{

    public static void main(String[] args) {
        Test();
    }


    @Myannotation@Deprecated //可以多个在一起定义
    public static void Test(){
        System.out.println("啦啦啦");
    }
    @Myannotation2(name="张三",age={1,2})
    public static void Test3(){
        System.out.println("this is zhang san!");
    }
}


@Target(ElementType.METHOD)     //参数是唯一的value，可以省略不写
    @Retention(RetentionPolicy.RUNTIME)
@Documented
@interface Myannotation{
//    String value();
//    char[] name();

    String value() default "张三";
    String [] schools() default {"李四","王五","赵6"};

}



@Target(value={ElementType.METHOD,ElementType.FIELD})   //注解作用范围
@Retention(value=RetentionPolicy.RUNTIME)           //注解的作用时刻

@interface Myannotation2{
    String name();  //参数
    int[] age();
}