精华内容
下载资源
问答
  • 2021-01-11 13:32:45

    概述

        在ES6中,class (类)作为对象的模板被引入,可以通过 class 关键字定义类。它可以被看作一个语法糖,让对象原型的写法更加清晰、更像面向对象编程的语法。
        类实际上是个“特殊的函数”,就像你能够定义的函数表达式和函数声明一样,类语法有两个组成部分:类表达式和类声明。

    严格模式

        类和模块的内部,默认就是严格模式,所以不需要使用 use strict 指定运行模式

    类的声明

    定义一个类的一种方法是使用一个类声明,即用带有class关键字的类名(这里是“Rectangle”)
    函数名和实例化构造名相同且大写(非强制)

    class Person {
    	constructor(x, y) {
        this.x = x
        this.y = y
      }
    }
    

    函数声明和类声明之间的一个重要区别是函数声明会提升,类声明不会。需要先进行声明,再去访问,否则会报错 

    var person= new Person()
    class Person {
    	constructor(x, y) {
        this.x = x
        this.y = y
      }
    }
    // Personis not defined
    

    类声明不可以重复

    class Person {}
    class Person {}
    // TypeError Identifier 'Person' has already been declared
    

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

    class Person {
    	constructor(x, y) {
        this.x = x
        this.y = y
      }
    }
    Person()
    // TypeError Class constructor Person cannot be invoked without 'new'
    

    类表达式(类定义)

    类表达式可以是被命名的或匿名的

    /* 匿名类 */ 
    let Person = class {
      constructor(x, y) {
        this.x = x
        this.y = y
      }
    }
    
    /* 命名的类 */ 
    let Person = class Person {
      constructor(x, y) {
        this.x = x
        this.y = y
      }
    }
    

    类的方法

    constructor 方法

        constructor 方法是类的默认方法,通过 new 命令生成对象实例时,自动调用该方法(默认返回实例对象 this)。一个类必须有 constructor 方法,如果没有显式定义,一个空的 constructor 方法会被默认添加。一个类只能拥有一个名为 “constructor” 的特殊方法,如果类包含多个 constructor 的方法,则将抛出 一个 SyntaxError 。

    class Person {
       constructor(x, y) {
        this.x = x    // 默认返回实例对象 this
        this.y = y
      }
      toString() {
        console.log(this.x + ', ' + this.y)
      }
    }
    

    注意:

    1. 在类中声明方法的时候,方法前不加 function 关键字
    2. 方法之间不要用逗号分隔,否则会报错
    3. 类的内部所有定义的方法,都是不可枚举的(non-enumerable)
    4. 一个类中只能拥有一个 constructor 方法

    静态方法

        静态方法可以通过类名调用,不能通过实例对象调用,否则会报错

    class Person {
        static sum(a, b) {
            console.log(a + b)
        }
    }
    var p = new Person()
    Person.sum(1, 2)  // 3
    p.sum(1,2)     //  TypeError p.sum is not a function
    

    原型方法

        类的所有方法都定义在类的 prototype 属性上面,在类的实例上面调用方法,其实就是调用原型上的方法
        原型方法可以通过实例对象调用,但不能通过类名调用,会报错

    class Person {
    	constructor() {
    		// 默认返回实例对象 this
    	}
        sum() {
        	
        }
        toString() {
        	console.log('123456')
      	}
    }
    // 给 Person 的原型添加方法
    Person.prototype.toVal = function() {
    	console.log('I am is toVal')
    }
    
    // 等同于
    Person.prototype = {
      constructor() {},
      sum() {},
      toString() {}
    }
    
    var p = new Person()
    p.toString()       // 123456
    p.toVal()          // I am is toVal
    Person.toString()  // TypeError Person.toStringis not a function
    Person.toVal()  // TypeError Person.toVal is not a function
    

     实例方法

        实例方法也可以通过实例对象调用,但同样不能通过类名调用,会报错

    class Person {
        constructor() {
            this.sum = function(a, b) {
                console.log(a + b)
            }
        }
    }
    var p = new Person()
    p.sum(1,2)       // 3
    Person.sum(1,2)  // TypeError Person.sum is not a function
    

     

    更多相关内容
  • Java中的Class类

    千次阅读 2021-03-23 11:21:40
    Class类的作用 Class类是一个特殊类,它用于表示JVM运行时类或接口的信息。 Class类提供很多方法用于获取类的各种信息,比如获取类名、判断该类是否是一个接口还是普通类等等。 在Java中枚举类是一种类,而注解是一...

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

    isStrtrue

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

    istrue,因为IntegerNumber的子类。
    该方法还可以用于类型转换时,为了避免对象的转换异常,进行类型检查:

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

    isis2都是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的类型。

    方法名方法签名作用
    isInterfacepublic native boolean isInterface()判断该Class是否是一个接口
    isArraypublic native boolean isArray()判断该Class是否是一个数组 (数组在Java中也是类)
    isPrimitivepublic native boolean isPrimitive()判断该Class是否是基本类型
    isAnnotationpublic boolean isAnnotation()判断该Class是否是一个注解,如果该方法返回true,isInterface方法也将返回true,因为注解是特殊的接口
    isSyntheticpublic boolean isSynthetic()当且仅当该Class是Java语言规范定义的合成类时为true。
    isAnonymousClasspublic boolean isAnonymousClass()当且仅当该Class是匿名类时返回true。Runnable runnable = new Runnable() { public void run() { }};boolean is = runnable.getClass().isAnonymousClass();为true
    isLocalClasspublic boolean isLocalClass()当且仅当该Class是局部类时返回true。
    isMemberClasspublic boolean isMemberClass()当且仅当该Class是一个类的成员返回true
    isAnnotationPresentpublic boolean isAnnotationPresent(Class<? extends Annotation> annotationClass)判断该类是否有注解annotationClass
    isEnumpublic boolean isEnum()判断是否是枚举类

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

    展开全文
  • JS es6的Class类详解

    万次阅读 多人点赞 2020-09-05 10:17:18
    文章目录JS es6的Class类详解class基本语法Class的基本语法之constructorClass的基本语法之类的调用方式Class的基本语法之getter和setterClass的基本语法之类的属性名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也可以执行。

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9USZMu4q-1599271907892)(C:\Users\dell\Desktop\凯文的前端博客\images2\class1.png)]

    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的基本语法之类的属性名

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1iEAo4qQ-1599271907895)(C:\Users\dell\Desktop\凯文的前端博客\images2\class2.png)]

    上面代码中,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,它默认指向类的实例。但是,必须非常小心,一旦单独使用该方法,很可能报错。

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yWvVyll7-1599271907897)(C:\Users\dell\Desktop\凯文的前端博客\images2\class3.png)]

    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,因此这个属性可以用来确定构造函数是怎么调用的。

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rSe8aqiI-1599271907900)(C:\Users\dell\Desktop\凯文的前端博客\images2\class4.png)]

    展开全文
  • JAVA Class类与反射

    千次阅读 2021-07-24 11:57:34
    关于Class类与Class对象与反射 Class类与Class对象 Class对象是Class类的实例,类至少包含以下信息,因此class类又可以被 解构为如下部分: 权限修饰符 类名 参数化类型(泛型信息) 接口Interface 注解Annotation ...

    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类型
      在这里插入图片描述

    为什么要传 nameParameterType
    因为.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

    展开全文
  • js中的class类

    千次阅读 2020-02-15 15:10:37
    1.class类的创建 创建一个class类 class myClass{ //构造器,默认为空的构造器 //当class在被new时就会调用构造器 //相当于function //function myClass(name,age){ // this.name=name // this.age=age //}...
  • Class类简介

    万次阅读 多人点赞 2018-05-25 19:39:41
    1、Class类简介: &nbsp;Java程序在运行时,Java运行时系统一直对所有的对象进行所谓的运行时类型标识。这项信息纪录了每个对象所属的类。虚拟机通常使用运行时类型信息选准正确方法去执行,用来保存这些类型...
  • 全网最详细完备的class类文件结构解析

    万次阅读 多人点赞 2021-05-21 23:54:03
    写在前面 本文隶属于专栏《100个问题搞定Java虚拟机》,该专栏为笔者原创,引用请注明来源,不足和错误之处请在评论区帮忙指出,谢谢! 本专栏目录结构和文献引用请见...4. 索引、父类索引与接口索引集合 5. 字段表
  • Java中的Object类和Class类

    千次阅读 多人点赞 2019-04-24 19:59:33
    在Java中,无论是类还是接口,它们在JVM的内存逻辑模型中都会存在Super和Class指针,分别指向根类(Object类)和反射类(Class类) 在这一篇blog中会了解到很多常用方法,建议大家看api 1. 位置和内容 Object类和...
  • Class类 和 class对象(运行时的类型信息)

    万次阅读 多人点赞 2018-12-05 11:28:07
    每个的运行时的类型信息就是用Class对象表示的。它包含了与有关的信息。其实我们的实例对象就通过Class对象来创建的。Java使用Class对象执行其RTTI(运行时类型识别,Run-Time Type Identification),多态是...
  • Java反射 Class类常用方法详解

    万次阅读 多人点赞 2018-05-19 18:47:49
    1.返回Class类对应的实体类的相关的Class类的方法:如果我们已经有了一个类的 Class类,可以使用下面的一些方法来获得它相关的类:(1)返回当前Class类对应的实体类的父类的Class类:public Class&lt;? super T&...
  • Vue中设置class类样式

    千次阅读 2020-05-23 19:56:13
    vue中通过属性绑定为元素设置class类样式vue中class类样式的4种绑定方式1、数组2、三元表达式3、数组嵌套对象4、直接使用对象 vue中class类样式的4种绑定方式 1、数组 <h1 :class="['thin','red','italic','...
  • java反射以及Class类类型

    千次阅读 多人点赞 2018-12-10 02:46:42
    java的反射机制: 在运行状态中,对于任意一个类,都能知道这个...1.Class类的使用   在面向对象的世界中,万事万物都是对象 普通数据类型不是面向对象 比如int long 但是它们的包装类型 integer Long是对象 ...
  • es6 class类class类中constructor

    千次阅读 2019-02-20 16:00:43
    在es6 中的class关键字用于声明,在此之前js一直没有的概念,本文只要讨论class的与es5中对象的关系以及class中constructor的作用 关键字class ES6 的class可以看作只是一个语法糖,而本身可以看作一个构造函数...
  • python——class类和方法的用法详解

    万次阅读 多人点赞 2020-08-07 16:17:00
    因为一直不太清楚面向对象的和方法的编程思想,所以特地补了一下python-class的知识,在这里记录和分享一下。 文章目录和方法的概念和实例1.python:`class`2.的构造方法`__init__()`3.中方法的参数`self...
  • 1、Class类简介:  Java程序...
  • Class类的介绍和基本使用方法

    千次阅读 2020-12-07 19:53:01
    一、Class类的介绍 Class类的对象表示的是一个,类在内存中的class文件。 Class clz = String.class 表示String在内存中的class文件。 二、Class类的使用 1.获得Class类的对象 通过Class clz = Class.forName(...
  • ES6专题 class类继承super详解

    万次阅读 2020-03-12 23:01:05
    super作为对象在普通方法中...class A{ // 属性应该怎么写??? //#pA私有属性,static pA静态属性 pA = 123 //实例属性 p(){ return 3 } } //A.prototype.pA = 123 class B extends A{ constructor(){ ...
  • Java产生Class类的三种实例化对象的方法 1.object.getClass 2.类名.class直接根据某个具体的类来取得Class实例化对象 3.Class.forName(String className) public class TestClass { public static void main(String...
  • Java学习笔记Ⅰ(class类和main函数)

    千次阅读 2020-03-19 23:17:52
    1. class类 Java文件必须以.java 作为扩展名 一个java文件只能有一个public class public class 的名字必须和文件名字一样,大小写都要完全一致 一个文件可以有多个class类,但是只能有一个是public class,...
  • Java获取某个包下的所有Class类对象

    千次阅读 2019-07-11 20:44:49
    private static void addClass(Set<Class<?>> classSet, String packagePath, String packageName) { File[] files = new File(packagePath).listFiles(new FileFilter() { @Override public boolean accept...
  • Java中Class类与Object类之间的关系

    万次阅读 2018-02-22 15:57:06
    Object类和Class类没有直接的关系。Object类是一切java类的父类,对于普通的java类,即便不声明,也是默认继承了Object类。典型的,可以使用Object类中的toString()方法。Class类是用于java反射机制的,一切java类,...
  • matlab——之class类(详细总结)

    万次阅读 多人点赞 2018-06-02 13:25:53
    开篇:搜了一下网上介绍matlab的class类,信息不全,且总结不全面,于是单独help classdef以下做个详细总结 首先从类的定义说起,面对对象的编程思维通常包括,属性(类成员变量),方法(类成员函数) 基本语法为...
  • 在js的中,可分为三种方法,constructor构造方法、静态方法与普通方法。 一、constructor构造方法 1.概念 的作用在于构建对象,而constructor构造方法就是用于构建对象实例。 2.使用方法 在使用new...
  • Class类对象的三种实例化模式

    千次阅读 2019-05-06 20:24:22
    1任何的实例化对象可以通过Object类中的getClass()方法获得Class对象: import java.util.Date; public class Class_test... //第一种Class实例化模式,也将是通过class类来实例化对象 Class<?> cls = new...
  • 在vue中使用export default导出的class类

    万次阅读 2020-02-16 15:47:36
    首先我们要创建一个并导出 class win { getProcessInfo() { return 233; } } export default new win(); //用的是export default方法,并且导出的时候就已经实例化了 在vue文件中引用 <script> ..... ....
  • java.lang.Class类详解

    万次阅读 多人点赞 2015-05-18 13:54:21
    虚拟机通常使用运行时类型信息选准正确方法去执行,用来保存这些类型信息的类是Class类Class类封装一个对象和接口运行时的状态,当装载类时,Class类型的对象自动创建。说白了,Class类对象就是封装了一个类的类型...
  • ID选择器与Class类选择器区别

    千次阅读 2018-11-21 14:13:39
    class和id选择器得区别:class选择器的值不是唯一的,我可以在多个标签共用一个class名 ID选择器: &lt;!DOCTYPE html&gt; &lt;html&gt; &lt;head&gt; &lt;meta charset="UTF-8...
  • 反射(Reflection)是Java提供一种在运行时,动态操作类的方法...java.lang.Class类是java反射中的一个重要类。本文主要介绍了java.lang.Class实例的获取,Java类的类型判断,Java类的加载,Java对象的非new方式创建。
  • SystemVerilog——class类

    千次阅读 2020-08-13 16:04:25
    本文章主要介绍关于class的以下内容: 的定义; 虚以及方法; 的多态结构; 参数化; 接口; 内存的管理。 2. 的定义 在SystemVerilog中,你可以把定义在program、module、package中,或者在...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,259,563
精华内容 2,503,825
关键字:

class类