精华内容
下载资源
问答
  • java创建对象几种方式

    千次阅读 2018-09-17 16:57:17
    最简单最常用的创建对象方式,包括无参的和有参的构造函数。 例如: 通过NEW关键字创建方式: Test test = new Test();//通过无参构造函数创建 Test test1 = new Test(this);//this表示上下...

    面试被问到此问题,回答的不够完全,故自己网上搜索总结一下,如有不足之处请指出,谢谢。

    1、通过java关键字NEW创建对象

    最简单最常用的创建对象方式,包括无参的和有参的构造函数。
    例如:
    通过NEW关键字创建方式:

        Test test = new Test();//通过无参构造函数创建
        Test test1 = new Test(this);//this表示上下文context
    
        //Test对象
        public class Test{
            public Test(){
    
            }
            public Test(Context context){
    
            }
        }

    2、通过工厂方法返回对象

    如:String str = String.valueOf(10);

    3、通过反射手段返回对象

    • 调用java.lang.Class类的newInstance()方法
            //newInstance
            String className = "com.song.Test";//reference
            try {
                Test test2 = (Test)Class.forName(className).newInstance();
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
            //或者
            try {
                Test test3 = Test.class.newInstance();
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
    • 调用java.lang.reflect.Constructor类的newInstance()方法
            try {
                //拿到Constructor构造器
                Constructor<Test> constructor = Test.class.getConstructor();
                try {
                    //通过构造器的newInstance返回对象
                    Test Test4 = constructor.newInstance();
                } catch (InstantiationException e) {
                    e.printStackTrace();
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                } catch (InvocationTargetException e) {
                    e.printStackTrace();
                }
            } catch (NoSuchMethodException e) {
                e.printStackTrace();
            }

    4、通过对象的clone()方法返回对象

    需要满足一下两点条件:
    1)、需实现Cloneable接口
    2)、覆盖clone方法
    例如:

         //CLONE
         try {
             Test test5 = (Test)test.clone();
         } catch (CloneNotSupportedException e) {
             e.printStackTrace();
         }
    
    
        //Test
        public class Test implements Cloneable{
    
            @Override
            protected Object clone() throws CloneNotSupportedException {
                return super.clone();
            }
    
            public Test(){
    
            }
    
            public Test(Context context){
    
            }
        }

    5、通过I/O流(反序列化)返回对象

    调用java.io.ObjectInputStream对象的 readObject()方法返回对象
    * 需要实现Serializable接口

        public class Test implements Serializable{
    
    
            public Test(){
    
            }
    
            public Test(Context context){
    
            }
        }

    例如;

            // Serialization
            String fileName = "D:/serializaton.txt";//文件的具体路径
            try {
                ObjectOutputStream o = new ObjectOutputStream(new FileOutputStream(fileName));
                o.writeObject(test);
                o.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
    
            // Deserialization
            try {
                ObjectInputStream i = new ObjectInputStream(new FileInputStream(fileName));
                try {
                    //通过readObject()方法返回对象
                    Test test6 = (Test)i.readObject();
                    i.close();
                } catch (ClassNotFoundException e) {
                    e.printStackTrace();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }

    参考文章
    https://www.cnblogs.com/wxd0108/p/5685817.html
    https://www.cnblogs.com/baizhanshi/p/5896092.html
    https://blog.csdn.net/coffee801/article/details/71080634
    https://blog.csdn.net/hustzw07/article/details/72518298

    展开全文
  • js创建对象几种方式

    千次阅读 2017-10-20 14:16:47
    1.通过字面量方式创建 方法:将成员信息写到{}中,并且赋值给一个变量。此时的这个变量就是一个对象 例如:var person={ name:'jack', ...通过该方法创建对象时,会自动执行该构造函数 例如: f

    1.通过字面量方式创建

    方法:将成员信息写到{}中,并且赋值给一个变量。此时的这个变量就是一个对象

    例如:

    var person={
    name:'jack',
    sex:'girl',
    job:function(){}
    }
     person.job();

    2.通过构造函数创建

    方法:var person=new 函数名();

    通过该方法创建对象时,会自动执行该构造函数

    例如:

    function Person(){
    this.name='jack';
    this.sex='girl';
    this.job=function(){
    alert('program');
    }
    alert('123');
    }
    var child=new person();
    person.job();

    此代码一共会两次跳出对话框,因为创建对象时会自动执行构造函数一次。this指的是调用函数的对象

    3.通过object方式创建

    方法:通过object构造器new一个对象,再丰富成员信息

    var person=new Object();
    person.name='jack';
    person.sex='girl';
    

    4.通过object.create方式创建

    var p={name:'jack',sex:'girl'};
    var object1=Object.create(p);

    推荐好文: 点击打开链接


    展开全文
  • 创建对象几种方式

    千次阅读 2017-04-11 18:25:20
    在javascript中,所有对象创建都是基于原型的。在js中任意的对象都有一个内部属性[[Prototype]]。这个属性的值只能是object或者是null。对象有这个内部属性的目的就是为了实现继承,或者更明确的说实现属性(方法...

    在javascript中,所有对象的创建都是基于原型的。在js中任意的对象都有一个内部属性[[Prototype]]。这个属性的值只能是object或者是null。对象有这个内部属性的目的就是为了实现继承,或者更明确的说实现属性(方法)的复用。所以说创建一个对象的关键就是确定[[prototype]]的值。一般情况下,如果创建了一个对象什么属性也没有那么这个对象的原型就是Object.prototype。假设创建的对象的原型为null的话,则将不会继承toString等方法,也就不会进行相应的操作了。可以设么说,原型是js的核心。

     

    创建一个对象有四种方式,分别是ES3之前的通过对象字面量创建、ES3中通过new创建对象、ES5标准下通过Object.create的方式创建对象、还有就是ES6中通过__proto__、Object.setPrototypeOf创建对象。其实上述这些方式根本是对对象的原型属性的操纵。

     

    一、通过对象字面量创建对象

    var myObj = {

        name: "maotr",

        "ID  code": 21

    };

    通过对象字面量窗帘对象中,创建对象表达式每执行一次,表达式每部的被赋值的表达式也会执行一次,所以会出现下面这个情况:

    function f() {

        return myObj = {

            name: "maotr",

            eat: function () {}

        };

    }

    console.log(f() === f());//false

    console.log(f().eat === f().eat);//false

    所以说使用这种方式创建对象的话仅仅限于单例模式,对于其他的方式会很消耗内存的。

     

    除了我们都知道的对象的属性除了可以是标识符之外,如果不符合标识符条件可以通过字符串的形式引用,比如:一开始那个例子。即使在ES5标准下,通过这种方式定义的对象的属性是不能变的。也就是说只能是标识符或者字符串常量。如果要使用变化的属性怎么办,只能通过如下方式:

    function f(name, value) {

        var o = {

            x: 2,

            y: 4

        };

        o[name] = value;//使用[]访问运算符进行添加属性。

        return o;

    }

    但是在ES6标准下,可以这样了:

    function f(name, value) {

        return {

            x: 2,

            y: 4,

            [name]: value

        };

    }

    console.log(f("z", 10).z);//10

    也就是说,在ES6中:左边的属性名不再要求是常量了,而是可以使表达式。工作方式是:当执行到一个对象字面量表达式的时候,除了创建一个对象和计算每一个属性的值之外,还会计算:左边的方括号内的表达式,并且将结果通过调用内部的toString函数转化成字符串,也就是说如下实例:

    function f(name, value) {

        return {

            x: 2,

            y: 4,

            [name+4]: value

        };

    }

    console.log(f("^", 10)["^4"]);//10

     

     

    二、通过new关键字创建对象

    New更像是为了能够靠近面向对象类式语言而引入的。New关键字实现的功能就是将一个对象的原型属性绑定到构造函数的prototype中去,然后执行构造函数执行初始化。所以这么看来函数中有prototype也是为了类式风格的面向对象设计而引入的。但是对于js本身而言,实现类或者继承使用原型的方式更加纯粹。

    对于new关键字是如何工作的呢?看一下规范就明白了。

     

     

    我们可以不是同new和函数内部的prototype情况下模拟类的创建。

    function defineClass(initializer, proto) {
        if(typeof initializer !== 'function') {
            throw TypeError('the initializer may only an function');
        }
        return (function f() {
           var obj, result;
          if(!(proto instanceof Object)) {
            proto = Object.prototype;
          }else {
            proto.constructor = initializer;
          }
           //obj = Object.create(proto); ES5
           function Temp() {};
           Temp.prototype = proto;
           obj = new Temp();
           f.prototype = proto;
     
           result = initializer.apply(obj, arguments);
           if(result instanceof Object) {
                obj = result;
           }
     
           return obj;
        });
    }
     
    var Point = defineClass(function (x, y){
        this.x = x;
        this.y = y;
    },{
        getLength: function(){
            let {x, y} = this;
            return Math.sqrt(x * x + y * y);
        }
     
    });
     
    var p = Point(3,4);
     console.log(p.getLength(),p instanceof Point, p instanceof Object);//5 true true


    所以这种通过new创建对象的方式使得创建对象时要创建一个函数作为构造函数,使得原型这个工具使用起来比较局限,不能灵活的去使用。下面介绍的Object.create略有改善。

     

    三、通过Object.create创建对象

    Object.create函数传入第一个参数是返回的对象的原型,第二个参数是添加到对象中的属性的特性的描述。但是对于IE6到8来说存在兼容性的问题。所以要处理兼容性:

    if (typeof Object.create !== 'function') {
        Object.create = (function () {
            //为了省内存,共享一个构造器
            function Temp() {};
     
            //使用Object.propertype.hasOwnProperty更安全的引用
            var hasOwn = Object.prototype.hasOwnProperty;
     
            return function (proto, properties) {
                //1、如果proto不是Object或者null,则抛出异常
                if(typeof proto !== 'object') {
                    throw TypeError('Object prototype may only be an Object or null');
                }
     
                //2创建一个对象obj,和通过new Object()方式创建的一样
                //3设置obj的prototype值为proto
                Temp.prototype = proto;
                var obj = new Temp();
                Temp.prototype = null;//不要保持一个proto的杂散引用
     
                //4如果存在参数properties 而不是undefined
                //那么就把参数的自身属性添加到obj上,就像是调用
                //携带obj,properties两个参数的标准内置函数
                //Object.properties()一样
                if (properties !== undefined) {
                    for (var key in properties) {
                        if(hasOwn.call(properties, key)) {
                            obj[key] = properties[key];
                        }
                    }
                }
                //5返回obj
                return obj;
            }
        })();
    }


     

    ES5这个方法的提出,使得创建对象可以直接明确的赋予原型值,使得原型成为一个可以控制的量,真正的将js原型的功能发挥出来,但是有一个缺点就是一旦创建了这个对象之后,这个对象就和这个传入的原型对象绑定在一起,不够灵活。下面ES6能够直接操作对象的原型属性,所以更加灵活了。

     

    四、通过Object.setPrototypeOf创建对象。

     

    Object.setPrototypeOf方法,用来设置一个对象的prototype对象,返回参数对象本身。

     

    let proto = {};let obj = { x: 10 };

    Object.setPrototypeOf(obj, proto);

     

    proto.y = 20;

    proto.z = 40;

     

    obj.x // 10

    obj.y // 20

    obj.z // 40


    注意返回的是设置对象本身,所以:

    如果第一个参数不是对象,会自动转为对象。但是由于返回的还是第一个参数,所以这个操作不会产生任何效果。

    Object.setPrototypeOf(1, {}) === 1 // true

    Object.setPrototypeOf('foo', {}) === 'foo' // true

    Object.setPrototypeOf(true, {}) === true // true


    由于undefined和null无法转为对象,所以如果第一个参数是undefined或null,就会报错。

    Object.setPrototypeOf(undefined, {})

    // TypeError: Object.setPrototypeOf called on null or undefined

    Object.setPrototypeOf(null, {})

    // TypeError: Object.setPrototypeOf called on null or undefined

     

    展开全文
  • C++对象创建几种方式

    千次阅读 2019-11-21 17:18:16
               C++对象创建几种方式    由于公司的项目众多,且底层由众多团队操刀实施,这样不利于代码的管理和平台的统一性,所以为了将众多的底层C实现的代码整合起来,不得不借助C++的面相对象,...

               C++对象创建的几种方式


       由于公司的项目众多,且底层由众多团队操刀实施,这样不利于代码的管理和平台的统一性,所以为了将众多的底层C实现的代码整合起来,不得不借助C++的面相对象,而我也不得不捞起早已经忘的差不多的C++语法了。下面先来点简单的C++中对象创建的几种方式。



    具体实现

       先直接上代码,给大家演示一下,后续再来详细解释几种创建的方式,具体代码如下:

    #include<stdio.h>
    using namespace std;
    class ObjectClass{
    public:
    	void fun(){
    		printf("Hello, Im c++ objectClass\n");
    	}
    };
    
    int main(){
    	ObjectClass obj1;//栈中分配  ,由操作系统进行内存的分配和管理
    	ObjectClass obj2 = obj1; //栈中分配  ,由操作系统进行内存的分配和管理
    	obj1.fun();//"." 是结构体成员引用
    	obj2.fun();//"." 是结构体成员引用
    
    	ObjectClass * obj3 = new ObjectClass(); //堆中分配  ,由管理者进行内存的分配和管理,用完必须delete(),否则可能造成内存泄漏
    	obj3->fun();//->是指针引用
    	delete(obj3);
    	return 0;
    }	
    
    root@A920:/system/bin # ./ObjectClass
    Hello, Im c++ objectClass
    Hello, Im c++ objectClass
    Hello, Im c++ objectClass
    
    


    上面就是具体的演示代码,下面分析一下几种创建方式:
    (1).第一种和第二种:这两种没什么区别,一个隐式调用,一个显式调用,两者都是在进程虚拟地址空间中的栈中分配内存。用这种方法创建的对象,内存分配到栈里(Stack)。使用 “.” 而不是 “->” 调用对象的方法。当程序离开对象的使用范围(如方法结束,一个程度块的最后{}),范围内的栈中的对象会自动删除,内存自动回收。这是创建对象最简单的方式栈是系统数据结构,对于线程/进程是唯一的,它的分配和释放由操作系统决定,不需要由开发者来管理。在执行函数时,函数内局部变量的存储单元可以在栈上创建,函数执行完毕,系统会自动释放这些存储单元。

    (2).第三种:使用了new,在堆中分配了内存,堆上的内存分配,亦称动态内存分配。程序在运行的期间用malloc申请的内存,这部分内存由程序员自己负责管理,其生存期由开发者决定:在何时分配,分配多少,并在何时用free来释放该内存。这是唯一可以由开发者参与管理的内存。使用的好坏直接决定系统的性能和稳定。注意:栈中内存的分配和管理由操作系统决定,而堆中内存的分配和管理由管理者决定。在堆中的对象不会自动删除,内存不会自动回收,所以new一个对象使用完毕,必须调用delete,释放内存空间。也就是说,new和delete必须成对出现

    我们需要的内存很少,你又能确定你到底需要多少内存时,用栈。当你需要在运行时才知道你到底需要多少内存时,请用堆。



    总结

       最后我们来总结一下C++语法new创建对象的特点和C++内存分配常见的几种方式:

    (1) 关于new创建类对象特点

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

    (2).C++内存分配三种方式

    • 从静态存储区域分配。内存在程序编译的时候就已经分配好,这块内存在程序的整个运行期间都存在。例如全局变量,static 变量。

    • 在栈上创建。在执行函数时,函数内局部变量的存储单元都可以在栈上创建,函数执行结束后在将这些局部变量的内存空间回收。在栈上分配内存空间效率很高,但是分配的内存容量有限。

    • 从堆上分配的。程序在运行的时候用 malloc 或 new 申请任意多少的内存,程序员自己负责在何时用 free 或 delete 释放内存。

    展开全文
  • 创建对象方式几种

    千次阅读 2018-11-04 20:16:27
    最近看到一个java面试题是:创建对象方式几种 很多同学看到这道题第一想法肯定是new出来。其实除了new对象的方式以外还有很多种下面我们来看看。 一、new Obj..() 这种方式应该是很多人最经常使用的不过在...
  • JavaScript 创建对象几种方式

    千次阅读 2018-07-13 09:43:41
    这里创建对象,主要介绍三种方式:工厂模式、构造函数模式、原型模式、组合使用构造函数模式和原型模式。1、工厂模式 工厂模式是用函数来封装创建对象的细节,在函数里面创建对象并返回对象。function createPerson...
  • js创建对象几种方式

    千次阅读 2018-11-25 10:17:39
        工厂模式的虽然解决了一个一个的创建对象的问题,但却没有解决对象识别问题(怎么知道一个 对象的类型 )返回的都是Object类型 构造函数模式     ECMAScript中的构造函数可以用来创建特定类型的对象。...
  • js创建对象几种方式-转载

    千次阅读 2018-05-22 10:18:17
     2、构造函数模式 与工厂模式相比: 1、没有显式的创建对象 2、直接将属性和方法赋给了this对象 3、没有return语句 要创建person的实例,必须使用new操作符,以这种方式调用构造函数实际上会经历4个步骤: 1...
  • Spring创建对象几种方式

    千次阅读 2018-03-26 11:04:59
    Spring的核心思想是IOC,即所有对象的创建都是...Spring创建对象有以下几种方式: 无参构造器 有参构造器 工厂模式 静态方法 非静态方法 构造器创建对象 applicationContext.xml &lt;beans xmlns="...
  • Go语言中创建对象几种方式

    千次阅读 2020-10-08 14:39:33
    对于Go对象 type Car struct { color string size string } 方式一:使用T{…}方式,结果为值类型 c := Car{} 方式二:使用new的方式,结果为指针类型 c1 := new(Car) 方式三:使用&方式,结果为指针类型 ...
  • java中创建对象几种方式

    千次阅读 2017-06-26 15:58:42
    创建对象几种方式
  • ① 最常见的方式就是直接 new 加构造器的方式创建 ② 变形一:XXX(类名). 静态方法,本质这种方式还去调用类中构造器,比如说:单例模式、日历类(Calendar) 和一些工具类等等。 ③ 变形二:XXXBuilder / ...
  • 利用反射创建对象几种方式

    千次阅读 2019-05-23 15:50:42
    创建对象 1.使用Class对象的newInstance()方法来创建类的实例,这种方式要求该Class对象的对应类有默认构造器,执行newInstance()实际上是利用默认构造器来创建该类的实例。 2.先使用Class对象获取到Constructor对象...
  • js创建自定义对象几种方式

    千次阅读 2019-04-16 11:47:41
    1. 对象字面量方式(通过JSON来创建对象)。 对象字面量方式是创建自定义对象的首选模式,简单方便。 var person = { name: '小白开发', job: 'html', getName: function () { alert(this.name); } } 缺点:使用...
  • javascript中创建对象几种方式

    万次阅读 2012-08-27 22:24:33
    javascript 中常见的创建对象几种方式。    1. 简单对象的创建 使用对象字面量的方式{} 创建一个对象(最简单,好理解,推荐使用) var Cat = {};//JSON Cat.name="kity";//添加属性并赋值 Cat.age=2; Cat....
  • java创建对象实例的四种方式

    千次阅读 2018-05-21 21:26:05
    java创建对象的方法常用的有四:使用new关键字、利用java的放射机制、实现Cloneable接口使用克隆方法以及利用java序列化和反序列化实现创建对象。不说那么多,直接上代码。本次主要讲前三中创建方式,只是大致讲解...
  • 博主总结Java中有5种创建对象方式,下面给出它们的例子还有它们的测试代码:首先,列举这5种创建对象方式: 使用得方法 是否调用构造函数 使用New关键字 是 使用Class类的newInstance 是 使用Constructor...
  • Java创建对象的四种方式

    万次阅读 多人点赞 2016-05-09 16:47:56
     通过反射来生成对象有如下两种方式: (1)使用Class对象的newInstance()方法来创建该Class对象对应类的实例。但是这种方式要求该Class对象的对应类有默认的构造器,而执行newInstance()方法时实际上是利用...
  • Java中创建对象几种方式

    千次阅读 2017-05-19 10:10:00
    然后究竟有多少种创建对象的方法呢? 这里列举一下:使用New关键字、使用Class类的newInstance方法、使用Constructor类的newInstance方法、使用Clone方法、使用反序列化。 new关键字 这是最简单最常用的创建对象...
  • Java创建对象的5种方式

    万次阅读 多人点赞 2018-10-07 13:30:08
    Java有5种方式创建对象: 使用 new 关键字(最常用):  ObjectName obj = new ObjectName(); 使用反射的Class类的newInstance()方法:  ObjectName obj = ObjectName.class.newInstance(); 使用反射的...
  • JAVA创建对象有哪几种方式

    千次阅读 2015-06-09 17:11:59
    有4显式地创建对象方式: 1.用new语句创建对象,这是最常用的创建对象方式。 2.运用反射手段,调用java.lang.Class或者java.lang.reflect.Constructor类的newInstance()实例方法。 3.调用对象的clone...
  • Java创建对象几种方式

    千次阅读 2014-05-14 20:43:39
    Java创建有四种方式: (1)用new 语句创建对象,这是最常用的创建对象方法。 (2)运用反射手段,调用java.lang.Class或者java.lang.reflect.Constructor类的newInstance()实例方法。 (3)调用对象的clone()...
  • 创建对象方式 方式 是否调用了构造函数 使用new关键字 是 使用Class类的newInstance方法 是 使用Constructor类的newInstance方法 是 使用clone方法 否 使用反序列化 否 1.使用new...
  • 1、通过new语句实例化一个对象 2、通过反射机制动态创建对象 3、通过clone()创建对象 4、通过反序列化的方式创建对象
  • 一、由一对大括号括起来 var emptyObj = {}; var myObj = { 'id': 1, //属性名用引号括起来,属性间由逗号隔开 'name': 'myName' ... 不知你注意到对象都是用 var 声明的没有,像上面的代码,就只
  • 创建(实例化)对象的五种方式

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

    千次阅读 2018-09-14 20:07:51
    创建对象几种方式 在java中,万事万物皆对象,作为开发者,我们每天也会创建大量的对象。那么你知道有几种创建对象的方式吗? 一、使用new关键字 Student student=new Student(); 这种方式是我们最熟知的方式...
  • Java创建对象的四方法

    千次阅读 2019-05-22 16:33:56
    Java创建对象的四方法 使用New关键字 使用Class类的newInstance方法,newInstance方法调用无参构造器创建对象(反射),Class.forName.newInstance(); 使用clone方法 反序列化 使用构造器的两:New关键字...
  • java 创建对象几种不用方式

    千次阅读 2017-05-09 18:25:49
    作为java开发者,我们每天创建很多对象,但是我们通常使用依赖注入的方式管理系统,比如:Spring去创建对象,然而这里有很多创建对象的方法:使用New关键字、使用Class类的newInstance方法、使用Constructor类的new...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,262,347
精华内容 504,938
关键字:

创建对象的几种方式