java 反射--Java笔记

JVM 负责对类进行初始化（主要指静态成员），此阶段是执行 <clinit>（）方法的过程，<clinit>（）方法是由编译器按语句在源文件中出现的顺序，依次收集类中的所有静态变量的赋值和静态代码块中的语句。虚拟机会保证一个类的<clinit>（）方法在多线程中被正确的加锁和同步，如果多线程同时初始化一个类，那么只会有一个线程去执行这个类的<clinit>（）方法，其他线程都需要等待阻塞。

三.反射相关的类与方法

1.Class类

①.Class 也是类，继承object，Class类不是 new 出来的，而是系统创建的

②.类只加载一次，所有一个类的Class 对象在内存中只有一个

③.每一个类的实例都会记得自己是哪个 Class 实例生成的

④.通过Class 对象可以完整的得到一个类的完整结构

⑤.Class对象是存放在堆中的，类的字节码二进制数据是放在方法区的，

Ⅰ.获取 Class 类对象

已知一个类的全类名，且该类在类路径下，可通过Class 类的静态方法 forName（）来获取

已知具体的类，通过类的 class 来获取，该方式最安全

已知一个类的实例，调用该实例的 getClass（）方法来获取Class 对象

getClassLoader（）

Ⅱ.那些类型有 Class 对象

外部类、内部类、接口、数组、枚举、注解、基本数据类型和void

Ⅲ.Class 类的方法

1.forName（）获取类的Class对象

2.getClass（）查看类运行类型

3.getPackage（）返回该类的包

4.newInstance（）通过反射创建对象

5.getName（）返回 Class 对象的实体名称

6.getSuperClass（）返回当前Class对象的父类的Class对象

7.getInterfaces（）获取当前Class对象的接口

8.getClassLoader（）返回该类的类加载器

9.getSimpleName（）获取简单类名

10.getFields（）获取该类和父类所有public 修饰的属性

11.getDeclaredFields（）获取该类所有的属性

12.getMethods（）获取该类和父类所有public 修饰的方法

13.getDeclaredMethods（）获取该类所有的方法

14.getConstructors（）获取本类所有的public修饰的构造器

15.getDeclaredConstructors（）获取该类所有的构造器

16.getAnnotations（）返回注解信息

import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class App {
    public static void main(String[] args)
            throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchFieldException,
            SecurityException {

        // 1.forName（）获取类的Class对象
        Class c = Class.forName("B");
        System.out.println("1.:  " + c);

        // 2.getClass（）查看类运行类型
        System.out.println("2.:  " + c.getClass());

        // 3.getPackage（）
        System.out.println("3.:  " + c.getPackage());

        // 4.newInstance
        Object o = c.newInstance();
        System.out.println("4.:  " + o.getClass());

        // 5.getName（）返回 Class 对象的实体名称
        System.out.println("5.:  " + c.getName());

        // 6.getSuperClass（）返回当前Class对象的父类的Class对象
        System.out.println("6.:  " + c.getSuperclass());

        // 7.getInterfaces（）获取当前Class对象的接口
        System.out.println("7.:  " + c.getInterfaces());

        // 8.getClassLoader（）返回该类的类加载器
        System.out.println("8.:  " + c.getClassLoader());

        // 9.getSimpleName（）获取简单类名
        System.out.println("9.:  " + c.getSimpleName());

        // 10.getFields（）获取该类和父类 所有public 修饰的属性
        Field[] f = c.getFields();
        System.out.println("10.:  ");
        for (Field field : f) {
            System.out.println(field);
        }

        // 11.getDeclaredFields（）获取该类所有的属性
        f = c.getDeclaredFields();

        for (Field field : f) {
            System.out.println(field);
        }

        // 12.getMethods（）获取该类和父类所有public 修饰的方法
        Method[] m = c.getMethods();
        System.out.println("12.:  ");
        for (Method method : m) {
            System.out.println(method);
        }

        // 13.getDeclaredMethods（）获取该类所有的方法
        m = c.getDeclaredMethods();
        System.out.println("13.:  ");
        for (Method method : m) {
            System.out.println(method);
        }

        // 14.getConstructors（）获取本类所有的public修饰的构造器
        Constructor[] cc = c.getConstructors();
        System.out.println("14.:  ");
        for (Constructor constructor : cc) {
            System.out.println(constructor);
        }

        // 15.getDeclaredConstructors（）获取该类所有的构造器
        cc = c.getDeclaredConstructors();
        System.out.println("15.:  ");
        for (Constructor constructor : cc) {
            System.out.println(constructor);
        }

        // 16.getAnnotations（）返回注解信息
        Annotation[] aa = c.getAnnotations();
        System.out.println("16.:  ");
        for (Annotation annotation : aa) {
            System.out.println(annotation);
        }

    }
}

interface AA {
}

class A {
    public void AA() {
    }

    void AAA() {
    }

    public A() {
    }

    A(int i) {
    }
}

@Deprecated
class B extends A implements AA {
    public String s;
    int i;

    public void bb() {
    }

    void bbb() {
    }

    public B() {
    }

    B(int i) {
    }
}

输出：

1.: class B
2.: class java.lang.Class
3.: null
4.: class B
5.: B
6.: class A
7.: [Ljava.lang.Class;@70dea4e
8.: sun.misc.Launcher$AppClassLoader@6d06d69c
9.: B
10.:
public java.lang.String B.s
11.:
public java.lang.String B.s
int B.i
12.:
public void B.bb()
public void A.AA()
public final void java.lang.Object.wait() throws java.lang.InterruptedException
public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException
public boolean java.lang.Object.equals(java.lang.Object)
public java.lang.String java.lang.Object.toString()
public native int java.lang.Object.hashCode()
public final native java.lang.Class java.lang.Object.getClass()
public final native void java.lang.Object.notify()
public final native void java.lang.Object.notifyAll()
13.:
public void B.bb()
void B.bbb()
14.:
public B()
15.:
B(int)
public B()
16.:
@java.lang.Deprecated()

2..Field的方法

1.set（）通过字段对象修改值

2.get（）获得值

3.getModifiers（）返回修饰符

0 为默认、1 = public、2 = private、

4 = protected、8 = static、16 = final

4.getType（）返回类型

5.getName（）返回属性名

        Class c = Class.forName("B");
        Object o = c.newInstance();
        Field f = c.getField("s");

        // 1.set（）通过字段对象修改值
        f.set(o, "100");

        // 2.get（）获得值
        System.out.println(f.get(o));

        // 3.getModifiers（）返回修饰符 0 为默认、1 = public、2 = private、4 = protected、8 =
        // static、16 = final
        System.out.println(f.getModifiers());

        // 4.getType（）返回类型
        System.out.println(f.getType());

        // 5.getName（）返回属性名
        System.out.println(f.getName());

    }
}

@Deprecated
class B {
    public String s;
    int i;

    public void bb() {
    }

    void bbb() {
    }

    public B() {
    }

    B(int i) {
    }
}

输出：

3.Method的方法

方法与Field类似

getParameterTypes（）返回参数类型数组

 
        Class c = Class.forName("B");
        Object o = c.newInstance();
        Method[] m = c.getDeclaredMethods();
        System.out.println(m);
        for (Method method : m) {
            Class<?>[] cc = method.getParameterTypes();
            System.out.println(method);
            for (Class<?> class1 : cc) {
                System.out.println(class1);
            }
        }
class B {
    public String s;
    int i;

    public void bb(int i, String s, int ii) {
    }

    void bbb() {
    }

    public B() {
    }

    B(int i) {
    }
}

输出：

4.Constructor的方法

和method类似

5.爆破：setAccessible

可以获取 private 修饰的构造器，静态属性和方法参数可以写成 null

        Class c = Class.forName("B");
        Constructor cc = c.getDeclaredConstructor(int.class);//获取私有构造器
        cc.setAccessible(true);//爆破
        // 1构造器
        Object o1 = cc.newInstance(100);//创建实例
        System.out.println(o1);
        // 2构造器
        B b = (B) cc.newInstance(200);//创建实例
        System.out.println(b);
        //属性
        Field f = c.getDeclaredField("i");//获取私有属性 
        f.setAccessible(true);//爆破
        f.set(o1, 1);//修改值
        System.out.println(f.get(o1));输出属性值

        Method m = c.getDeclaredMethod("bb", String.class);//获取私有方法
        m.setAccessible(true);//爆破
        m.invoke(o1, "张三");//调用方法

class B {
    public String s;
    private int i;

    private void bb(String s) {
        System.out.println("bb()" + s);
    }

    public void bbb() {
    }

    public B() {
    }

    private B(int i) {
        this.i = i;
        System.out.println("B(int i)");
    }

    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return i + "";
    }
}

输出：