精华内容
下载资源
问答
  • 对象实例化的方式
    千次阅读
    2022-05-07 14:38:35

    1.什么是对象实例化

    在写代码时,我们用关键词class定义一个类其实只是定义了一个类的模板,没有在内存中实际产生一个类的实例对象,也没有分配内存空间。要想在内存中产生一个类的实例对象就需要使用new关键字申请分配内存空间,加上类的构造方法提供申请空间的大小规格,在内存中实际产生一个类的实例,一个类使用 new 加 此类的构造方法,执行之后就在内存中分配了一个此类的内存空间,有了内存空间就可以向里面存放定义的数据和进行方法的调用了,这就是对象的实例化。

    大致就是给这个类赋予对应意义的过程吧,比如

    Person p = new Person();

    对象:纸上的一个机器草图,不占用任何空间

    实例化:将纸上的机器制作出来,实际占用空间

    2.java对象实例化的五种方式

    1. ⽤new语句创建对象,这是最常见的创建对象的⽅法;
    2. 通过⼯⼚⽅法返回对象,如:String str = String.valueOf(23);
    3. 运⽤反射⼿段,调⽤java.lang.Class或者java.lang.reflect.Constructor类的newInstance()实例⽅法。如:Object obj =Class.forName("java.lang.Object").newInstance();
    4. 调⽤对象的clone()⽅法;
    5. 通过I/O流(包括反序列化),如运⽤反序列化⼿段,调⽤java.io.ObjectInputStream对象的 readObject()⽅法。
    更多相关内容
  • c++三种实例化对象方式

    千次阅读 2022-04-16 18:47:15
    1.隐式创建 首先我们定义一个测试类 class Person { private: int ...而new出来的指针对象可以在方法之间传递,且该指针对象所指向的堆中的对象实例仍然存在。 5.频繁调用场合并不适合new,就像new申请和释放内存一样。

    1.隐式创建

    首先我们定义一个测试类

    class Person {
        private:
          int age;
          string name;
        public:
            Person() {
                cout<<"this is construct~";
            }
            Person(int age, string name) {
                this->age = age;
                this->name = name;
                cout<<"name is: "<<name<<", age is: "<<age<<endl;
            }
    };
    

    然后我们在main方法中隐式创建Person对象

    Person p1;
    cout<<endl;
    Person p2(18, "lili");
    cout<<endl;
    

    2.显示创建

    当然,我们也可以像其他编程语言一样,显示创建一个对象

    Person p3 = Person();
    cout<<endl;
    Person p4 = Person(16, "xx");
    cout<<endl;
    

    这种方式,与上面的第一种方式原理基本一直。

    3.用new创建

    当然我们还可以用new关键字来创建对象

    Person *p5 = new Person();
    cout<<endl;
    Person *p6 = new Person(14, "yy");
    

    注意new出来的对象,都需要用指针接收。

    4.上述三种方式的区别

    上面三种方式可以认为是两种方式,因为第一种方式与第二种方式基本相同。那么具体区别在哪里?

    1.new出来的对象必须要用指针接收,并且需要显式delete销毁对象释放内存。

    2.内存位置不同。
    对于隐式声明

    Person p1;
    

    p1对象位于栈空间。

    Person *p5 = new Person();
    

    p5对象位于堆空间。

    3.内存分配时间不同
    使用隐式创建对象的时候,创建支出就已经分配了内存。而使用new的方式,如果对象没有初始化,此时没有分配内存空间,也无法delete。

    Person *p = NULL;
    delete p;
    

    上述语句如果执行,会有各种意想不到的情况发生。

    4.隐式声明的对象是局部变量,出了函数就没有了。而new出来的指针对象可以在方法之间传递,且该指针对象所指向的堆中的对象实例仍然存在。

    5.频繁调用场合并不适合new,就像new申请和释放内存一样。

    展开全文
  • 对象实例化

    千次阅读 2020-07-11 10:01:15
    一、创建对象方式 1、new (1)直接new 对象 (2)单例模式,构造器是私有的,通过静态方法获取对象 (3)工厂类产生对象 2、class的newInstance() 反射的方式,只能调用空参构造器,权限是public 3、...

    一、创建对象的方式

    1、new

    (1)直接new 对象

    (2)单例模式,构造器是私有的,通过静态方法获取对象

    (3)工厂类产生对象

    2、class的newInstance()

    反射的方式,只能调用空参构造器,权限是public

    3、Constructor的newInstance()

    可以调用有参构造器,权限没有要求

    4、使用clone()

    实现Cloneable接口,浅拷贝不使用构造器,深拷贝需要用到其他方式产生对象

    5、使用反序列化

    从文件中,网络中获取一个二进制流

    6、第三方库

    Objenesis

    二、对象字节码

    三、创建对象的步骤

    1、判断对象的对应的类是否加载,链接,初始化

    虚拟机遇到new指令,首先检查这个指令的参数能否在元空间的常量池中定位到一个类的符号引用,并且检查这个类的符号引用代表的类已经被加载,解析和初始化。如果没有,则使用双亲委派机制加载,以当前类加载器+包名+类名为key进行查找对应的.class文件。如果没有找到文件,则抛出ClassNotFoundException异常。如果找到则进行类加载,生成对应的class类对象。

    2、为对象分配内存

    首先计算对象占用空间的大小,接着在堆中划分一块内存给新对象,如果实例成员变量是引用变量,进分配变量空间即可,即4个字节。

    对象所需内存大小在类加载完成后便可完全确定,为对象分配空间的任务等同于把一块确定大小的内存从java堆中划分出来。

    按照堆内存是否规整可以划分为以下两种分配方式:

    (1) 指针碰撞

    如果java堆内存是规整的,所用过的内存都放在一边,空闲的内存放在另一边,中间放着一个指针作为分界点的指示器,那所分配的内存是指针向空闲区域挪动一段与对象大小相等的距离。

    (2)空闲列表

    如果java堆内存是不规整,虚拟机需要维护一个列表,记录哪些块可以用,在分配的时候从列表中找到一块足够大

    的空间分配给对象,并更新列表上的记录。

    小结:

    选择哪种分配方式是由java堆是否规整决定,而java堆是否规整又由采用的垃圾收集器是否带有压缩整理功能决定的。

    使用Serial,ParNew等带Compact过程的收集器时,系统采用的分配算法是指针碰撞,而使用CMS这种基于Mark-Sweep算法的收集器时,通常采用空闲列表。

    3、处理并发问题

    在虚拟机创建对象是非常频繁的行为,在并发情况下也并不是线程安全的,可能出现正在给对象A分配内存,指针还没来得及修改,对象B又同时使用了原来的指针来分配内存的情况。

    解决此种并发问题,jvm提供两种方案:

    (1) 对分配内存空间的动作进行同步处理,实际上虚拟机采用CAS配上失败重试的方式保证更新操作的原子性

    (2) 内存分配的动作按照线程划分在不同的空间之中进行,即每个线程在java堆中预先分配一小块内存,称为本地线程的TLAB上分配,只有TLAB用完分配新的TLAB时,才需要同步锁定。虚拟机是否使用TLAB可以通过-XX:+/-UseTLAB参数设定。
    4、初始化分配到的空间

    所有属性设置默认值,保证对象实例字段在不赋值时可以直接使用。内存分配完成后,虚拟机需要将分配到的内存空间都初始化为0(不包括对象头),如果使用TLAB,这一工作过程也可以提前至TLAB分配时进行。这一步保证了对象的实例字段在java代码中不赋初始值就可直接使用。

    5、设置对象头

    虚拟机要对对象进行必要的设置,例如这个对象是哪个类的实例、如何才能找到类的元数据信息、对象的哈希码、对象的GC分代年龄等信息。这些信息存放在对象的对象头之中。根据虚拟机当前的运行状态的不同,如是否启用偏向锁,对象头会有不同的设置方式。

    6、执行init方法进行初始化

    在程序的角度看,初始化才正式开始,初始化成员变量,执行实例化代码块,调用类的构造方法,并把堆内对象的首地址赋值给引用变量。

    到此为止,虚拟机创建对象完成。

     

     

    展开全文
  • 各位同学好,本章节和大家分享一下面向对象编程的一些方法,通过一些案例带大家由浅入深掌握面向对象的编程。...item1 = Item() # 创建Item类的实例化对象item1 #(3)给实例化对象分配属性 item1.n..

    各位同学好,本章节和大家分享一下面向对象编程的一些方法,通过一些案例带大家由浅入深掌握面向对象的编程。

    1. 最基本的类实例化

    创建类的方法是 class 变量名: 实例化方法是 类名() 分配属性的方法是 实例名.属性名 = 值  

    #(1)创建类
    class Item:  # 创建类的方法是   class 类名:
        pass  # 不执行任何内容
    
    #(2)实例化
    item1 = Item()  # 创建Item类的实例化对象item1
    
    #(3)给实例化对象分配属性
    item1.name = 'phone'
    item1.price = 100
    item1.quantity = 5
    
    #(4)打印结果
    print(type(item1))  # <class '__main__.Item'>
    print(type(item1.name))  # <class 'str'>
    print(type(item1.price))  # <class 'int'>
    print(type(item1.quantity))  # <class 'int'>

    2. 在类中创建方法

    在类的内部定义的函数,我们称之为方法,它可以运用于所有的类实例化对象上。我们在类的内部定义的函数,它的第一个参数默认是 self代表类实例化对象,下面代码中是指item1。在类的外部调用类的内部定义的方法对象名.方法名(参数) 

    #(1)定义类
    class Item:  # 创建类的方法是   class 类名:
        
        #(2)在类中创建方法
        # 当调用这个方法时,将对象本身作为第一个参数self传递
        def calculate_total_price(self, x, y):  
            return x * y  # 返回乘积
    
    #(3)实例化
    item1 = Item()  # 创建Item类的实例化对象item1
    
    #(4)给实例化对象分配属性
    item1.name = 'phone'
    item1.price = 100
    item1.quantity = 5
    
    #(5)调用方法,self代表item1,传入两个参数x代表价格,y代表数量,
    res = item1.calculate_total_price(item1.price, item1.quantity)
    print(res)  # 500
    
    # 再实例化一个
    item2 = Item()  # 创建Item类的实例化对象item1
    item2.name = 'MacBook'
    item2.price = 1000
    item2.quantity = 3
    print(item2.calculate_total_price(item2.price, item2.quantity))
    # 输出 3000

    3. 类的初始化

    3.1 初始化无默认值

    在类实例化之后,需要分别给每个对象分配属性,如上一节的第(4)步。如果对象很多的话,极大增加了工作量。因此我们希望在类实例化对象的时候就能自动给对象分配属性初始化方法:在类中定义 def __init__(self, 参数): 在类实例化时,会自动执行初始化函数中的所有内容,自动完成属性分配。

    #(1)定义类
    class Item:   # 创建一个类
        
        #(2)初始化,实例化这个类时,会自动执行init内容
        def __init__(self, name, price, quantity):
            
            # 动态属性分配
            self.name = name  # 给实例化属性赋值,相当于item1.name = 'phone'
            self.price = price  # 相当于item1.price = 100
            self.quantity = quantity  # 相当于item2.quantity = 3
            
    #(3)实例化,创建Item类的实例化对象item1
    # 自动执行初始化中的内容,不需要一个一个去定义 
    item1 = Item('Phone', 100, 5)  
    item2 = Item('MacBook', 1000, 3)
    
    # 打印结果
    print('name1:', item1.name, 'price1:', item1.price, 'quantity1:', item1.quantity)
    print('name2:', item2.name, 'price2:', item2.price, 'quantity2:', item2.quantity)
    # name1: Phone price1: 100 quantity1: 5
    # name2: MacBook price2: 1000 quantity2: 3
    

    3.2 初始化有默认值

    在初始化的过程中,可以给属性设置默认值。那样的话,在实例化时,如果不给定某个属性的值,那么这个属性就被赋予默认值。如下面在初始化时,已经给定了price和quantity这两个属性的默认值,因此item1就直接使用这两个属性的默认值,item2改变这两个属性的默认值。

    #(1)创建类
    class Item:   # 创建一个类
        
        #(2)初始化,实例化这个类时,会自动执行init内容
        # price和quantity存在默认值,可以不用传值
        def __init__(self, name, price=50, quantity=10): 
            
            # 动态属性分配
            self.name = name  # 给实例化属性赋值,相当于item1.name = 'phone'
            self.price = price  # 相当于item1.price = 100
            self.quantity = quantity  # 相当于item2.quantity = 3
            
    #(3)实例化,创建Item类的实例化对象item1
    # 自动执行初始化中的内容,不需要一个一个去定义 
    item1 = Item('Phone')  # 使用默认值的price和quantity
    item2 = Item('MacBook', 1000, 3)  # 不使用默认值,自己赋值
    
    # 打印结果
    print('name1:', item1.name, 'price1:', item1.price, 'quantity1:', item1.quantity)
    print('name2:', item2.name, 'price2:', item2.price, 'quantity2:', item2.quantity)
    # name1: Phone price1: 50 quantity1: 10
    # name2: MacBook price2: 1000 quantity2: 3

    4. 初始化后调用类中定义的方法

    接着类初始化之后,在类中定义方法,第一个参数默认是实例化对象 self,这时候不需要传入额外参数。因为经初始化之后的对象,就已经被赋予了属性及属性值,可直接通过 self.属性名 读取该属性值

    #(1)定义类
    class Item: 
        
        #(2)初始化,如果实例化时不给定实例化属性的值,那就使用默认值
        def __init__(self, name, price=100, quantity=10):
            
            # 给实例化对象分配属性
            self.name = name
            self.price = price
            self.quantity = quantity
            
        #(3)在类中定义方法,self代表实例化对象
        def calculate_total_price(self):
            
            # 实例化对象在初始化过程中已经附有了属性,可直接在定义的方法中计算
            return self.price * self.quantity
    
    #(4)创建Item类的实例化对象item1
    item1 = Item('Phone', 100, 5)  # 自定义各个属性的值
    
    #(5)调用类中定义的方法,将item1作为对象self传入该方法
    res = item1.calculate_total_price()
    print(res)  # 500
    
    # ==2== 补充
    # 这里在实例化对象过程中没有指定数据类型,如果我们传入的price属性的值是字符串会发生什么呢
    item1 = Item('Phone', '100', 5) # 传入各个属性的值
    res = item1.calculate_total_price()  # 调用类方法计算price和quantity的乘积
    # 相当于'100'*5,即把字符串100打印5次
    print(res)  # 100100100100100

    可是,如果在类实例化的时候,传入的属性值的类型不符合要求,就得不到想要的结果。比如传入的price是字符串类型的'100',而quantity是整型的5,这两个不同的数据类型相乘,'100'*5表示将字符串'100'打印5次,得到的不是我们预期的结果。下面讲一下如何处理这种情况。


    5. 初始化时,指定传入的数据类型

    在初始化函数中指定数据类型,属性名: 数据类型,在类实例化的时候会提醒需要的什么样的数据类型。如下,name属性指定数据类型为str字符串类型,price属性为浮点类型,quantity属性已经赋予默认值,那么它的数据类型和默认值的数据类型相同

    #(1)创建类
    class Item:  
    
        #(2)初始化,self代表实例化对象
        # 指定name属性的值为字符串类型,price属性的值为浮点类型,
        # quantity属性已经附有默认值,不需要再指定类型,因为quantity的数据类型就是默认值的数据类型
        def __init__(self, name: str, price: float, quantity=10):
            
            # 给实例化对象分配属性
            self.name = name
            self.price = price
            self.quantity = quantity
            
        #(3)定义类方法
        def calculate_total_price(self):
            
            # 计算乘积
            return self.price * self.quantity
        
    #(4)创建Item类的实例化对象
    item1 = Item('Phone', 100)  # 指定name属性和price属性,quantity属性使用默认值
    
    #(5)调用类中的方法
    res = item1.calculate_total_price()
    print(res)  # 1000

    6. 初始化时,检查输入值是否符合预期

    这里用到 assert 方法。在上一节中,我们规定了数据类型,但如果数据类型输入对了,但是值的范围不满足要求那要怎么办呢。方法: assert 条件, 报错内容

    如下面代码中的 assert price >= 0, f'Price {price} is not greater or equal to 0' 。意思是,如果price接收的属性值大于等于0,那就正常运行;如果price的值小于0,程序就报错,报错内容是逗号后面的内容。

    #(1)创建一个类
    class Item:  
        
        #(2)初始化,self代表实例化对象,指定实例化属性的数据类型
        def __init__(self, name:str, price:float, quantity=10):
            
            #(3)判断输入值是否满足要求,不满足则报错,报错内容是逗号后面的
            # 比如,要求每个实例的价格属性price是大于0的,满足要求则不显示逗号后面的内容
            assert price >= 0, f'Price {price} is not greater or equal to 0'   
            assert quantity >= 0, f'Quantity {quantity} is not greater or equal to 0'
            
            #(4)给每个实例属性赋值
            self.name = name
            self.price = price
            self.quantity = quantity
            
        #(5)定义类方法
        def calculate_total_price(self):
            
            # 计算乘积
            return self.price * self.quantity
        
    #(6)Item类的实例化对象item1
    item1 = Item('Phone', -100, 3)
    
    #(7)调用类实例化方法
    res = item1.calculate_total_price()
    print(res)
    展开全文
  • String类的两种实例化方式

    千次阅读 2021-02-05 13:11:15
    面试常见问题:比较String类的两种实例化方式
  • 学Java· 从new说对象实例化

    千次阅读 多人点赞 2022-03-31 12:05:37
    就可以实例化一个对象,这个对象就有Student类中的所以成员变量。可是 对象student1 和 类Student到底是怎样建立联系的,在内存中到底发生了什么? 想要知道内存中发生了什么,我们先来了解两个内存概念 堆...
  • Unity 创建/实例化对象

    千次阅读 2021-09-23 11:40:30
    在程序运行过程中创建、实例化对象物体需要用到Object类中的 Instantiate 函数,例如,我们场景中有一个物体A: 现在我们想要在场景中创建五个该物体,则用Instantiate函数将该物体作为参数传入: using ...
  • 创建(实例化对象的五种方式

    万次阅读 2018-08-28 10:16:52
    Java中创建(实例化对象的五种方式 用new语句创建对象,这是最常见的创建对象的方法。 通过工厂方法返回对象,如:String str = String.valueOf(23); 运用反射手段,调用java.lang.Class或者java.lang....
  • JavaScript 对象实例化

    万次阅读 2018-05-02 16:26:10
    参考资料:《JavaScript入门经典》利用内置对象创建直接实例JavaScript有一个内置对象Object,利用它可以创建一个空白的对象。aObject = new Object();添加属性这样,我们就创建了没有任何属性和方法的空白对象。...
  • 一个对象实例化的过程(细节)

    千次阅读 2019-07-11 17:34:30
    一个对象实例化的过程(细节): 刚接触对象实例化可能会有些不明白,以下为详细过程: 一个对象实例化过程: Person p = new Person(); 1.JVM 会读取指定的路径下的 Person.class 文件,并加载进内存,并会先加载...
  • 关于实例化对象

    千次阅读 2021-02-06 23:15:33
    实例化对象 1、什么是实例化对象 ①类是对象的抽象。对象是类的具体实例,需要通过类来创建 ②创建对象的过程称为实例化 ——意思是类是抽象的,需要通过创建对象实例化对象)来使用类的功能 2、实例化对象的两个...
  • C++的三种实例化对象方式

    千次阅读 2019-10-10 09:00:51
    C++的三种实例化对象方式 2019-05-04 19:15:43d89538239阅读数 385 一、隐式创建 class CEmployee { private: int age; int id; public: CEmployee() { cout << "这是构造函数" << endl; } ...
  • python:类的定义、实例化对象

    千次阅读 2021-02-03 12:24:54
    定义:类的定义使用关键字 ,class 关键字:封装:类可以把各种对象组织在一起,作为类的属性,通过 . (点)运算符来调用类中封装好的对象属性:变量在类中称为属性,但是类中的属性不仅仅只包含变量,函数等其他的...
  • C++的使用:实例化对象

    千次阅读 2021-06-19 10:46:47
    实例化对象有两种方式,一种是在栈上实例化,另一种是在堆上实例化。 示例代码 2 int main() { // 栈上实例化 Student stu1; stu1.setName("jake"); stu1.setAge(15); cout << "My name is " <<...
  • 声明对象实例化对象的区别

    千次阅读 多人点赞 2019-05-31 20:40:45
    声明对象: 和声明基本引用类型是一样的, 类名 对象名(对象名也是标识符,和基本类型的...如此处理,使得Java中声明一个对象的消耗很小,但也有一个副作用,就是对象不能马上使用,还需要对它进行实例化。 实...
  • Java实例化对象的几种方式

    万次阅读 2017-10-12 11:28:36
    Java中创建(实例化对象的五种方式 1、用new语句创建对象,这是最常见的创建对象的方法。 2、通过工厂方法返回对象,如:String str = String.valueOf(23);  3、运用反射手段,调用java.lang.Class或者java....
  • 接口--实例化接口对象的三种方式

    千次阅读 2019-12-26 17:45:12
    所以在这里,我来分享三种方式实例化接口对象。 //这里会提示'Student' is abstract; cannot be instantiated,也就是说接口是抽象的,不能被实例化 Student stud00 = new Student(); //1.使用实现类来创建...
  • Java中实例化对象是什么意思

    千次阅读 多人点赞 2021-02-22 20:45:53
    在Java语言中使用new关键字创建/构造对象的过程叫做类的实例化,该过程的本质,会在内存空间的堆区申请一块存储区域,用于记录该对象独有的成员变量信息。 通俗点就是,实例化:使用关键字new来创建对象。 例如: ...
  • 在面向对象程序设计中,"类"在实例化之后叫做一个"实例"(Person person = new Person())。 "类"是静态的,不占进程内存,而"实例"拥有动态内存。 实例(instance)和对象(object)的区别: 对象就是类的实例,所有的...
  • 实例化对象写法的区别 栈中实例化对象: 堆中实例化对象: 最大区别就在于,从栈中申请内存,在使用完后无需释放,但是从堆中申请内存,使用完以后必须释放! 注意:从堆中申请内存,是有可能失败的,所以...
  • Java对象在内存中实例化的过程

    千次阅读 多人点赞 2020-07-27 15:08:52
    Java对象在内存中实例化的过程 在讲 Java 对象在内存中的实例化过程前,先来说下在类的实例化过程中,内存会使用到的三个区域:栈区、堆区、方法区。 堆区: 存储的全部都是对象,每个对象包含了一个与之对应的 ...
  • 那么怎么完成实例化呢。我们创建一个对象需要对它初始化数据。能够有这一作用的是什么呢?——构造函数。所以就有了 Car mycar= new Car(); 当我们自己定义了与类同名的有参构造函数时,假设参数类型是整型的,...
  • 用spring管理和实例化对象的四种方式 方式一:无参构造函数(最常用) 对象是spring创建,创建的对象还要交给spring容器管理 bean:豆子 id:在spring容器中Hello对象的名,在容器中id的值必须唯一 class:要对哪个类实例化...
  • 对C#中用new关键字实例化对象的理解

    千次阅读 2019-12-27 16:27:50
    类是模板,定义了对象实例化的时候看起来像什么样子。 对象是类的一个实际的例子,简称实例。 实例化是从类创建对象的过程。 举例而言:类可以看做是图纸,我们根据这个图纸做出来一个东西(即对象),做出来的...
  • Java中子类中子类实例化父类对象

    千次阅读 2019-05-03 18:08:39
    版权声明:博主原创/资料整理,转载请注明出处...1. 子类中,父类实例化父类对象,调用父类中的方法。 2. 子类中,子类实例化父类对象,调用子类中的方法。 3. 子类中,子类实例化子类对象,调用子类中的方法。
  • C++对象实例化及调用

    万次阅读 2017-08-01 11:15:43
    class TV { public: int type; void changeVol() { cout ; } };从栈中实例化对象调用TV tv; Tv.type = 0; Tv.changeVol();从堆中实例化对象调用TV *p = new TV(); if(NULL == p) {
  • 为什么要创建对象实例化)?

    千次阅读 多人点赞 2020-06-04 19:55:49
    一、为什么要实例化对象对象:属性+方法 类是指:描述一种事物的定义,是个抽象的概念 实例指:该种事物的一个具体的个体,是具体的东西 联系 类是现实世界或思维世界中的实体在计算机中的反映,它将数据以及...
  • 在学习Java反射的过程中,遇到了一点疑惑的地方 //1.获取Class对象 Class clazz = Class.forName("...); //2. 利用Class对象的newInstance方法创建一个类的...平常理解的对象实例都是一个东西,将一个对象实...
  • java 内部类实例化方式

    万次阅读 2018-09-06 19:42:52
    1、java成员和静态内部类的使用,适用类本身适用,旨在减少文件个...①java成员内部类和静态内部类的实例化方式, ②内部类的方法调用方式 代码实现如下: package com.innerClass; import com.google.gson.Gso...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,013,182
精华内容 805,272
关键字:

对象实例化的方式