一，Class类有什么用？

   Class类的实例表示java应用运行时的类(class and enum)或接口(interface and annotation)（每个java类运行时都在JVM里表现为一个class对象，可通过类名.class, 类型.getClass(), Class.forName("类名")等方法获取class对象）。数组同样也被映射为为class 对象的一个类，所有具有相同元素类型和维数的数组都共享该 Class 对象。基本类型boolean，byte，char，short，int，long，float，double和关键字void同样表现为 class  对象。

 

二，Class类的特征

    Class类没有公有的构造方法，它由JVM自动调用（在new对象或者加载-classLoader时）。

    下面的方法作用是打印出对象的class name：

 void printClassName(Object obj) {

         System.out.println("The class of " + obj +

                            " is " + obj.getClass().getName());

   }

  同样可以根据class literal 获得class name：

  System.out.println("The name of class Foo is: "+Foo.class.getName());//你可以将Foo改为void尝试下。

三，Class的主要方法


Class类的方法还是挺多的。主要是用于得到运行时类的相关信息(可用于反射)。

  重要的几个方法：

1， public static Class<?> forName(String className) ：native 方法，动态加载类。非常重要。

       如在sql中动态加载驱动程序:class.forName(sqlDriver);

2，public T newInstance() ：根据对象的class新建一个对象，用于反射。非常重要。

       可用在反射中构建对象，调用对象方法：

       class doubleClass= class.forName("java.lang.Double");

       Object objDouble = doubleClass.newInstance();

       如在javaBean中就应用了这个方法，因为java默认要有一个无参构造函数。

3， public ClassLoader getClassLoader() ：获得类的类加载器Bootstrap  ，Extension ,System or user custom      ClassLoader(一般为system classloader)。重要。

 

4，public String getName() ：获取类或接口的名字。记住enum为类，annotation为接口。重要

5，public native Class getSuperclass()：获取类的父类，继承了父类则返回父类，否则返回java.lang.Object。返回Object的父类为空-null。一般

6，public java.net.URL getResource(String name) ：根据字符串获得资源。

7，其他类 

 public boolean isEnum() ：判断是否为枚举类型。

 public native boolean isArray() ：判断是否为数组类型。

 public native boolean isPrimitive() ：判断是否为基本类型。

 public boolean isAnnotation() ：判断是否为注解类型。



public Package getPackage() ：反射中获得package，如java.lang.Object 的package为java.lang。

public native int getModifiers() ： 反射中获得修饰符，如public static void等 。

public Field getField(String name)：反射中获得域成员。

public Field[] getFields() :获得域数组成员。    

public Method[] getMethods() ：获得方法。

public Method getDeclaredMethod(String name, Class<?>... parameterTypes)：加个Declared代表本类，继承，父类均不包括。

public Constructor<?>[] getConstructors() ：获得所有的构造函数。

如此我们可以知道反射可以运行时动态获得类的所有信息，并新建对象（newInstance()方法）。

如我们定义一个类：

public class Test{

   //Constructor

   public Test(){this("");}

   public Test(String name){}

   //Field

   public int id;

   public String name;

   //Method

   public void testMethod(){



   }

}



我们可以:

Class c = Class.forName("Test");
Method m[] = c.getDeclaredMethods();
for (int i = 0; i < m.length; i++)
   System.out.println(m[i].toString());//输出testMethod
}

Constructor c[] = cls.getDeclaredConstructors();
for (int i = 0; i < c.length; i++) {
   Constructor ct = c[i];
System.out.println("name = " + ct.getName());//输出两个构造函数信息



没时间写了，别人用电脑了。。。。

 

 

1、Class类简介：
 Java程序在运行时，Java运行时系统一直对所有的对象进行所谓的运行时类型标识。这项信息纪录了每个对象所属的类。虚拟机通常使用运行时类型信息选准正确方法去执行，用来保存这些类型信息的类是Class类。Class类封装一个对象和接口运行时的状态，当装载类时，Class类型的对象自动创建。

      Class 没有公共构造方法。Class 对象是在加载类时由Java 虚拟机以及通过调用类加载器中的 defineClass 方法自动构造的，因此不能显式地声明一个Class对象。 

      虚拟机为每种类型管理一个独一无二的Class对象。也就是说，每个类（型）都有一个Class对象。运行程序时，Java虚拟机(JVM)首先检查是否所要加载的类对应的Class对象是否已经加载。如果没有加载，JVM就会根据类名查找.class文件，并将其Class对象载入。

      基本的 Java 类型（boolean、byte、char、short、int、long、float 和 double）和关键字 void 也都对应一个 Class 对象。 

      每个数组属于被映射为 Class 对象的一个类，所有具有相同元素类型和维数的数组都共享该 Class 对象。

      一般某个类的Class对象被载入内存，它就用来创建这个类的所有对象。


一、如何得到Class的对象呢？有三种方法可以的获取：
  1、调用Object类的getClass()方法来得到Class对象，这也是最常见的产生Class对象的方法。例如：

    MyObject x;

    Class c1 = x.getClass();
 2、使用Class类的中静态forName()方法获得与字符串对应的Class对象。例如： 

    Class c2=Class.forName(“MyObject”),Employee必须是接口或者类的名字。
3、获取Class类型对象的第三个方法非常简单。如果T是一个Java类型，那么T.class就代表了匹配的类对象。例如

    Class cl1 = Manager.class;

    Class cl2 = int.class;

    Class cl3 = Double[].class;

    注意：Class对象实际上描述的只是类型，而这类型未必是类或者接口。例如上面的int.class是一个Class类型的对象。由于历史原因，数组类型的getName方法会返回奇怪的名字。
二、Class类的常用方法
1、getName() 
一个Class对象描述了一个特定类的属性，Class类中最常用的方法getName以 String 的形式返回此 Class 对象所表示的实体（类、接口、数组类、基本类型或 void）名称。
2、newInstance()
Class还有一个有用的方法可以为类创建一个实例，这个方法叫做newInstance()。例如：

    x.getClass.newInstance()，创建了一个同x一样类型的新实例。newInstance()方法调用默认构造器（无参数构造器）初始化新建对象。
3、getClassLoader() 
返回该类的类加载器。
   4、getComponentType() 

    返回表示数组组件类型的 Class。
   5、getSuperclass() 

    返回表示此 Class 所表示的实体（类、接口、基本类型或 void）的超类的 Class。
   6、isArray() 

    判定此 Class 对象是否表示一个数组类。
三、Class的一些使用技巧
1、forName和newInstance结合起来使用，可以根据存储在字符串中的类名创建对象。例如

    Object obj = Class.forName(s).newInstance();
2、虚拟机为每种类型管理一个独一无二的Class对象。因此可以使用==操作符来比较类对象。例如：

    if(e.getClass() == Employee.class)…
2、 Class.forName()方法:
Class.forName：返回与给定的字符串名称相关联类或接口的Class对象。
Class.forName是一个静态方法，同样可以用来加载类。该方法有两种形式：Class.forName(String name, boolean initialize, ClassLoader loader)和 Class.forName(String className)。第一种形式的参数 name表示的是类的全名；initialize表示是否初始化类；loader表示加载时使用的类加载器。第二种形式则相当于设置了参数 initialize的值为 true，loader的值为当前类的类加载器。


static Class<?>


forName(String className)
Returns the Class object associated with the class or interface with the given string name.


static Class<?>


forName(String name,
 boolean initialize, ClassLoader loader)
Returns the Class object associated with the class or interface with the given string name, using the given
 class loader.


说明：
publicstatic Class<?> forName(String className)
Returns the Class object associated withthe class or interface with the given string name.
Invokingthis method is equivalent to:
Class.forName(className,true, currentLoader)
where currentLoader denotes the definingclass loader of the current class.
For example, thefollowing code fragment returns the runtime Class descriptor for theclass named java.lang.Thread:
Class t =Class.forName("java.lang.Thread")
A call to forName("X") causes theclass named X to
 beinitialized.
Parameters:
className - the fully qualifiedname of the desired class.
Returns:
the Class object for the classwith the specified name.
从官方给出的API文档中可以看出:
Class.forName(className)实际上是调用Class.forName(className,true, this.getClass().getClassLoader())。第二个参数，是指Class被loading后是不是必须被初始化。可以看出，使用Class.forName（className）加载类时则已初始化。
所以Class.forName(className)可以简单的理解为：获得字符串参数中指定的类，并初始化该类。
 
 一.首先你要明白在java里面任何class都要装载在虚拟机上才能运行。
1.      forName这句话就是装载类用的(new是根据加载到内存中的类创建一个实例，要分清楚)。 
2.      至于什么时候用，可以考虑一下这个问题，给你一个字符串变量，它代表一个类的包名和类名，你怎么实例化它？
           A a = (A)Class.forName(“pacage.A”).newInstance();这和 A a =new A();是一样的效果。
3.      jvm在装载类时会执行类的静态代码段，要记住静态代码是和class绑定的，class装载成功就表示执行了你的静态代码了，而且以后不会再执行这段静态代码了。
4.      Class.forName(xxx.xx.xx)的作用是要求JVM查找并加载指定的类，也就是说JVM会执行该类的静态代码段。
5.      动态加载和创建Class 对象，比如想根据用户输入的字符串来创建对象
       String str = 用户输入的字符串  
       Class t = Class.forName(str);  
       t.newInstance(); 
 二.在初始化一个类，生成一个实例的时候，newInstance()方法和new关键字除了一个是方法，一个是关键字外，最主要有什么区别？
      1.它们的区别在于创建对象的方式不一样，前者是使用类加载机制，后者是创建一个新类。
      2.那么为什么会有两种创建对象方式？
        这主要考虑到软件的可伸缩、可扩展和可重用等软件设计思想。  

        Java中工厂模式经常使用newInstance()方法来创建对象，因此从为什么要使用工厂模式上可以找到具体答案。例如：
           class c = Class.forName(“Example”);  
           factory = (ExampleInterface)c.newInstance();  
       其中ExampleInterface是Example的接口，可以写成如下形式：
          String className = “Example”;  
          class c = Class.forName(className);  
          factory = (ExampleInterface)c.newInstance();  
      进一步可以写成如下形式：
          String className = readfromXMlConfig;//从xml 配置文件中获得字符串
         class c = Class.forName(className);  
         factory = (ExampleInterface)c.newInstance();  
        上面代码已经不存在Example的类名称，它的优点是，无论Example类怎么变化，上述代码不变，甚至可以更换Example的兄弟类Example2 , Example3 , Example4……，只要他们继承ExampleInterface就可以。  

        3.从JVM的角度看，我们使用关键字new创建一个类的时候，这个类可以没有被加载。  但是使用newInstance()方法的时候，
         就必须保证：
              1、这个类已经加载；
              2、这个类已经连接了。
        而完成上面两个步骤的正是Class的静态方法forName()所完成的，这个静态方法调用了启动类加载器，即加载 java API的那个加载器。  

         现在可以看出，newInstance()实际上是把new这个方式分解为两步，即首先调用Class加载方法加载某个类，然后实例化。这样分步的好处是显而易见的。我们可以在调用class的静态加载方法forName时获得更好
         的灵活性，提供给了一种降耦的手段。  
三.最后用最简单的描述来区分new关键字和newInstance()方法的区别： 
1. newInstance: 弱类型。低效率。只能调用无参构造。  

         2. new: 强类型。相对高效。能调用任何public构造。
3、应用情景：
情景一：加载数据库驱动的时候
Class.forName的一个很常见的用法是在加载数据库驱动的时候。
如：

[java] view plain copy
 print?
Class.forName(“com.microsoft.sqlserver.jdbc.SQLServerDriver”);  
Connection con=DriverManager.getConnection(”jdbc:sqlserver://localhost:1433;DatabaseName==JSP”,“jph”,“jph”);      
Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver");
Connection con=DriverManager.getConnection("jdbc:sqlserver://localhost:1433;DatabaseName==JSP","jph","jph");    


  为什么在我们加载数据库驱动包的时候有的却没有调用newInstance( )方法呢？

即有的jdbc连接数据库的写法里是Class.forName(xxx.xx.xx);而有一些：Class.forName(xxx.xx.xx).newInstance()，为什么会有这两种写法呢？ 
刚才提到，Class.forName(“”);的作用是要求JVM查找并加载指定的类，如果在类中有静态初始化器的话，JVM必然会执行该类的静态代码段。
而在JDBC规范中明确要求这个Driver类必须向DriverManager注册自己，即任何一个JDBCDriver的Driver类的代码都必须类似如下： 

          public 
classMyJDBCDriver implements Driver {





    static{ 
       DriverManager.registerDriver(new MyJDBCDriver());



   } 
   } 
  既然在静态初始化器的中已经进行了注册，所以我们在使用JDBC时只需要Class.forName(XXX.XXX);就可以了。
情景二：使用AIDL与电话管理Servic进行通信
Method method =Class.forName(“android.os.ServiceManager”)
         .getMethod(“getService”,String.class);
// 获取远程TELEPHONY_SERVICE的IBinder对象的代理
IBinder binder =(IBinder) method.invoke(null, new Object[] {
TELEPHONY_SERVICE});
// 将IBinder对象的代理转换为ITelephony对象
ITelephonytelephony = ITelephony.Stub.asInterface(binder);
// 挂断电话
telephony.endCall();


参考资料：
JDK1.8_API…/docs/api/java/lang/Class.html

http://www.ibm.com/developerworks/cn/java/j-lo-classloader/

            

Copyright©Stonee

在Java中，无论是类还是接口，它们在JVM的内存逻辑模型中都会存在Super和Class指针，分别指向根类（Object类）和反射类（Class类）

在这一篇blog中会了解到很多常用方法，建议大家看api

1. 位置和内容

Object类和Class类都位于 java.lang. 包中，使用时均无需导入
我们可以在jdk或者IDE甚至是官方文档中找到，当然，也可以利用reflect类中的方法写个小程序来找到他们的内容（一会有讨论）

public class java.lang.Object
{
  public java.lang.Object();

  protected void finalize();
  public final native void wait(long);
  public final void wait(long, int);
  public final void wait();
  public boolean equals(java.lang.Object);
  public java.lang.String toString();
  public native int hashCode();
  public final native java.lang.Class getClass();
  protected native java.lang.Object clone();
  public final native void notify();
  public final native void notifyAll();
  private static native void registerNatives();
}


关于class的就不再详细列出

2. Object类

Object类是每个类的始祖，Java中的任何一个类都是由Object类扩展而来，但不用写class a extends Object，无论是否指出，Object都被认为是此类的直接超类或间接超类。所以任何类都可以调用Object类中方法

基本操作



使用Object的变量引用各种类型的方法：Object obj = new A();




同时，当一个函数的形参是 object 的话，就说明可以传递object的子类，即任意一种类，具体可以参考我的另一篇博客，Java中用Object实现任意参数




通过强制类型转换来实现子类的具体操作： A a = (A) obj;但是需要注意，这种向下转型极有可能出错：




如下

Object obj = new A();
A aa = (A) obj;     //正确

Object obj = new B();
A ab = (A) obj;     //错误


相信大家可以看到，向下转型的条件必须是父类指向转型类的实例

常用方法

在平时编写子类的时候，经常要重写Object中的几个方法，如下：


public boolean equals(Object obj)

底层的实现过程为：
public boolean equals(Object obj) {   
    
    return (this == obj);
}


检测两个对象是否具有相通的引用，其中“==”比较的是地址值。下面是一个重写的例子：

class a {
    private int a;
    public a( int a){
        this.a = a;
    }
    public boolean equals(a obj){
        return this.a == obj.a;
    }
}


public native int hashCode();


在Java应用程序执行期间，无论何时在同一个对象上多次调用它，hashCode方法都必须始终返回相同的整数，前提是不修改对象上等号比较中使用的信息。从应用程序的一次执行到同一应用程序的另一次执行，此整数不必保持一致。

如果根据equals(Object)方法，两个对象是相等的，那么在每个对象上调用hashCode方法必须产生相同的整数结果。

但是并没有强制要求如果equals()判断两个对象不相等，那么它们的hashCode()方法就应该返回不同的值。


public String toString()


底层实现为：

public String toString() {   
    return getClass().getName() + "@" + Integer.toHexString(hashCode());
}


Object中的toString返回的是：包名+类名+@+对象hashCode的16进制。所以当我们需要将派生类中进行字符串转换时，也需要重写toString方法


public final native Class<?> getClass();


取得该类已经被实例化了的对象的该类的引用，这个引用指向的是Class类的对象

3. Class类

Java程序在运行时，Java运行时系统一直对所有的对象进行所谓的运行时类型标识，即所谓的RTTI。这项信息纪录了每个对象所属的类。虚拟机通常使用运行时类型信息选准正确方法去执行，用来保存这些类型信息的类是Class类。Class类封装一个对象和接口运行时的状态，当装载类时，Class类型的对象自动创建。



注意Class和class
类没有公共构造函数。相反，当类装入器调用某个defineClass方法并传递类文件的字节时， 类对象由Java虚拟机自动构造 。

获得Class类对象的几种方法

假设 a 为一个类对象，则获得a的类对象：


Class c = a.getClass()
Class c = Class.forName(a) 但是由于传入的a可能不是类实例，所以此处应提供一个异常处理器，否则会抛出checkedexception异常
Class c = int.class;  注意，int需要先自动装箱，使用这种办法生成Class类对象时，不会使JVM自动加载该类（如Integer类）。而其他办法会使得JVM初始化该类。

使用Class类的对象来生成目标类的实例

动态创建类实例

    Class c = Class.forName(a); 
    Object aInstance=obj.newInstance();

4. 附：通过反射类查找类中具体的字段和方法的java程序
package chapter05;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.Scanner;

/**
 * This program uses reflection to print all features of a class
 * @version 1.0 2019-04-7
 * @author stonee(http://www.stonee.club)
 */

public class ReflectionTest {
    public static void main(String [] args){

        //read class name from command line args or user input

        int flag = 1;
        String name;    //class name
        Scanner input = new Scanner(System.in);
        while(flag == 1){
            if (args.length > 0)    //from command line args
                name = args[0];
            else{   //from user input
                System.out.println("Enter class name (e.g. java.util.Date) : ");
                name = input.next();
            }

            try {
                //print class name and superClass name

                Class c1 = Class.forName(name);     //get class
                Class superC1 = c1.getSuperclass();     //get superClass

                String modifiers = Modifier.toString(c1.getModifiers());    //get the "public" to string

                if (modifiers.length() > 0)
                    System.out.print(modifiers + " ");  //print the "public"

                System.out.print("class " + name);  //print the class name

                if (superC1 != null && superC1 != Object.class)
                    System.out.print(" extends " + superC1.getName());  //print the superClass if have

                System.out.print("\n{\n");  //print "{"

                printConstructors(c1);
                System.out.println();
                printMethods(c1);
                System.out.println();
                printField(c1);
                System.out.println("}");

            }
            catch (ClassNotFoundException e){
                e.printStackTrace();
            }

            //System.exit(0);
            System.out.println("Do you wanna go on this program ?(1 or 0)");
            flag = input.nextInt();
        }
    }

    /**
     * prints all constructors of a class
     * @param c1 a class
     */
    private static void printConstructors(Class c1){

        Constructor [] constructors = c1.getDeclaredConstructors(); //返回这个类或接口所有共有方法，不包括继承

        for (Constructor c:
             constructors) {

            String name = c.getName();
            System.out.print("  ");

            String modifiers = Modifier.toString(c.getModifiers());    //get the "public" to string

            if (modifiers.length() > 0)
                System.out.print(modifiers + " ");  //print the "public"

            System.out.print(name + "(");

            // print parameter types
            Class [] paramTypes = c.getParameterTypes();
            for (int i = 0; i < paramTypes.length; i++){
                if (i > 0)
                    System.out.print(", ");
                System.out.print(paramTypes[i].getName());
            }
            System.out.println(");");
        }

    }

    private static void printMethods(Class c1){
        Method[] methods = c1.getDeclaredMethods();

        for (Method m:
             methods) {

            Class retType = m.getReturnType();  //得到返回值
            String name = m.getName();

            System.out.print("  ");

            //print modifiers, return type and method name
            String modifiers = Modifier.toString(m.getModifiers());    //get the "public" to string

            if (modifiers.length() > 0)
                System.out.print(modifiers + " ");  //print the "public"

            System.out.print(retType.getName() + " " + name + "("); //打印方法的返回值和方法名

            //print the parameter types
            Class [] paramTypes = m.getParameterTypes();
            for (int i = 0; i < paramTypes.length; i++){
                if (i > 0)
                    System.out.print(", ");
                System.out.print(paramTypes[i].getName());
            }
            System.out.println(");");

        }
    }

    private static void printField(Class c1) {
        Field[] fields = c1.getDeclaredFields();

        for (Field f :
                fields) {

            Class fType = f.getType();  //得到返回值
            String name = f.getName();

            System.out.print("  ");

            //print modifiers, return type and method name
            String modifiers = Modifier.toString(f.getModifiers());    //get the "public" to string

            if (modifiers.length() > 0)
                System.out.print(modifiers + " ");  //print the "public"

            System.out.print(fType.getName() + " " + name + ";" ); //打印方法的返回值和方法名
            System.out.println();

        }
    }
}

序言
在es6 中的class关键字用于声明类，在此之前js一直没有类的概念，本文只要讨论class的与es5中对象的关系以及class中constructor的作用
关键字class
ES6 的class可以看作只是一个语法糖,而类本身可以看作一个构造函数
class A {
	hello() {}
}
typeof A //function

首先验证类型，OK确实为函数，既然是构造函数，当然能够new一个实例，继续
class A {
	hello() {}
}
console.log(new A());

结果如下



仔细观察，我们在类中声明的hello函数出现在了实例A的原型上，那么得出结论类中声明的函数实际上是绑定在原型上的，故上述代码等价于
class A {
	hello() {}
}
// 等于
function A() {}
A.prototype.hello = function() {};

既然说到原型，那么来看一下类的原型与es5中构造函数的原型是否一致。
class A {
	hello() {}
}
A.prototype.constructor === A // true

与es5一致，同样构造函数原型的constructor指向它本身。
这样看来实例的构造函数是否就与类相等呢？实际并不是，之前的结论说过class只是一个语法糖，里面还有constructor
class中的constructor
constructor方法在这里实质就是构造方法，通过new生成实例会自动调用，如果类型没有定义constructor则会默认添加
class A {
	constructor() {
		this.a = 'a';
		this.b = 'b';
	}
	hello() {}
}
console.log(new A());



这里不难看出constructor才是实例A的构造函数，写在constructor外部的可以理解为绑定在构造函数的原型上。
相关文档：http://es6.ruanyifeng.com/#docs/class