精华内容
下载资源
问答
  • 创建或实例化对象
    千次阅读
    2022-04-16 18:47:15

    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申请和释放内存一样。

    更多相关内容
  • Unity 创建/实例化对象

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

    在程序运行过程中创建、实例化对象物体需要用到Object类中的 Instantiate 函数,例如,我们场景中有一个物体A: 

    现在我们想要在场景中创建五个该物体,则用Instantiate函数将该物体作为参数传入:

    using UnityEngine;
    
    public class Foo : MonoBehaviour
    {
        public GameObject A;
    
        private void Start()
        {
            for (int i = 0; i < 5; i++)
            {
                Instantiate(A);
            }
        }
    }

    运行效果:

    场景中多出的五个A(Clone)物体即为我们创建的物体。

    展开全文
  • 创建实例化对象的五种方式

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

    一、Java中创建(实例化)对象的五种方式

    1. 用new语句创建对象,这是最常见的创建对象的方法;
    2. 调用对象的clone()方法;
    3. 运用反射手段,调用java.lang.Class或者java.lang。 reflect.Constructor类的newInstance()实例方法。如:Object obj = Class.forName(“java.lang.Object”)。newInstance();
    4. 通过I / O流(包括反序列化),如运用反序列化手段,调用java.io.ObjectInputStream对象的readObject()方法;
    5. 通过工厂方法返回对象,如:String str = String.valueOf(23);

    1、new关键字创建对象; 2、调用对象的clone()方法创建对象

    /**
     * @ClassName Bigwig
     * @Description new关键字创建对象;
     *              调用对象的clone()方法创建对象
     *              测试Cloneable接口的使用
     *              实例化对象
     * @Author lzq
     * @Date 2019/6/15 19:53
     * @Version 1.0
     **/
    public class Bigwig implements Cloneable{
        private String name;
        private int age;
    
        public Bigwig(String name,int age) {
            this.name = name;
            this.age = age;
        }
    
        public String getName () {
            return name;
        }
    
        public int getAge () {
            return age;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    
        @Override
        protected Object clone() throws CloneNotSupportedException {
            return super.clone();
        }
    
        @Override
        public String toString() {
            String s = "姓名是:"+this.name+"\t年龄是:"+this.age;
            return s;
        }
    }
    
    public static void main(String[] args) throws CloneNotSupportedException {
            Bigwig p1 = new Bigwig("诸葛亮", 30);  //new关键字创建的对象
            System.out.println(p1);
            Bigwig p2 = null;
            p2 = (Bigwig) p1.clone(); 调用对象的clone()方法创建对象
            System.out.println(p2);
            p2.setAge(51);
            p2.setName("司马懿");
            System.out.println(p2);
        }
    

    运行结果:

    姓名是:诸葛亮	年龄是:30
    姓名是:诸葛亮	年龄是:30
    姓名是:司马懿	年龄是:51
    

    3、通过反射对对象进行初始化

    
    import java.lang.reflect.Constructor;
    import java.lang.reflect.InvocationTargetException;
    
    /*
     * 通过反射对对象进行初始化
     * 注意必须有无参数的Constructor
     * 实例化Class类然后调用newInstance()方法
     *
     */
    
    class Student{
     private Integer age;
     private String name;
     
     public Student() {
    	 System.out.println("无参构造");
     }
     
     public Student(String name) {
    	 System.out.println("一参构造");
     }
     
     public Student(String name,Integer age) {
    	 System.out.println("双参构造");
     }
     
    }
    public class TestClass {
      public static void main(String[] args) {
    	  try{
    		  Class clazz = Class.forName("com.xagy.lianxi.Student");
    		  /**
    	       * 调用无参构造函数,
    	       * 效果上和使用class.newInstance()差不多
    	       * 构造函数无参的情况下,可以传入一个空数组,也可以不传入数组
    	       */
    	       Constructor<Student> con = clazz.getConstructor();
    	       Student thisIsTestClass = con.newInstance();
    	       System.out.println("-------------------------------------");
    	        
    	       //依然是无参构造函数
    	       Class[] paramTypeEmpty = {};
    	       Constructor<Student> con0 = clazz.getConstructor(paramTypeEmpty);
    	       Object[] paramEmpty = {};
    	       Student thisIsTestClassEmpty = con0.newInstance(paramEmpty);
    	       System.out.println("-------------------------------------");
    	       
    	       //getConstructor接受变长参数,以Class数组形式传入,
    	       //告诉jdk我们要调用哪个构造器
    	       Class[] paramType1 = {String.class};
    	       Constructor<Student> con1 = clazz.getConstructor(paramType1);
    
    	       //Constructor实例的newInstance同样也是接受一个变长参数,
    	       //参数数组中类型要和getConstructor的类型对应
    	       Object[] params1 = {"ParamOne"};
    	       Student thisIsTestClass1 = con1.newInstance(params1);
    	       System.out.println("-------------------------------------");
    
    	       //params2中的数据类型要和paramTypes2中的类型相对应
    	       Class[] paramTypes2 = {String.class,Integer.class};
    	       Constructor<Student> con2 = clazz.getConstructor(paramTypes2);
    	       Object[] params2 = {"ParamOne",2};
    	       Student thisIsTestClass2 = con2.newInstance(params2);
    	       System.out.println("-------------------------------------");
    	    }catch(ClassNotFoundException e){
    	        e.printStackTrace();
    	    }catch (NoSuchMethodException e){
    	        e.printStackTrace();
    	    }catch (SecurityException e){
    	        e.printStackTrace();
    	    }catch (InstantiationException e){
    	        e.printStackTrace();
    	    }catch (IllegalAccessException e){
    	        e.printStackTrace();
    	    }catch (IllegalArgumentException e){
    	        e.printStackTrace();
    	    }catch (InvocationTargetException e){
    	        e.printStackTrace();
    	    }
    	  }
    }
    
    

    运行结果:

    无参构造
    -------------------------------------
    无参构造
    -------------------------------------
    一参构造
    -------------------------------------
    双参构造
    -------------------------------------
    

    4、序列化

    ①、序列化是干什么的?
    简单说就是为了保存在内存中的各种对象的状态(也就是实例变量,不是方法),并且可以把保存的对象状态再读出来。虽然你可以用你自 己的各种各样的方法来保存object states,但是Java给你提供一种应该比你自己好的保存对象状态的机制,那就是序列化。

    ②、什么情况下需要序列化
    a)当你想把的内存中的对象状态保存到一个文件中或者数据库中时候;
    b)当你想用套接字在网络上传送对象的时候;
    c)当你想通过RMI传输对象的时候;

    ③、相关注意事项
    a)序列化时,只对对象的状态进行保存,而不管对象的方法;
    b)当一个父类实现序列化,子类自动实现序列化,不需要显式实现Serializable接口;
    c)当一个对象的实例变量引用其他对象,序列化该对象时也把引用对象进行序列化;
    d)并非所有的对象都可以序列化,,至于为什么不可以,有很多原因了,比如:
    Ⅰ.安全方面的原因,比如一个对象拥有private,public等field,对于一个要传输的对象,比如写到文件,或者进行rmi传输 等等,在序列化进行传输的过程中,这个对象的private等域是不受保护的。
    Ⅱ. 资源分配方面的原因,比如socket,thread类,如果可以序列化,进行传输或者保存,也无法对他们进行重新的资源分 配,而且,也是没有必要这样实现。

    import java.io.*;
    
    /**
     * @ClassName TestDemo7
     * @Description 对象序列化
     * @Author lzq
     * @Date 2018/12/11 11:36
     * @Version 1.0
     **/
    
    class Student implements Serializable {
        private static final long serialVersionUID = -88175599799432325L;
        private String name;
        private int age;
        public Student(String name, int age) {
            this.name = name;
            this.age = age;
        }
        public String toString() {
            return "name=" + name + ", age=" + age;
        }
    }
    
    public class TestDemo7 {
        public static void main(String[] args) {
            String filename = "F:/FHB/serialize.txt";
            serialize(filename);
            reverse_serialize(filename);
        }
    
        /**
         * 序列化
         */
        public static void serialize(String filename) {
            try {
                OutputStream fos = new FileOutputStream(filename);
                ObjectOutputStream oos = new ObjectOutputStream(fos);
                oos.writeInt(12345);
                oos.writeObject("Today");
                oos.writeObject(new Student("lzq",20));
                oos.close();
                fos.close();
            }catch (Exception e) {
                e.printStackTrace();
            }
        }
    
        /**
         * 反序列化
         */
        public static void reverse_serialize(String filename) {
            try {
                InputStream in = new FileInputStream(filename);
                ObjectInputStream obj = new ObjectInputStream(in);
                int i = obj.readInt();
                String str = (String)obj.readObject();
                Student student = (Student)obj.readObject();
                System.out.println(i);
                System.out.println(str);
                System.out.println(student);
                obj.close();
                in.close();
            }catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
    
    12345
    Today
    name=lzq, age=20
    

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

    单例模式

    二、Java中,类的实例化方法有四种途径:

    1)使用new关键字

    2)利用反射,调用Class对象的newInstance()方法

    3)调用clone()方法,对现有实例的拷贝

    4)利用反序列化,通过ObjectInputStream的readObject()方法反序列化类

    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.ObjectInputStream;
    import java.io.ObjectOutputStream;
    import java.io.Serializable;
    import java.lang.reflect.Constructor;
    import java.lang.reflect.InvocationTargetException;
    
    class ClassInstance implements Cloneable, Serializable {
    	private String str = "测试...";
    	public void fun(){
    		System.out.println(str);
    	}
    	
    	public ClassInstance(String str) {
    		 System.out.println("有参类的实例化");
    		 this.str += str;
    	}
    	
    	public ClassInstance() {
    		 System.out.println("无参类的实例化");
    	}
    	
    	public Object clone() {
    		 return this;
    	}
    }
    public class ClassInstanceTest{
    	public static void main(String[] args) throws ClassNotFoundException, InstantiationException,
    	IllegalAccessException, IOException,InvocationTargetException, NoSuchMethodException{
    		//第一种类的实例化方式
            ClassInstance ci01 = new ClassInstance("01"); 
            ci01.fun();
    
            //第二种类的实例化方式
            ClassInstance ci02 = (ClassInstance) Class.forName("com.xagy.lianxi.ClassInstance").newInstance();
            ci02.fun();
    
           //第三种类的实例化方式
           ClassInstance ci03 = (ClassInstance) ci01.clone();
           ci03.fun();
    
           //第四种类的实例化方式
           FileOutputStream fos = new FileOutputStream("D:\\ci.txt");
           ObjectOutputStream oos = new ObjectOutputStream(fos);
           oos.writeObject(ci01);
           oos.close();
           fos.close();
           FileInputStream fis = new FileInputStream("D:\\ci.txt");
           ObjectInputStream ois = new ObjectInputStream(fis);
           ClassInstance ci04  = (ClassInstance) ois.readObject();
           ois.close();
           fis.close();
           ci04.fun();
           
           System.out.println("--------------------额外测试--------------------");
           ClassInstance ci05 = null;
           //额外的思考 在第二种类实例化的方式中有没有一种方法实现有参数的构造方式
           //获得类的构造信息
           Constructor[] ctor = Class.forName("com.xagy.lianxi.ClassInstance").getDeclaredConstructors();
           //找到我们需要的构造方法
           for(int i=0;i<ctor.length;i++ ){
               Class[] cl = ctor[i].getParameterTypes();
               if(cl.length == 1){
                  //实例化对象
                   ci05 = (ClassInstance) Class.forName("com.xagy.lianxi.ClassInstance").getConstructor(cl).newInstance(new Object[]{"05"});
               }
           }
           ci05.fun();
          }
    }
    
    
    有参类的实例化
    测试...01
    无参类的实例化
    测试...
    测试...01
    测试...01
    --------------------额外测试--------------------
    有参类的实例化
    测试...05
    
    
    展开全文
  • java 泛型实例化创建对象

    千次阅读 2020-06-01 17:43:35
    //定义泛型抽象类 public abstract class TObjectFactory { protected abstract T getTable(); } //继承使用 public class ...//创建实例 //p_table_log.getTable();//使用; return p_table_log; } { ITableDataBase
    //定义泛型抽象类
    public abstract class TObjectFactory<T> {
    
        protected abstract T getTable();
        
    }
    
    //继承使用
    public class TableFactory<Table,Value> extends TObjectFactory<Table>{
    
        ITableDataBase<Value> p_table_t;
        
        public TableFactory(ITableDataBase<Value> p_table_t) {
            //构造传Table类型实例
            this.p_table_t = (ITableDataBase<Value>) p_table_t;
        }
    
        @Override
        protected Table getTable() {
            // 类型转换
            return (Table) p_table_t;
        }
    
    }
    
    public class Field{}
    
    public abstract class ITableDataBase<T> {}
    
    public class TableLog extends ITableDataBase<Field>{}
    
        //定义
        private TableFactory<TableLog, Field> p_table_log;
        // 获取表类对象
        TableFactory<TableLog, Field> tableLog() {
            ITableDataBase<Field> p_table_t = new TableLog();
            p_table_log=new TableFactory<TableLog, Field>(p_table_t);//创建实例
            //p_table_log.getTable();//使用;
    
            return p_table_log;
        }

    展开全文
  • 为什么要创建对象实例化)?

    千次阅读 多人点赞 2020-06-04 19:55:49
    一、为什么要实例化对象? 对象:属性+方法 类是指:描述一种事物的定义,是个抽象的概念 实例指:该种事物的一个具体的个体,是具体的东西 联系 类是现实世界思维世界中的实体在计算机中的反映,它将数据以及...
  • 各位同学好,本章节和大家分享一下面向对象编程的一些方法,通过一些案例带大家由浅入深掌握面向对象的编程。...item1 = Item() # 创建Item类的实例化对象item1 #(3)给实例化对象分配属性 item1.n..
  • 声明对象和实例化对象的区别

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

    千次阅读 2021-02-06 23:15:33
    ——意思是类是抽象的,需要通过创建对象(实例化对象)来使用类的功能 2、实例化对象的两个步骤 ①使用new操作符为对象的各个实例变量分配内存并赋初始值 ②使用构造方法对对象的各个实例变量赋值,并返回一个引用...
  • 实例化泛型对象 在你发布的代码中,不可能创建一个泛型T,因为你不知道它是什么类型: public class Abc<T> { public T getInstanceOfT() { // There is no way to create an instance of T here // since...
  • Java对象实例化以及实例化方式

    千次阅读 2022-05-07 14:38:35
    1.什么是对象实例化 在写代码时,我们用关键词class定义一个类其实只是定义了一个类的模板,没有在内存中实际产生一个类的实例对象,也没有分配内存空间。要想在内存中产生一个类的实例对象就需要使用new关键字申请...
  • 接口可以创建对象实例化吗?

    千次阅读 2021-01-05 17:31:27
    文章目录一、interface的基础知识1. 接口使用interface来定义2.... 接口中不可以定义构造器 意味着接口不能实例化5. Java开发中,接口通过让类去实现implement的方式去使用6. java类可以实现多个接
  • 什么是实例化对象? 分析问题: 在面向对象程序设计中,"类"在实例化之后叫做一个"实例"(Person person = new Person())。 "类"是静态的,不占进程内存,而"实例"拥有动态内存。 实例(instance)和对象(object)...
  • 在学习Java反射的过程中,遇到了一点疑惑的地方 //1.... 利用Class对象的newInstance方法创建一个类的实例 Object obj = clazz.newInstance(); 平常理解的对象实例都是一个东西,将一个对象实...
  • Java中实例化对象是什么意思

    千次阅读 多人点赞 2021-02-22 20:45:53
    在Java语言中使用new关键字创建/构造对象的过程叫做类的实例化,该过程的本质,会在内存空间的堆区申请一块存储区域,用于记录该对象独有的成员变量信息。 通俗点就是,实例化:使用关键字new来创建对象。 例如: ...
  • 那么怎么完成实例化呢。我们创建一个对象需要对它初始化数据。能够有这一作用的是什么呢?——构造函数。所以就有了 Car mycar= new Car(); 当我们自己定义了与类同名的有参构造函数时,假设参数类型是整型的,...
  • 对C#中用new关键字实例化对象的理解

    千次阅读 2019-12-27 16:27:50
    【前置知识】 对值类型和引用类型的理解 公共语言运行时CLR ...实例化是从类创建对象的过程。 举例而言:类可以看做是图纸,我们根据这个图纸做出来一个东西(即对象),做出来的东西就是图...
  • 普通类实现字符串创建实例: var type =Assembly.Load("SqlSugar").GetType("SqlSugar.SqlServerDb"); IDb IDb=(IDb)Activator.CreateInstance(type, true); 泛型类就比较坑了,花了我一些时间,下面是泛型类的使用...
  • 在python中,可以通过class关键字定义类,然后通过定义的类来创建实例对象。语法格式如下: calss 类名: 类体 注意事项 在python中使用class关键字来定义类,定义类时需要注意以下几个事项: (1)类代码块以...
  • 【vue】创建实例&数据对象方法

    千次阅读 2021-01-13 20:14:33
    Vue 的核心库只关注视图层,不仅易于上手,还便于与第三方库既有项目整合。另一方面,当与现代的工具链以及各种支持类库结合使用时,Vue 也完全能够为复杂的单页应用提供驱动,比较适用于已了解关于 HTML、CSS ...
  • 学Java· 从new说对象实例化

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

    千次阅读 2019-04-16 17:02:47
    私有的构造方法如何创建对象 在java中,对象创建都是由构造方法实现的,如果将构造方法私有,根据private的用法,就只能在类的内部创建类的对象。外部又怎么得到这个对象呢,是否可以提供一个public方法返回在...
  • java反射实例化对象

    万次阅读 2018-06-08 13:43:41
    可通过Class类提供的方法为一个类实例化对象,区别与new关键字创建对象,前者是在类已经编译好的情况下,通过指定类名来创建实例化对象,后者是在编译之后之间创建实例化对象。也可通过Class类在运行时获得某个类...
  • 对象实例化

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

    万次阅读 多人点赞 2017-05-18 14:17:45
    在Java中,一个对象在可以被使用之前必须要被正确地初始化,这一点是Java规范规定的。...本文试图对JVM执行类初始化和实例化的过程做一个详细深入地介绍,以便从Java虚拟机的角度清晰解剖一个Java对象创建过程。
  • C++的三种实例化对象方式

    万次阅读 多人点赞 2019-05-04 19:15:43
    一、隐式创建 class CEmployee { private: int age; int id; public: CEmployee() { cout << "这是构造函数" << endl; } CEmployee(int id) { this->id = id; } ~CEmployee() { cout << "这...
  • 反射:对对象的反向处理,通过对象获取对象的来源信息(即可以知道这个对象是通过什么类型实例化出来的)。 通过对象获取创建对象的类型信息。 对类型(类)的一个抽象,就是JDK中的Class类; Class也是一个类,用来...
  • Java中创建实例化对象的五种方式 1、用new语句创建对象,这是最常见的创建对象的方法。 2、通过工厂方法返回对象,如:String str = String.valueOf(23);  3、运用反射手段,调用java.lang.Class或者java.lang....
  • java创建对象实例的四种方式

    万次阅读 2018-05-21 21:26:05
    java创建对象的方法常用的有四种:使用new关键字、利用java的放射机制、实现Cloneable接口使用克隆方法以及利用java序列和反序列实现创建对象。不说那么多,直接上代码。本次主要讲前三中创建方式,只是大致讲解...
  • 接口--实例化接口对象的三种方式

    千次阅读 2019-12-26 17:45:12
    当我们创建了一个接口的时候,我们是无法像创建对象一样,直接实例化接口对象的。所以在这里,我来分享三种方式来实例化接口对象。 //这里会提示'Student' is abstract; cannot be instantiated,也就是说接口是...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,458,574
精华内容 583,429
热门标签
关键字:

创建或实例化对象