Class类的作用

Class类是一个特殊类，它用于表示JVM运行时类或接口的信息。
Class类提供很多方法用于获取类的各种信息，比如获取类名、判断该类是否是一个接口还是普通类等等。
在Java中枚举类是一种类，而注解是一个接口，数组也是一个类；Java原始类型(boolean, byte, char, short, int, long, float, and double)和关键字void也被表示为Class的对象。

你知道吗？
在每一个基本类型的包装类中都有一个共有的静态变量，例如Integer：
public static final Class TYPE = (Class) Class.getPrimitiveClass(“int”);
TYPE就是这个基本类型的Class对象表示。

一个类只有被JVM加载后才能使用，需要经过加载-->验证-->准备-->解析-->初始化五个阶段。
当类被虚拟机加载后都会在内存中创建一个该类的Class对象，用于存储该类的各种信息。
Class类的构造函数被设计为私有的，这意味着我们不能通过new的方式来创建Class对象，只有JVM才能创建该类的实例。因为类的加载不是我们负责的，只有JVM才知道如何加载一个类。

Class类的父类

Class类是java中的一个类和其他非继承类一样，默认的父类也是Object。
可以使用下面的方式验证：

public class ClassParentTest {
	public static void main(String[] args) {
		boolean assignableFrom = Object.class.isAssignableFrom(Class.class);
		System.out.println(assignableFrom);
	}
}

Class#isAssignableFrom(Class<?> cls)方法用于判断cls的实例能否赋值给该Class的引用；换句话说，该方法可以用来判断cls类是否是该Class的子类或者如果Class是接口表示cls是否实现了该接口。
上边那段代码将输出true，说明Class类的父类是Object类。

Class类的forName方法

用于手动加载一个类，该方法是一个公共静态方法，有多个重载。
方法签名：

public static Class<?> forName(String className)
public static Class<?> forName(String name, boolean initialize,ClassLoader loader)
        throws ClassNotFoundException
//下面这个是JDK9新增加的，用于从模块中加载一个类，不对类进行初始化
public static Class<?> forName(Module module, String name) 
//第一个和第二个都是调用下面的native方法forName0来加载类
private static native Class<?> forName0(String name, boolean initialize,
                                        ClassLoader loader,
                                        Class<?> caller)

关于参数boolean initialize
注意这里的参数boolean initialize表示是否对类进行初始化，这里的初始化指的是类加载过程中收集静态代码块和静态变量形成的方法的初始化，不是指类构造函数的执行(构造函数的执行是在类生成实例的时候执行的，是对实例变量的初始化，不要搞混！)。
看下面的例子：

class A{
    private static final int i = 0;//#1
    private static final String str = "hello";//#2
    static {
        System.out.println("static block!"); //#3
    }
    public A(){
        System.out.println("constructor!");
    }
}

在类加载的过程中，会将#1,#2,#3按照顺序收集在一起形成<clinit>方法，为了帮助理解，可以表示成下面的伪代码：

<clinit>() {
	private static final int i = 0;//#1
	private static final String str = "hello";//#2
	System.out.println("static block!"); //#3
 }

参数boolean initialize就是来表示是否在类加载的时候执行这个<clinit>方法！

public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, 			               IllegalAccessException, InvocationTargetException, InstantiationException {
        Class<A> aClass = (Class<A>) Class.forName("com.company.A",
                true,Test4.class.getClassLoader());
}

上边的代码将参数initialize设置为true，执行会输出static block!,说明执行了类的初始化！
如果改成false，将不会输出static block!,也就是不执行类的初始化，这将类的初始化延迟到第一次创建该类的实例！
类的构造函数是类实例化时执行的。

A a = aClass.getConstructor().newInstance();

通过以上方式创建A类的实例将输出constructor!

Class类的isInstance和isAssignableFrom方法

这两个方法都是native方法。

isInstance
方法签名：

public native boolean isInstance(Object obj);

isInstance用于判断obj对象是否是该Class或该Class子类的一个实例。
例如：

String hello = "hello";
boolean isStr = String.class.isInstance(hello);

isStr为true。

boolean is = Number.class.isInstance(Integer.valueOf(1));

is为true,因为Integer是Number的子类。
该方法还可以用于类型转换时，为了避免对象的转换异常，进行类型检查：

public void method(Object str){
		String str1;
		if(String.class.isInstance(str)){
			str1 = (String) str;
		}
}

但是我们一般不会这样写，因为java给我提供了instanceof。

isAssignableFrom
方法签名：

public native boolean isAssignableFrom(Class<?> cls);

该方法用于判断cls的实例能否赋值给该Class的引用；换句话说，该方法可以用来判断cls类是否是该Class的子类或者如果Class是接口表示cls是否实现了该接口。
例如：

  boolean is = Number.class.isAssignableFrom(Integer.class);
  boolean is2 = List.class.isAssignableFrom(ArrayList.class);

is和is2都是true,因为Integer继承了Number，ArrayList间接的实现了List接口。

看Spring中的一段代码（代码摘自MapMethodProcessor类，HandlerMethodArgumentResolver的实现类，用于自动注入Controller方法参数）：

@Override
public boolean supportsParameter(MethodParameter parameter) {
	return Map.class.isAssignableFrom(parameter.getParameterType()) &&
	parameter.getParameterAnnotations().length == 0;
}

它使用isAssignableFrom方法来判断方法参数是否是Map类型。

Class类的isXXXX

Class类还提供了isXXXX的方法，这些方法大多用于判断Class的类型。

Class类还有其他方法，常用的也就那么几个，其他不再写了。。。

JS es6的Class类详解

class基本语法

JavaScript 语言中，生成实例对象的传统方法是通过构造函数和原型的组合模式.ES6 提供了更接近传统语言（java）的写法，引入了 Class（类）这个概念，作为对象的模板。通过class关键字，可以定义类。

class point{
	constructor(x,y){
        this.x=x;
        this.y=y;
    }
    play(){
        console.log("我会玩");
    }
}

ES6 的class可以看作只是一个语法糖，它的绝大部分功能，ES5 都可以做到，新的class写法只是让对象原型的写法更加清晰、更像面向对象编程的语法而已。

注：“语法糖”:是由英国计算机科学家彼得·约翰·兰达（Peter J. Landin）发明的一个术语，指计算机语言中添加的某种语法，这种语法对语言的功能并没有影响，但是更方便程序员使用。

ES6 的class与ES5写法的几个核心注意点：
ES5 的构造函数Point，对应 ES6 的Point类的构造方法。
类的所有方法都定义在类的prototype属性上面。
定义“类”的方法的时候，前面不需要加上function这个关键字，直接把函数定义放进去了就可以了
方法之间不需要逗号分隔，加了会报错
ES6的class使用方法与ES5的构造函数一模一样

//类的所有方法都定义在类的prototype属性上面。
class piont{
    constructor(){
		//
    }
    play(){
        
    }
}
//上述代码等价于
point.prototype={
    constructor() {},
    play(){};
}

//在类的实例上面调用方法，其实就是调用原型上的方法。
class Ba{
	//
}
let b=new Ba();
b.constructor===Ba.prototype.constructor//true

另外：ES5 的构造函数Point，对应 ES6 的Point类的构造方法。

由于类的方法都定义在prototype对象上面，所以类的新方法可以添加在prototype对象上面。Object.assign方法可以很方便地一次向类添加多个方法。

class ponit{
    constructor(){
        
    }
}
Object.assign(Point.prototype,{
	play(){};
})
//Class直接定义的方法之间不需要逗号分隔，加了会报错. 但是这里是Object.assign的方法格式, 这里面需要往Point.prototype里面添加的方法就需要符合对象的默认格式

类的内部所有定义的方法，都是不可枚举的（non-enumerable）。通过Object.assign方法往类的原型上添加的方法,constructor不可枚举, 其他的可以枚举

Class的基本语法之constructor

constructor方法是类的默认方法，通过new命令生成对象实例时，自动调用该方法。一个类必须有constructor方法，如果没有显式定义，一个空的constructor方法会被默认添加。

constructor方法默认返回实例对象（即this），完全可以指定返回另外一个对象
(得是在创造class时就定义设置的, 在创造完class后,通过Object.assign的方式是没法改变构造函数的返回值的).

Class的基本语法之类的调用方式

类必须使用new调用，否则会报错。这是它跟普通构造函数 ( 普通构造函数完全可以当做普通函数使用 ) 的一个主要区别，后者不用new也可以执行。

Class的基本语法之getter和setter

与 ES5 一样，在“类”的内部可以使用get和set关键字，对某个属性设置存值函数和取值函数，拦截该属性的存取行为。

  class demo{
            constructor(age){
                this.age=agie;
                this._age=age;
            }
            get age(){
                return this._age;
            }
            set age(value){
                this._age=value;
                console.log("年龄"+value);
            }
        }
        let kevin=new demo(9);
        kevin.age=18;
        console.log(kevin.age);

Class的基本语法之类的属性名

上面代码中，Square类的方法名getArea，是从表达式得到的。

Class的基本语法的特别注意点

（1）严格模式

类和模块的内部，默认就是严格模式，所以不需要使用use strict指定运行模式。只要你的代码写在类或模块之中，就只有严格模式可用。考虑到未来所有的代码，其实都是运行在模块之中，所以 ES6 实际上把整个语言升级到了严格模式。

（2）不存在提升

new foo（）；

class foo{}；

上面代码中，Foo类使用在前，定义在后，这样会报错，因为 ES6 不会把类的声明提升到代码头部。

（3）name 属性

class point{

}

point.name//point

由于本质上，ES6 的类只是 ES5 的构造函数的一层包装，所以函数的许多特性都被Class继承，包括name属性。

（4）this 的指向

类的方法内部如果含有this，它默认指向类的实例。但是，必须非常小心，一旦单独使用该方法，很可能报错。

printName方法中的this，默认指向Logger类的实例。但是，如果将这个方法提取出来单独使用，this会指向该方法运行时所在的环境（由于 class 内部是严格模式，所以 this 实际指向的是undefined），从而导致找不到print方法而报错。

解决办法：

一个比较简单的解决方法是，在构造方法中绑定this，这样就不会找不到print方法了。

另一种解决方法是使用箭头函数。箭头函数位于构造函数内部，它的定义生效的时候，是在构造函数执行的时候。这时，箭头函数所在的运行环境，肯定是实例对象，所以this会总是指向实例对象。

class Logger{
    constructor(){
        this.printName=this.printName.bind(this);
        //但是请注意bind之后返回的函数里面的this就永久锁死了问题:!!! !!! 坚决别用 
    }
}
//箭头函数
class Obj{
    constructor(){
        this.getThis=()=>this;
    }
}
let o=new Obj();
o.getThis()===o//true

Class的静态属性和方法

类相当于实例的原型，所有在类中定义的方法，都会被实例继承。如果在一个方法前，加上static关键字，就表示该方法不会被实例继承，而是直接通过类来调用，这就称为“静态方法”。

 class Person{
            static sum=0;
            constructor(){
                this.add();
            }
            add(){
                Person.sum++;
            }
        }
        let kaiwen=new Person();
        console.log("当前的聊天室人数为："+Person.sum);
        //作用：当没有实例化的时候，我们可以通过静态的属性和方法去获取一些信息
 // 注意，如果静态方法包含this关键字，这个this指的是类，而不是实例。静态方法可以与非静态方法重名。

父类的静态方法，可以被子类继承静态方法也是可以从super对象上调用的。

 class Person{
            constructor(name){
                this.name=name;
                this.sex="男";
            }
        }
        class Student extends Person{
            constructor(name,age){
                super(name);
                this.age=age;
            }
        }
        let s=new Student("张三",11);
        console.log(s.name);
        console.log(s.age);
        console.log(s.sex);

Class的私有方法和私有属性

私有方法和私有属性:是只能在类的内部访问的方法和属性，外部不能访问。
这是常见需求，有利于代码的封装，但 ES6 不提供，只能通过变通方法模拟实现。

_bar方法前面的下划线，表示这是一个只限于内部使用的私有方法。但是，这种命名是不保险的，在类的外部，还是可以调用到这个方法

下面代码中的写法不仅可以写私有属性，还可以用来写私有方法

 class Cat{
            #eyes="眼睛";
            static pai(){
                console.log("凯文");
            }
            say(){
                Cat.pai();
                console.log("猫有一双大大的"+this.#eyes);
            }
        }
        let kate=new Cat();
        kate.say();

私有属性也可以设置 getter 和 setter 方法。

私有属性不限于从this引用，只要是在类的内部，实例也可以引用私有属性。

构造函数的新属性

ES6 为new命令引入了一个new.target属性，该属性一般用在构造函数之中，返回new命令作用于的那个构造函数。如果构造函数不是通过new命令调用的，new.target会返回undefined，因此这个属性可以用来确定构造函数是怎么调用的。

私有属性也可以设置 getter 和 setter 方法。

私有属性不限于从this引用，只要是在类的内部，实例也可以引用私有属性。

构造函数的新属性

ES6 为new命令引入了一个new.target属性，该属性一般用在构造函数之中，返回new命令作用于的那个构造函数。如果构造函数不是通过new命令调用的，new.target会返回undefined，因此这个属性可以用来确定构造函数是怎么调用的。

Class类与Class对象

Class对象是Class类的实例，类至少包含以下信息，因此class类又可以被 解构为如下部分：

• 权限修饰符
• 类名
• 参数化类型（泛型信息）
• 接口Interface
• 注解Annotation
• 字段Field（重点）
• 构造器Constructor（重点）
• 方法Methd（重点）

以下图为例：

整个.class文件最终都成为字节数组byte[] b，里面的构造器、方法等各个“组件”，其实也是字节。
打开Class类的源代码，发现果然如此：

private static class ReflectionData<T> {
        volatile Field[] declaredFields;
        volatile Field[] publicFields;
        volatile Method[] declaredMethods;
        volatile Method[] publicMethods;
        volatile Constructor<T>[] declaredConstructors;
        volatile Constructor<T>[] publicConstructors;
        // Intermediate results for getFields and getMethods
        volatile Field[] declaredPublicFields;
        volatile Method[] declaredPublicMethods;
        volatile Class<?>[] interfaces;

        // Value of classRedefinedCount when we created this ReflectionData instance
        final int redefinedCount;

        ReflectionData(int redefinedCount) {
            this.redefinedCount = redefinedCount;
        }
    }

而且，针对字段、方法、构造器，因为信息量太大了，JDK还单独写了三个类,比如

Method类：

Field类：

Constructor类：

也就是说，Class类准备了很多东西来标识一个.class文件的信息，并写了三个类，Method,Fileld,Constructor来描述方法、字段、构造器等信息。
比如：

也就是说，Class类准备了很多字段用来表示一个.class文件的信息，对于字段、方法、构造器等，为了更详细地描述这些重要信息，还写了三个类，每个类里面都有很详细的对应

理解反射API

没啥好说的，在日常开发中反射最终目的主要两个：

• 创建实例
• 反射调用方法

创建实例的难点在于，很多人不知道clazz.newInstance()底层还是调用Contructor对象的newInstance()。所以，要想调用clazz.newInstance()，必须保证编写类的时候有个无参构造。

反射调用方法的难点，有两个，初学者可能会不理解。

在此之前，先来理清楚Class、Field、Method、Constructor四个对象的关系：

Field、Method、Constructor对象内部有对字段、方法、构造器更详细的描述。

• 难点一：为什么根据Class对象获取Method时，需要传入方法名+参数的Class类型
  

为什么要传 name和 ParameterType？
因为.class文件中有多个方法，比如：

所以必须传入name，以方法名区分哪个方法，得到对应的Method。

那参数parameterTypes为什么要用Class类型，我想和调用方法时一样直接传变量名不行吗，比如userName， age。

答案是：我们无法根据变量名区分方法

实际上，调用Class对象的getMethod()方法时，内部会循环遍历所有Method，然后根据方法名和参数类型匹配唯一的Method返回。

private static Method searchMethods(Method[] methods,
                                        String name,
                                        Class<?>[] parameterTypes)
    {
        Method res = null;
        String internedName = name.intern();
        for (int i = 0; i < methods.length; i++) {
            Method m = methods[i];
            if (m.getName() == internedName
                && arrayContentsEq(parameterTypes, m.getParameterTypes())
                && (res == null
                    || res.getReturnType().isAssignableFrom(m.getReturnType())))
                res = m;
        }

        return (res == null ? res : getReflectionFactory().copyMethod(res));
    }

难点二：调用method.invoke(obj, args);时为什么要传入一个目标对象？

上面分析过，.class文件通过IO被加载到内存后，JDK创造了至少四个对象：Class、Field、Method、Constructor，这些对象其实都是0101010的抽象表示。

以Method对象为例，它到底是什么，怎么来的？我们上面已经分析过，Method对象有好多字段，比如name（方法名），returnType（返回值类型）等。也就是说我们在.java文件中写的方法，被“解构”以后存入了Method对象中。所以对象本身是一个方法的映射，一个方法对应一个Method对象。

对象的本质就是用来存储数据的。而方法作为一种行为描述，是所有对象共有的，不属于某个对象独有。比如现有两个Person实例

    Person p1 = new Person();
    Person p2 = new Person();

对象 p1保存了"hst"和18，p2保存了"cxy"和20。但是不管是p1还是p2，都会有changeUser()，但是每个对象里面写一份太浪费。既然是共性行为，可以抽取出来，放在方法区共用。

但这又产生了一个棘手的问题，方法是共用的，JVM如何保证p1调用changeUser()时，changeUser()不会跑去把p2的数据改掉呢？

所以JVM设置了一种隐性机制，每次对象调用方法时，都会隐性传递当前调用该方法的对象参数，方法可以根据这个对象参数知道当前调用本方法的是哪个对象！

同样的，在反射调用方法时，本质还是希望方法处理数据，所以必须告诉它执行哪个对象的数据。

所以，把Method理解为方法执行指令吧，它更像是一个方法执行器，必须告诉它要执行的对象（数据）。

当然，如果是invoke一个静态方法，不需要传入具体的对象。因为静态方法并不能处理对象中保存的数据。

参考文章：
【1】https://www.zhihu.com/question/24304289/answer/694344906