Java面试基础—Class类中各个方法有什么区别？

一、获取Class对象的三种方式

package com.reflect;
public class Demo3 {
	public static void main(String[] args) {
		// 第一种方式获取Class对象
		User u1 = new User();// 这一new 产生一个Student对象，一个Class对象。
		Class u1Class = u1.getClass();// 获取Class对象
		System.out.println("class "+u1Class.getName());

		// 第二种方式获取Class对象
		Class u2 = User.class;
		System.out.println(u2);

		// 第三种方式获取Class对象
		try {
			Class u3 = Class.forName("com.reflect.User");// 注意此字符串必须是真实路径，就是带包名的类路径，包名.类名
			//判断三种方式，获取结果是否一致
			System.out.println(u2 == u1Class);// 判断第一种方式获取的Class对象和第二种方式获取的是否是同一个
			System.out.println(u3 == u1Class);// 判断三种方式是否获取的是同一个Class对象
			
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
        
	}
}

执行结果，得出结论：
同一个字节码文件（*.class）在同一次程序运行过程中，只会被加载一次！
无论何种方式获取class文件对象，都是同一个！

二、Class类中各个方法

Person类

package com.reflect;
public class Person {
    public String name;     //最大范围public
    protected  int age;     //受保护类型
    int height;             //默认的访问权限
    private String adress;  //私有类型
    public Person() {
    }
    protected Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    Person(String name, int age, int height) {
        this.name = name;
        this.age = age;
        this.height = height;
    }
    private Person(String name, int age, int height, String adress) {
        this.name = name;
        this.age = age;
        this.height = height;
        this.adress = adress;
    }
    public void eat(){
        System.out.println("eat...");
    }
    protected void drink(){
        System.out.println("drink...");
    }
    void play(){
        System.out.println("play...");
    }
    private void happy(){
        System.out.println("happy...");
    }
}

User继承Person类

package com.reflect;
public class User extends Person{
	    public String username;      //最大范围public
	    protected  String userage;   //受保护类型
	    String users;                //默认的访问权限
	    private String userid;       //私有类型
	    public User() {
	    }
	    protected User(String userage) {
	        this.userage = userage;
	    }
	    User(String username, String userid) {
	        this.username = username;
	        this.userid = userid;
	    }
	    private User(String username, String userage, String users, String userid) {
	        this.username = username;
	        this.userage = userage;
	        this.users = users;
	        this.userid = userid;
	    }
	    public void haha(){
	        System.out.println("哈哈哈...");
	    }
	    protected void xixi(){
	        System.out.println("嘻嘻嘻...");
	    }
	    void wu(){
	        System.out.println("呜呜呜...");
	    }
	    private void liu(){
	        System.out.println("溜溜溜...");
	    } 	
}

Demo3测试

package com.reflect;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class Demo3 {
	public static void main(String[] args) {
		// 第一种方式获取Class对象
		User u1 = new User();// 这一new 产生一个Student对象，一个Class对象。
		Class u1Class = u1.getClass();// 获取Class对象
		//System.out.println("class "+u1Class.getName());
		System.out.println("*************getFields方法***********");
		//使用getFields()方法获取成员变量，会获取所有public修饰的成员变量,包括父类。
        Field[] fields = u1Class.getFields();
        for(Field field : fields){
            System.out.println(field);
        }
        System.out.println("*************getDeclaredFields方法***********");
        //getDeclaredFields()方法会获取本类中所有的成员变量，不考虑修饰符,不包括父类。
        Field[] fields2  = u1Class.getDeclaredFields();
        for (Field field : fields2) {
        	 System.out.println(field);
		}
        //System.out.println("*************getConstructors方法***********");
        //使用getConstructors()方法获取构造函数，获取本类中所有public修饰的构造函数，不包括父类。
        Constructor[] constructors = u1Class.getConstructors();
        for(Constructor constructor : constructors){
            //System.out.println(constructor);
        }
        //System.out.println("*************getDeclaredConstructors方法***********");
        //getDeclaredConstructors()方法会获取本类中所有的构造函数，不考虑修饰符,不包括父类。
        Constructor[] constructors1 = u1Class.getDeclaredConstructors();
        for(Constructor const1 : constructors1){
            //System.out.println(const1);
        }
        
        //System.out.println("************getMethods方法************");
	    //使用getMethods()方法获取成员方法，获取所有public修饰的成员方法,包括父类和超类。
        Method[] methods=u1Class.getMethods();
        for(Method method : methods){
            //System.out.println(method);
        }
        //System.out.println("************getDeclaredMethods方法************");
        //getDeclaredMethods()会获取本类中所有的成员方法，不考虑修饰符,不包括父类。
        Method[] methods2=u1Class.getDeclaredMethods();
        for(Method method : methods2){
            //System.out.println(method);
        }    
		/*
		// 第二种方式获取Class对象
		Class u2 = User.class;
		System.out.println(u2);

		// 第三种方式获取Class对象
		try {
			Class u3 = Class.forName("com.reflect.User");// 注意此字符串必须是真实路径，就是带包名的类路径，包名.类名
			//判断三种方式，获取结果是否一致
			System.out.println(u2 == u1Class);// 判断第一种方式获取的Class对象和第二种方式获取的是否是同一个
			System.out.println(u3 == u1Class);// 判断三种方式是否获取的是同一个Class对象
			
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
		*/
	}
}

getFields()和getDeclaredFields()

getFields()和getDeclaredFields()都是用来获取成员变量的方法。
getFields()方法获取成员变量，会获取所有public修饰的成员变量，包括父类。
getDeclaredFields()方法会获取本类中所有的成员变量，不考虑修饰符，不包括父类。

getConstructors()和getDeclaredConstructors()

getConstructors()方法获取构造函数，获取本类中所有public修饰的构造函数，不包括父类。
getDeclaredConstructors()方法会获取本类中所有的构造函数，不考虑修饰符，不包括父类。

getMethods()和getDeclaredMethods()

getMethods()方法获取成员方法，获取所有public修饰的成员方法，包括父类和超类。
getDeclaredMethods()会获取本类中所有的成员方法，不考虑修饰符，不包括父类。

参考资料
https://blog.youkuaiyun.com/Mr_wxc/article/details/106003401