package test1;

public class Student {

    private Student() {}
}

class testA {

}

package test1;

public class Personal {

    private String name;
    private int age = 1;

    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;
    }

    public Personal(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }

    public Personal() {
        super();
    }

    public void eat() {
        System.out.println("eat 1");
    }

    public void eat(String name) {
        System.out.println("eat" + name);
    }

    public String eat(int a) {
        return "eat return";
    }
}

public class Demo {

    public static void main(String[] args) throws ClassNotFoundException {
        //获取Student的字节码文件对象
        Student s = new Student();
        //Object类的getClass()方法
        Class clazz = s.getClass();
        System.out.println(clazz);
        
        testA a = new testA();
        //类的class属性方法
        System.out.println(testA.class);
        //同一个类的对象或者同一个类得到的字节码对象是同一个
        System.out.println(testA.class == a.getClass()); //true
        //Class的forName方法
        Class clazz1 = Class.forName("test1.Personal");
        System.out.println(clazz1);
    }

}

package test1;

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

public class Demo {

    public static void main(String[] args) throws Exception {        
        //获得构造方法对象
         
         //获得字节码文件对象
        Class clazzPerson = Personal.class;
        //获得所有公告的(public)构造方法对象
        Constructor[] constructors = clazzPerson.getConstructors();
        //遍历输出所有
        for (Constructor con : constructors) {
            System.out.println(con);
        }
        
        //用反射的方式创建Personal类对象
        Object obj = Personal.class.getConstructor().newInstance();
        System.out.println(obj);
        
        Class clazz = Student.class;
        // 获取构造方法对象
        Constructor declaredConstructor = clazz.getDeclaredConstructor();
        // 暴力访问(Student构造方法为private)
        declaredConstructor.setAccessible(true);
        // 用反射的方式创建该类对象
        Object objt = declaredConstructor.newInstance();
        System.out.println(objt);
     
        /**
         * 用反射的便捷方式创建一个类对象 不直接使用构造器对象， 不直接使用构造器对象 无参、public
         */
        Object objp = Personal.class.newInstance();
        System.out.println(objp);

    }

}

package test1;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;

public class Demo {

    public static void main(String[] args)
        throws Exception {

        Class clazzPs = Personal.class;
        // 获取所有方法
        Method[] declaredMethods = clazzPs.getDeclaredMethods();
        for (Method method : declaredMethods) {
            System.out.println(method);
        }
        
        // 得到特定的方法--无参的
        Method method = clazzPs.getMethod("eat", null);
        // 调用该方法
        method.invoke(clazzPs.newInstance(), null);
        
        //得到特定的方法--带参的，第二个参数为参数类型的字节码文件对象
        Method method1 = clazzPs.getDeclaredMethod("eat", String.class);
        //调用该方法并传参数"ces"
        method1.invoke(clazzPs.newInstance(), "ces");
        
        // 得到特定的方法--带参并有返回值的
        Method method2 = clazzPs.getMethod("eat", int.class);
        Object res = method2.invoke(clazzPs.newInstance(), 1);
        System.out.println(res);
    }

}