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

我们创建了一个类，通过 编译(javac.exe),生成对应的.class文件，之后使用java.exe(JVM的类加载器来完成)加载此.class文件，此.class文件加载到内存以后，就是一个运行时类，存放在缓存区，这个运行时类就是一个
Class的实例。
java.lang.class是反射的源头。
它有如下几个特点：
1.每一个运行时类只加载一次
2.有了Class的实例之后，我们才可以进行如下的操作：
2.1）创建对应的运行时类的对象
2.2）获取对应的运行时类的完整结构（属性、方法、构造器、内部类、父类、所在包、注解、异常…）
2.3）调用对应的运行时类的指定的结构（属性、方法、构造器）
2.4）反射的应用：动态代理。

在正常方式下：我们需要引入需要的“包类”名称——通过new实例化——取得实例化的对象
反射方式：实例化对象——getClass()方法——得到完整的“包类”名称。
这相当于是一个倒序的过程。
如何获取Class实例呢？
Class只有在实例后才能开始进行反射。下面是实例化的四种方式：
1.调用运行时类本身的.class属性
[java] view plain copy
Class clazz1 =Person.class;  
System.out.println(clazz1.getName());  
  
Class clazz2 = String.class;  
System.out.println(clazz2.getName);  

2.通过运行时类的对象获取
[java] view plain copy
Person  p =new Person();  
Class clazz3 = p.getClass();  
System.out.prinln(clazz3.getName());<strong>  
lt;/strong>  

3. 通过Class的静态方法获取(反射的动态性)
[java] view plain copy
String className ="com.arguigu.java.Person";  
Class clazz4 = Class.forName(className);  
//clazz4.newInstance();  
System.out.prinln(clazz4.getName());  

4.通过类的加载器
[java] view plain copy
ClassLoader  classLoader = this.getClass().getClassLoader();  
Class  clazz5 = classLoader.loadClass(className);  
System.out.println(clazz5.getName());  
用途：
1.可以创建对应的运行时类的对象
2.获取对应的运行时类的完整的类的结构：属性/方法/构造器/包/父类/泛型/注解/异常/内部类…
3.可以调用对应的运行时类中指定的结构（某个指定的属性/方法/构造器）

以上就是Class实例化的四种方式

我们创建了一个类，通过
编译(javac.exe),生成对应的.class文件，之后使用java.exe(JVM的类加载器来完成)加载此.class文件，此.class文件加载到内存以后，就是一个运行时类，存放在缓存区，这个运行时类就是一个
Class的实例。
java.lang.class是反射的源头。
它有如下几个特点：


1.每一个运行时类只加载一次
2.有了Class的实例之后，我们才可以进行如下的操作：
2.1）创建对应的运行时类的对象
2.2）获取对应的运行时类的完整结构（属性、方法、构造器、内部类、父类、所在包、注解、异常…）
2.3）调用对应的运行时类的指定的结构（属性、方法、构造器）
2.4）反射的应用：动态代理。


在正常方式下：我们需要引入需要的“包类”名称——通过new实例化——取得实例化的对象
反射方式：实例化对象——getClass()方法——得到完整的“包类”名称。
这相当于是一个倒序的过程。
如何获取Class实例呢？
Class只有在实例后才能开始进行反射。下面是实例化的四种方式：
1.调用运行时类本身的.class属性

		Class clazz1 =Person.class;
		System.out.println(clazz1.getName());
		
		Class clazz2 = String.class;
		System.out.println(clazz2.getName);

2.通过运行时类的对象获取
	Person  p =new Person();
	Class clazz3 = p.getClass();
	System.out.prinln(clazz3.getName());<strong>
</strong>


3.
通过Class的静态方法获取(反射的动态性)

String className ="com.arguigu.java.Person";
Class clazz4 = Class.forName(className);
//clazz4.newInstance();
System.out.prinln(clazz4.getName());


4.通过类的加载器

ClassLoader  classLoader = this.getClass().getClassLoader();
Class  clazz5 = classLoader.loadClass(className);
System.out.println(clazz5.getName());
用途：

1.可以创建对应的运行时类的对象

2.获取对应的运行时类的完整的类的结构：属性/方法/构造器/包/父类/泛型/注解/异常/内部类…
3.可以调用对应的运行时类中指定的结构（某个指定的属性/方法/构造器）


以上就是Class实例化的四种方式，下一篇介绍第四种类加载器ClassLoader的使用。

类的加载过程
程序在经过javac.exe命令后会生成一个或多个字节码文件（.class结尾的文件），接着使用java.exe命令对字节码文件进行解释运行，这时候就把字节码文件加载到内存中。加载到内存中的类成为运行时类，运行时类是Class的实例。
@Test
public void  test() throws ClassNotFoundException {
    //方式1：调用运行时类的属性  .class
    Class cla1 = person.class;
    System.out.println(cla1);

    //方式二：通过运行时类的对象，调用getClass()方法
    person p = new person();
    Class cla2 = p.getClass();
    System.out.println(cla2);

    //方式三：调用Class的静态方法 forName(String classPath)
    Class cla3 = Class.forName("com.reflection.person");
    System.out.println(cla3);

    //方式四：通过类的加载器
    ClassLoader classLoader = reflectionTest.class.getClassLoader();
    Class cla4 = classLoader.loadClass("com.reflection.person");
    System.out.println(cla4);

    System.out.println(cla1 == cla2);
    System.out.println(cla1 == cla3);
    System.out.println(cla1 == cla4);

//运行结果
//true
//true
//true
//说明是同一个运行时类
}