1.调用运行时类本身的.class属性
 

Class clazz = Person.class;
2.通过运行时类的对象获取
 
Person p = new Person();
Class clazz = p.getClass();
 
3.通过Class的静态方法获取:体现反射的动态性
 

Class clazz = Class.forName("java.util.commons");
4.通过类的加载器
 

String className = "java.util.commons";
ClassLoader cl = this.getClass().getClassLoader();
Class clazz = cl.loaderClass(className);

随笔---------------------------------------获取Class类的4种方式-----------------------------------------------------------------------------------------
 

 
 
1.调用运行时类本身的.class属性
 
Class clazz = String.class;
 
2,通过运行时类的对象获取
 
Person p = new Person();
 
Class clazz = p.getClass();
 
3.通过Class的静态方法获取:体现反射的动态性
 
String className = “java.util.commons”;
 
Class clazz = Class.forName(className);
 
4.通过类的加载器
 
String className = “java.util.commons”;
 
ClassLoader classLoader = this.getClass().getClassLoader();
 
Class clazz = classLoader.loadClass(className);
 

 
 
扩展：
 
类加载起分为三种：系统类加载器：ClassLoader.getSystemClassLoader()
 
   扩展类加载器：ClassLoader.getSystemClassLoader().getParent()
 
  引导类加载器(核心库、对象----如String，Object)：无法直接获取
 
配置文件读取：如在包com.test.java下有配置文件jdbc.properties
 
    内容为：user = root           password=pd123
 
   类加载器加载（指定目录如：com.test.java）：
 
   ClassLoader classLoader = this.getClass().getClassLoader();
    InputStream is = classLoader.getResourceAsStream("com/test/java/jdbc.properties");
      Properties properties = new Properties();
    properties.load(is);
    String user = properties.getProperty("user");
    System.out.println(user);
 
   文件字节输入流加载（根目录：src）：
 //对比FileInputStream获取当前项目根目录下的文件
    FileInputStream is = new FileInputStream(new File("jdbc.properties"));
 
   Properties properties = new Properties();
    properties.load(is);
    String user = properties.getProperty("user");
    System.out.println(user);
 
 
得到Class 后得到对应对象的实例--------------> class.newInstance() <------- 需要对应的对象有空参的构造器以及对应的调用构造器权限

1.通过ClassLoader对象的loadClass()方法
 
比如以下方式：
 
  ClassLoader.getSystemClassLoader().loadClass("com.my.test.Hello")
 
去看一下loadClass的源码：
 
public Class<?> loadClass(String name) throws ClassNotFoundException {
        return loadClass(name, false);
    }
 
最终调用：
 
//可以看到参数resolve的解释，如果为true才会对这个类进行resolve
 /* @param  resolve
     *         If <tt>true</tt> then resolve the class
     * */
 protected Class<?> loadClass(String name, boolean resolve)
        throws ClassNotFoundException
    {
        synchronized (getClassLoadingLock(name)) {
            // First, check if the class has already been loaded
            Class<?> c = findLoadedClass(name);
            if (c == null) {
                long t0 = System.nanoTime();
                try {
                    if (parent != null) {
                        c = parent.loadClass(name, false);
                    } else {
                        c = findBootstrapClassOrNull(name);
                    }
                } catch (ClassNotFoundException e) {
                    // ClassNotFoundException thrown if class not found
                    // from the non-null parent class loader
                }

                if (c == null) {
                    // If still not found, then invoke findClass in order
                    // to find the class.
                    long t1 = System.nanoTime();
                    c = findClass(name);

                    // this is the defining class loader; record the stats
                    sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
                    sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
                    sun.misc.PerfCounter.getFindClasses().increment();
                }
            }
            if (resolve) {
                resolveClass(c);
            }
            return c;
        }
    }

 
resolve其实是连接过程（验证verification，准备preparation，解析resolution），具体代码如下：
 
 /**
     * Links the specified class.  This (misleadingly named) method may be
     * used by a class loader to link a class.  If the class <tt>c</tt> has
     * already been linked, then this method simply returns. Otherwise, the
     * class is linked as described in the "Execution" chapter of
     * <cite>The Java&trade; Language Specification</cite>.
     *
     * @param  c
     *         The class to link
     *
     * @throws  NullPointerException
     *          If <tt>c</tt> is <tt>null</tt>.
     *
     * @see  #defineClass(String, byte[], int, int)
     */
    protected final void resolveClass(Class<?> c) {
        resolveClass0(c);
    }

    private native void resolveClass0(Class<?> c);
 
可以看到，ClassLoader对象的loadClass()方法传入的resolve值为false，因此它不会对类进行连接这一过程，根据类的生命周期我们知道，如果一个类没有进行验证和准备的话，是无法进行初始化过程的，也就是说该方法的调用不会导致初始化<cinit>的执行。
 
2. 类名.class
 
Class a=Test.class
 
该种方式同样不会对类进行初始化。
 
3. Class.forName()
 
Class test = Class.forName("com.my.Test");
 
forName函数的源码如下：
 
 public static Class<?> forName(String className)
                throws ClassNotFoundException {
        Class<?> caller = Reflection.getCallerClass();
        return forName0(className, true, ClassLoader.getClassLoader(caller), caller);
    }

 
forName0是一个native方法。调用forName(string)方法等同于调用Class.forName(className, true, currentLoader)方法。源码如下：
 
 public static Class<?> forName(String name, boolean initialize,
                                   ClassLoader loader)
        throws ClassNotFoundException
    {
        Class<?> caller = null;
        SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            // Reflective call to get caller class is only needed if a security manager
            // is present.  Avoid the overhead of making this call otherwise.
            caller = Reflection.getCallerClass();
            if (sun.misc.VM.isSystemDomainLoader(loader)) {
                ClassLoader ccl = ClassLoader.getClassLoader(caller);
                if (!sun.misc.VM.isSystemDomainLoader(ccl)) {
                    sm.checkPermission(
                        SecurityConstants.GET_CLASSLOADER_PERMISSION);
                }
            }
        }
        return forName0(name, initialize, loader, caller);
    }
 
initialize为true表示会进行初始化initialization步骤，即静态初始化（会初始化类变量，静态代码块）。
 
这也就是为什么加载MySQL等一些数据库驱动程序的时候要使用这个方法的原因。比如MySQL的数据库驱动中有如下代码：
 
static {
    try {
        java.sql.DriverManager.registerDriver(new Driver());
    } catch (SQLException E) {
        throw new RuntimeException("Can't register driver!");
    }
}
 
需要使用forName方式加载使得静态代码块得以初始化。
 
4.object.getClass()
 
这个方法没什么好说的了，你通过一个对象调用其getClass()方法能获得其对应类的Class对象，既然对象已经存在了，那么说明这个类已经被装载到了虚拟机中。
 
public final native Class<?> getClass();

//综合最好的方法是第三种方法
/*
*法一：是通过类对象来获取class的
*法二：通过类直接调class
*法三：通过Class.forName();
*/
package hncu.reflect.getClass;
import java.lang.reflect.Method;

import org.junit.Test;

import hncu.Demo.Person;

import hncu.Demo.Student;

public class ReflectGetClass {


 @Test


 //法一：通过getClass的对象获取


 public void demo1(){


 Person p=new Person();


 Class c=p.getClass();


 //Method ms[]=c.getMethods();//该方式获得的方法包括其父类的public方法


 Method ms[]=c.getDeclaredMethods();//该方式获取不包括父类方法


 for(Method s:ms){


 System.out.println(s);


 System.out.println("------------------------");


 }


 }


 


 //任何数据的类型都包含一个静态属性class，通过他可以直接获取对应放入Class对象


 /**


  * 


  */


 @Test//法二：通过Class.forName()方法获取。这种方式仅需使用类名，就可以获取该类的Class对象，更有利于扩展。


 public void demo2(){

//
 Class c=Person.class;


 Class c=Student.class;


 


 Method ms[]=c.getDeclaredMethods();//该方式获取不包括父类的方法


 for(Method s:ms){


 System.out.println(s);


 System.out.println("------------------------");


 }


 


 


 }


 


 @Test//法三：通过Class.forName()方法获取。


 public void demo3() throws Exception{


 String name=new String("hncu.Demo.Person");//此处的name必须是类全名即导的包的路径加上方法类名


 Class c=Class.forName(name);
 


 System.out.println(c);


 


 }


 


 


}
package hncu.Demo;


public class Person {
 private String name;
 private int age;
 public Person(){
 
 }
 
 public Person(String name ,int age){
 this.name=name;
 this.age=age;
 }


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


 @Override
 public String toString() {
 return "name=" + name + ", age=" + age;
 }
 public  void bb(){
 System.out.println(3);
 }
 
 
 
}