精华内容
下载资源
问答
  • 不用构造器也能创建对象

    千次阅读 2015-03-25 10:42:27
    不用构造器也能创建对象
    import java.io.ByteArrayInputStream;   
    import java.io.ByteArrayOutputStream;   
    import java.io.ObjectInputStream;   
    import java.io.Serializable;   
    public class TestClass implements Serializable{   
        private static final long serialVersionUID = 0L;   
        public TestClass() throws Exception {   
            throw new Exception("哎呀妈呀,异常啦!!!!");   
        }   
        public static void main(String[] args) throws Exception {   
            byte[] head = { -84, -19, 0, 5, 115, 114, 0 };   
            byte[] ass = { 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 120, 112 };   
            String name = TestClass.class.getName();   
            ByteArrayOutputStream baos = new ByteArrayOutputStream();   
            baos.write(head);   
            baos.write(name.length());   
            baos.write(name.getBytes());   
            baos.write(ass);   
            baos.flush();   
            baos.close();   
            ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(baos.toByteArray()));   
            TestClass o = (TestClass) ois.readObject();   
            ois.close();   
            System.out.println("创建对象: " + o);   
        }   
    }   
    看到这里先别着急执行,先看看.你觉得能够正常运行吗? 结果是什么?
    -----------------------------------------------------------------------------------
    运行结果:  创建对象: TestClass@743399
    CSDN某帖子 写道
    对象创建的几种方法:
    1.使用new关键字 2.使用clone方法 3.反射机制 4.反序列化
    其中1,3都会明确的显式的调用构造函数
    2是在内存上对已有对象的影印 所以不会调用构造函数
    4是从文件中还原类的对象 也不会调用构造函数

    上述代码就是反序列化的结果
    RednaxelaFX 写道
    嗯顺带推荐Effective Java, Second Edition的第74条
    引用
    Normally, objects are created using constructors;
    serialization is an extralinguistic mechanism for creating objects. Whether
    you accept the default behavior or override it, deserialization is a “hidden constructor”
    with all of the same issues as other constructors.

    大体的意思是反序列化有一定的风险.破坏了封装.相当于一个隐藏的构造器.
    RednaxelaFX 写道
    1、Java的实例构造器只负责初始化,不负责创建对象;Java虚拟机的字节码指令的设计也反映了这一点,有一个new指令专门用于创建对象实例,而调用实例构造器则使用invokespecial指令。
    2、“this”是作为实例构造器的第一个实际参数传入的。

    Java反序列化实际上是调用了基类的构造方法.
    ObjectStreamClass中调用ReflectionFactory.newConstructorForSerialization(cl, cons);
    Objectstreamclass代码 复制代码 收藏代码
    1. cons = reflFactory.newConstructorForSerialization(cl, cons);  

    根据cl参数(TestClass类的Class对象)和cons参数(基类Object的构造器)创建了一个新的构造器
    打印生成的构造器对象,输出信息为public java.lang.Object(),表面生成的构造器是TestClass父类Object的无参构造器.
    但是调用newInstance()的结果却产生了TestClass类的对象.(おかしい......)

    ReflectionFactory.newConstructorForSerialization()例子
    Java代码 复制代码 收藏代码
    1. Constructor superCons = TestClass.class.getSuperclass().getConstructor();   
    2. System.out.println(superCons);   
    3. ReflectionFactory reflFactory = ReflectionFactory.getReflectionFactory();   
    4. Constructor c = reflFactory.newConstructorForSerialization(TestClass.class,superCons);   
    5. System.out.println(c.newInstance());  
            Constructor superCons = TestClass.class.getSuperclass().getConstructor();
            System.out.println(superCons);
            ReflectionFactory reflFactory = ReflectionFactory.getReflectionFactory();
            Constructor c = reflFactory.newConstructorForSerialization(TestClass.class,superCons);
            System.out.println(c.newInstance());

    运行结果代码 复制代码 收藏代码
    1. public java.lang.Object()   
    2. TestClass@fd13b5  

    通过基类的方法调用生成了子类.绕开了TestClass类的构造方法.生成了看似不可能存在的TestClass对象

    -----------------------------------------------------------------------------------
    感谢FX,之前一篇关于构造器的详细论述.传送门http://rednaxelafx.iteye.com/blog/652719
    FX写的关于本篇的更详细讲解在这里,传送门http://rednaxelafx.iteye.com/blog/850082

    展开全文
  • 原帖:[url=http://www.iteye.com/topic/850027]不用构造方法也能创建对象[/url] 把之前我引用过的一段也贴上来: [quote="RednaxelaFX"]嗯顺带推荐Effective Java, Second Edition的第74条 [quote]...
    原帖:[url=http://www.iteye.com/topic/850027]不用构造方法也能创建对象[/url]

    把之前我引用过的一段也贴上来:
    [quote="RednaxelaFX"]嗯顺带推荐Effective Java, Second Edition的第74条
    [quote]A second cost of implementing Serializable is that it increases the likelihood
    of bugs and security holes. [color=red]Normally, objects are created using constructors;
    serialization is an extralinguistic mechanism for creating objects. Whether
    you accept the default behavior or override it, deserialization is a “hidden constructor”
    with all of the same issues as other constructors.[/color] Because there is no
    explicit constructor associated with deserialization, it is easy to forget that you
    must ensure that it guarantees all of the invariants established by the constructors
    and that it does not allow an attacker to gain access to the internals of the object
    under construction. Relying on the default deserialization mechanism can easily
    leave objects open to invariant corruption and illegal access (Item 76).[/quote][/quote]

    在Java语言层面看,Java类的构造器只能通过两种方式调用,一个是通过new表达式,另一个是通过反射调用构造器。这两种方式对Java程序员来说都是“整体”的,但实际新建对象的动作分两步走:
    1、创建出空对象(此时类型已经是正确的了),对应字节码是new
    2、调用某个版本的构造器,对应字节码是invokespecial "<init>"。

    默认的Java反序列化机制同样是分两步走,但变成:
    1、创建出空对象(此时类型已经是正确的了);
    2、调用用户定义的反序列化方法(readObject,如果有的话)或者调用默认反序列化方法。
    这就是为什么反序列化可以看作是“隐藏的构造器”。

    如果想自己试试去玩创建出空对象但却不调用构造器的,可以试试sun.misc.Unsafe.allocateInstance()
    用Groovy控制台来演示一下:
    Groovy Shell (1.7.2, JVM: 1.6.0_23)
    Type 'help' or '\h' for help.
    ----------------------------------------------------------------
    groovy:000> class Foo {
    groovy:001> int value = 12345;
    groovy:002> Foo() { println "foo ctor!" }
    groovy:003> int getValue() { println "getValue"; value }
    groovy:004> }
    ===> true
    groovy:000> f1 = new Foo()
    foo ctor!
    ===> Foo@10f0625
    groovy:000> f1.value
    getValue
    ===> 12345
    groovy:000> f2 = sun.misc.Unsafe.theUnsafe.allocateInstance(Foo)
    ===> Foo@38fff7
    groovy:000> f2.value
    getValue
    ===> 0
    groovy:000> quit

    可以看到,创建f2指向的Foo对象时,构造器并没有被调用(没有输出"foo ctor!"),实例的状态(value)也并未按用户指定的值初始化(12345),整个对象的所有字段都处于默认状态(0或者null或者false之类)。

    只是借这个话题用Unsafe举例说明Java对象的创建是分两步走、调用构造器只是其中一步。并不是说反序列化的时候就一定用了Unsafe哦,这个请注意区分 ^_^

    实际上在Sun JDK的实现里,Java层面的反射类库与JVM层面的反射实现相互配合来完成反序列化。java.io.ObjectStreamClass通过跟反射方法/构造器调用类似的机制获取所谓的“序列化构造器”,在反序列化的时候调用这个版本的构造器。
    创建这个“序列化构造器”时要在继承链里从最具体向最抽象的方向搜索,找出第一个不可序列化的类(没有实现Serializable接口的类),并找出它的无参构造器来调用。也就是说,反序列化的时候并不是完全不调用用户代码里声明的构造器,只是不调用实现了Serializable的类的而已。

    关于构造器,之前还有别的讨论可以参考:
    [url=http://rednaxelafx.iteye.com/blog/652719]实例构造器是不是静态方法?[/url]

    ======================================================================

    用[url=http://rednaxelafx.iteye.com/blog/727938]以前介绍过的办法[/url],把原帖里的例子拿来做一下实验,可以更形象的说明问题。

    原帖代码(稍微修改,去掉了包名):
    import java.io.ByteArrayInputStream;   
    import java.io.ByteArrayOutputStream;
    import java.io.ObjectInputStream;
    import java.io.Serializable;

    public class TestClass implements Serializable {
    private static final long serialVersionUID = 0L;
    public TestClass() throws Exception {
    throw new Exception("!!!");
    }

    public static void main(String[] args) throws Exception {
    byte[] head = { -84, -19, 0, 5, 115, 114, 0 };
    byte[] ass = { 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 120, 112 };
    String name = TestClass.class.getName();
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    baos.write(head);
    baos.write(name.length());
    baos.write(name.getBytes());
    baos.write(ass);
    baos.flush();
    baos.close();
    ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(baos.toByteArray()));
    TestClass o = (TestClass) ois.readObject();
    ois.close();
    System.out.println("Created: " + o);
    System.in.read(); // 暂停进程以便有足够时间来dump class
    }
    }


    MyFilter:
    import sun.jvm.hotspot.tools.jcore.ClassFilter;
    import sun.jvm.hotspot.oops.InstanceKlass;

    public class MyFilter implements ClassFilter {
    @Override
    public boolean canInclude(InstanceKlass kls) {
    String klassName = kls.getName().asString();
    return klassName.startsWith("sun/reflect/GeneratedSerializationConstructorAccessor");
    }
    }


    编译的时候用:
    javac -classpath ".:$JAVA_HOME/lib/sa-jdi.jar" MyFilter TestClass


    然后先运行:
    java TestClass

    别让它退出,用jps查出它的进程ID,然后用ClassDump得到class文件:
    java -classpath ".:./bin:$JAVA_HOME/lib/sa-jdi.jar" -Dsun.jvm.hotspot.tools.jcore.filter=MyFilter sun.jvm.hotspot.tools.jcore.ClassDump 7566

    这样就得到了./sun/reflect/GeneratedSerializationConstructorAccessor1.class文件。那么用javap就能查看到它的内容:
    Classfile /D:/experiment/test_java_deserialize/sun/reflect/GeneratedSerializationConstructorAccessor1.class
    Last modified 2010-12-23; size 1313 bytes
    MD5 checksum 6d59fc9bb0c7d58458cdc76714829a0f
    public class sun.reflect.GeneratedSerializationConstructorAccessor1 extends sun.reflect.SerializationConstructorAccessorImpl
    minor version: 0
    major version: 46
    flags: ACC_PUBLIC

    Constant pool: // ...
    {
    public sun.reflect.GeneratedSerializationConstructorAccessor1();
    flags: ACC_PUBLIC

    Code:
    stack=1, locals=1, args_size=1
    0: aload_0
    1: invokespecial #36 // Method sun/reflect/SerializationConstructorAccessorImpl."<init>":()V
    4: return

    public java.lang.Object newInstance(java.lang.Object[]) throws java.lang.reflect.InvocationTargetException;
    flags: ACC_PUBLIC

    Exceptions:
    throws java.lang.reflect.InvocationTargetException
    Code:
    stack=6, locals=2, args_size=2
    0: new #6 // class TestClass
    3: dup
    4: aload_1
    5: ifnull 24
    8: aload_1
    9: arraylength
    10: sipush 0
    13: if_icmpeq 24
    16: new #22 // class java/lang/IllegalArgumentException
    19: dup
    20: invokespecial #29 // Method java/lang/IllegalArgumentException."<init>":()V
    23: athrow
    24: invokespecial #12 // Method java/lang/Object."<init>":()V
    27: areturn
    28: invokespecial #42 // Method java/lang/Object.toString:()Ljava/lang/String;
    31: new #22 // class java/lang/IllegalArgumentException
    34: dup_x1
    35: swap
    36: invokespecial #32 // Method java/lang/IllegalArgumentException."<init>":(Ljava/lang/String;)V
    39: athrow
    40: new #24 // class java/lang/reflect/InvocationTargetException
    43: dup_x1
    44: swap
    45: invokespecial #35 // Method java/lang/reflect/InvocationTargetException."<init>":(Ljava/lang/Throwable;)V
    48: athrow
    Exception table:
    from to target type
    0 24 28 Class java/lang/ClassCastException
    0 24 28 Class java/lang/NullPointerException
    24 27 40 Class java/lang/Throwable
    }


    对应的Java代码(示意,里面的逻辑用Java无法直接表示,因为Java里new表达式同时包含了创建对象与调用构造器,而且这两个动作必须针对同一类型;而这里创建了TestClass的实例却调用了Object的无参构造器):
    package sun.reflect;

    public class GeneratedSerializationConstructorAccessor1
    extends SerializationConstructorAccessorImpl {
    public GeneratedMethodAccessor1() {
    super();
    }

    public Object newInstance(Object[] args)
    throws InvocationTargetException {
    try {
    // create an unitialized TestClass instance
    TestClass temp = newUnitializedTestClassInstance(); // new #6 // class TestClass
    // dup
    // check parameters
    if (args.length != 0) throw new IllegalArgumentException();
    } catch (final ClassCastException | NullPointerException e) {
    throw new IllegalArgumentException(e.toString());
    }
    // invoke Object() constructor
    try {
    invokeObjectConstructor(temp); // invokespecial #12 // Method java/lang/Object."<init>":()V
    return temp; // areturn
    } catch (Throwable t) {
    throw new InvocationTargetException(t);
    }
    }
    }

    (注:上面代码为了省事用了[url=http://blogs.sun.com/darcy/entry/project_coin_multi_catch_rethrow]Java 7的multi-catch语法[/url])

    可以留意一下一段有趣的注释:
    package sun.reflect;

    /** <P> Java serialization (in java.io) expects to be able to
    instantiate a class and invoke a no-arg constructor of that
    class's first non-Serializable superclass. This is not a valid
    operation according to the VM specification; one can not (for
    classes A and B, where B is a subclass of A) write "new B;
    invokespecial A()" without getting a verification error. </P>

    <P> In all other respects, the bytecode-based reflection framework
    can be reused for this purpose. This marker class was originally
    known to the VM and verification disabled for it and all
    subclasses, but the bug fix for 4486457 necessitated disabling
    verification for all of the dynamically-generated bytecodes
    associated with reflection. This class has been left in place to
    make future debugging easier. </P> */

    abstract class SerializationConstructorAccessorImpl
    extends ConstructorAccessorImpl {
    }


    一些相关的值得关注的方法和类有:
    java.io.ObjectStreamClass.getSerializableConstructor()
    sun.reflect.ReflectionFactory.newConstructorForSerialization()
    sun.reflect.MethodAccessorGenerator.generateSerializationConstructor()
    sun.reflect.SerializationConstructorAccessorImpl

    ======================================================================

    上面用Sun JDK来演示了反序列化的一种可能的实现方式。事实上Sun JDK也是从1.4开始才采用这种方式的,之前使用的是别的方式。这种方式使用了无法通过校验(verification)的字节码序列,硬要说的话是与JVM规范冲突的;为了能执行它而不出错,HotSpot VM里专门开了后门。

    请注意区分“规范”与实现之间的差异。
    规范一般定得会比较紧,而实现则可能在许多地方“走捷径”,只要不让上面的用户能感知到走了捷径就没问题 ∩^_^∩
    展开全文
  • 但是,JavaScript中也有构造函数,其使用的语法与Java或其他基于类的语言中创建对象的语法相似,也可以使用自己的构造函数或使用一些类似于Object()、Date()、String()的内置构造函数以创建对象。那么为什么我们平时...

    JavaScript中并没有类的概念,但是它却支持极大的灵活性,因为不必预先知道对象的一切细节。但是,JavaScript中也有构造函数,其使用的语法与Java或其他基于类的语言中创建对象的语法相似,也可以使用自己的构造函数或使用一些类似于Object()、Date()、String()的内置构造函数以创建对象。

    那么为什么我们平时都是使用字面量表示法,即用花括号{}来创建一个对象,而不是使用内置构造函数Object()创建对象呢?

    在下面的例子中展示了以两种等价的方法来创建两个相同的对象:

    //第一种方法——使用字面量const dog = {

    color: "white"

    };

    //第二种方法——使用内置构造函数const dog = new Object();

    dog.color = "white";

    从上面这个例子可以看出:字面量表示法的显著优点在于它仅需要输入更短的字符;

    使用字面量的另一个原因在于它并没有作用域解析,也就是说如果你使用Object()创建对象的话,代码中可能以同样的名字创建了一个局部构造函数,解析器需要从调用Object()的位置开始一直向上查询作用域链,直到发现全局Object()这个内置构造函数。就算没有一个一样名字的局部构造函数,同样也会去作用域解析。而字面量在设计上就已经等同于new Object(),被设计为无需作用域解析。

    完!

    展开全文
  • c++ 用new创建对象不用new创建对象的区别 直接看代码: #include <iostream> using namespace std; class A { public: int a = 0; A(){ cout << "默认构造函数被调用" << endl; } A...

    c++ 用new创建对象和不用new创建对象的区别


    直接看代码:

    #include <iostream>
    using namespace std;
    class A {
    
    	
    public:
    	int a = 0;
    	A(){
    		cout << "默认构造函数被调用" << endl;
    	}
    	A(int s) :a(s) {
    		cout << "构造函数被调用" << endl;
    	}
    	~A() {
    		cout << "析构函数被调用"<<endl;
    	}
    };
    int main()
    {
    	{
    		A a;
    		A* b = new A(2);
    	}
    	cin.get();
    }
    

    运行结果如下:

    默认构造函数被调用
    构造函数被调用
    析构函数被调用
    

    可以看出,区别如下:

    new创建类对象需要指针接收,一处初始化,多处使用
    new创建类对象使用完需delete销毁
    new创建对象直接使用堆空间,而局部不用new定义类对象则使用栈空间
    new对象指针用途广泛,比如作为函数返回值、函数参数等
    频繁调用场合并不适合new,就像new申请和释放内存一样
    

    上面代码在跳出局部指针变量b的作用域时,没有用delete进行内存释放,跳出变量b的作用域后,b被销毁,我们再也找不到指向用new创建的对象的指针,因此再也无法释放那块内存,造成内存泄露。

    展开全文
  • 看了这篇文章,可以帮助你理解如下内容: 1、向原型链上添加属性为什么用prototype,而一般不用__proto__ ...对象字面量创建的是对象,而构造函数创建的是函数对象。为了帮助理解,我写了一些代码。...
  • 对象创建的时候一定会执行构造方法。构造方法的作用如下: 一、构造方法可以来初始化对象。看这行代码: (已预先定义了ClassA类) ClassA a = new ClassA(10,“OK”); Java程序执行这行代码将先后做三个动作:...
  • 1、为什么QT程序有时候直接用构造函数创建对象,有时候用new创建对象 2、为什么QT用new创建对象不用delete 答案在这里: http://shouce.jb51.net/qt-beginning/48.html ...
  • 析构函数是对象创建的一部分,在创建对象时,会被自动调用;创建对象后,析构函数就不能再被调用 默认析构函数:不带参数,或者所有参数都有默认值的的析构函数,析构函数可以重载。 类的析构函数一般是公开的,...
  • 今天看到两篇不错的文章:实例构造器是不是静态方法?答复: 不用构造方法也能创建对象其中提到JVM构造对象的4种方式:new构造函数,反射,反序列化,clone
  • 创建对象时可以带参 Fun1 里生成一个对象, 并返回该对象 参数存在 obj1 本身 实例化对象改变属性值后, 相互不影响 function Fun1(value1, value2, value3) { var _obj = new Object(); _obj.value1 = value1; _...
  • 1.构造函数用来创建对象,并且可以在构造函数中对对象进行初始化. (给对象的每个属性依次的赋值) 2.构造函数是用来创建对象的特殊方法: 1.方法名和类名一样. 2.没有返回值,连void都不用.. **创建对象的...
  •  * 前者会创建2个或者1个对象,后者会创建1个或者0个对象。(因为前者去方法区找如果找到了"hello"就不用创建了)  * ==:比较引用类型比较的是地址值是否相同  * equals:比较引用类型默认也是比较地址值是否相同...
  • C++对象构造与析构构造函数和析构函数初始化与清理构造函数语法析构函数语法构造函数的分类及调用拷贝构造函数的调用时机构造函数调用规则 构造函数和析构函数 初始化与清理 当大家买手机电脑的时候,都有一个初始...
  • public class ...//构造方法对对象中所有的成员变量进行初始化,在创建对象时就被调用。 public String color; //定义成员变量 public Orchard(){ //构造方法 color="绿色"; //初始化成员变...
  • 构造函数: 特点: 1、函数名与类名相同 2、不用定义返回值类型 3、没有具体的返回值 作用:给对象进行初始化。... 3、创建对象时,构造函数已经被调用并执行。 public class Person { private String name; private
  • 字面量创建对象

    2020-11-11 16:32:44
    在JavaScript高级程序设计第三版书籍中,推荐使用字面量表示法创建对象构造函数创建和字面量创建: var obj = new Object(); obj.name = 'zed'; console.log(obj) var obj1 = { name: 'zed' } console....
  • 构造函数:主要用于创建对象时,为对象的成员属性赋值,构造函数是编译器自动调用的,无需我们手工调用。 析构函数:主要用于对象销毁前,系统自动调用,执行一些清理工作。 构造函数的语法:类名(){} 1、不用写...
  • 对象创建完成后,“第一个”“自动调用”的方法 * * 2.构造方法的定义,方法名是一个固定的, * 在php4中:和类名相同的方法就是构造方法 * 在php5中:构造方法选择使用 魔术方法__construct() 所有类中声明构造方法...
  • java创建对象方法列表

    2019-10-07 22:25:37
    不用构造方法也能创建对象 前言 java中对象创建的方法主要包括,1,使用new关键字,2.使用clone方法,3.反射机制,4.反序列化。其中1,3都会明确的显式的调用构造函数。2是在内存上对已有对象的影印,所以不会调用...
  • Java如何创建对象问题

    2016-05-21 12:18:08
    如果有人问我,可不可以不用构造函数来创建对象? 我回答:可以,比如说正则表达式中的Pattern类,没有构造函数,需要使用其方法 compile(String regex) 来将给定的正则表达式编译到模式中。返回了一个Pattern...
  • 通过new Object方式来创建对象,Object为系统自带的构造函数 var obj2 = new Object({hobby:’篮球’,girlf:’美女’});//如果不加参数,则返回空对象。此创建方式基本不用 //3. 自建构造函数的方
  • 如果不用构造函数初始化,该怎么办: 为每个类都提供一个public的initialize函数; 对象创建后立即调用initialize函数进行初始化。 缺点1)initialize只是一个普通的函数,必须显示的调用2)一旦由于失误的原因,...
  • 构造函数 ...创建的每一个对象都是一个实体,每个实体必须要进行初始化后才可以使用,实体的初始化是需要通过动作来完成的,这个动作就是构造函数,构造函数的作用:就是给对象进行初始化。 ...
  • 这种方式创建对象代码比较多,每创建一个对象都要写很多代码,一般不用 let personal = new Object() personal.name = 'wangwu' personal.age = 18 console.log(personal) //{name: "wangwu", age: 18} 字面量...
  • 对象构造和析构

    2019-02-25 11:36:00
    那么随着我们使用手机和电脑的时间越来越久,那么电脑和手机会慢慢被我们手动创建很多文件数据,某一天我们不用手机或电脑了,那么我们应该将电脑或手机中我们增加的数据删除掉,保护自己的信息数据。 从这样的过程...
  • 除了可以使用构造函数创建对象,使用对象字面量也可以来创建一个对象。 使用对象字面量可以在创建对象时,直接指定对象中的属性,语法格式:{属性名:属性值,属性名:属性值} var obj = { name: "齐天大圣", sex: ...
  • IOC容器创建对象方式

    2019-04-17 13:36:36
    1、无参构造器 //默认无参数构造器 2、有参数构造器 //基本类型的就写基本类型,引用类型的一定要写全名 ...//用工厂来创建对象,就不用bean的class属性了。 //先创建工厂 //在创建user对象,用fa...
  • 所以,请问有办法写成调用静态方法前,先调用构造函数吗? Radix temp; cout << temp.two_to_ten("1010") << endl; cout << temp.sixteen_to_eight("3D") << endl; cout <<...
  • 对象的定义其实很广泛,万物皆为对象,我们创建对象一般都是用构造函数来创建的,这里我们来说说构造函数创建对象的原型图把. 这个问题有点抽象,举个例子来说,方便一点: 这是我们构造函数,这里我们要结合一张 图来...
  • 不用构造方法也能创建对象 前言 java中对象创建的方法主要包括,1,使用new关键字,2.使用clone方法,3.反射机制,4.反序列化。其中1,3都会明确的显式的调用构造函数。2是在内存上对已有对象的影印,所以不会...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,469
精华内容 587
关键字:

创建对象不用构造