精华内容
下载资源
问答
  • 创建实例化对象的五种方式

    万次阅读 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
    
    
    展开全文
  • 第一个vue案例 创建vue实例化对象

    千次阅读 2019-03-14 10:25:54
    Vue的使用 1、先导入vue.js ... 2、创建vue实例化对象 &lt;!DOCTYPE html&gt; &lt;html lang="en"&gt; &lt;head&gt; &lt;meta charset="UTF-8"&gt;

    Vue的使用

        1、先导入vue.js
            <script src="vue.js"></script>
        2、创建vue实例化对象
     

    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Title</title>
    </head>
    <body>
    <div id="app">
        <h3>{{title}}</h3>
    </div>
    <script src="vue.js"></script>
    <script>
        //实例化vue对象
        //参数
        var app = new Vue({
            el: "#app",//绑定元素
            //所有数据都放在数据属性中
             data:{
                title:"土豆"//类似于模板语言
             }
        })
    </script>
    </body>
    </html>

    展开全文
  • 定义类 声明对象 创建对象 实例化对象 属性 对象调用属性或者方法 举例,下面定义类了一个类并声明属性,写了一个方法: class Person { public String name; //声明属性 public int age; //声明属性 ...

    定义类 声明对象  创建对象 实例化对象 属性 对象调用属性或者方法

    举例,下面定义了一个类并声明属性,写了一个方法:
    class Person 
    {
        public String name; //声明属性
        public int age;     //声明属性
        
        //返回值 方法名(数据类型1 参数1,...)
        void talk(String name,int age)   
        {
            System.out.println("我是:"+name+",今年"+age+"岁")
        }
    }
    


    创建对象 实例化对象 属性 类调用属性或者方法
    public static void main(String[] args)
    {
        Person p;   //创建对象
        p = new Person   //实例化对象
    
    //也可以用下面这种方式,新建对象并实例化
    //    Person p = new Person
    
     //对象.属性 = "内容"  这个对象的属性是...   。也好理解,首先要有对象,有了对象再谈属性
        p.name = "张三"; 
       
    //同上,没啥可说的了    
        p.age = 25;
        
    //对象.方法     对这个对象应用方法
        p.talk()
    }
    



    展开全文
  • 普通类实现字符串创建实例: var type =Assembly.Load("SqlSugar").GetType("SqlSugar.SqlServerDb"); IDb IDb=(IDb)Activator.CreateInstance(type, true); 泛型类就比较坑了,花了我一些时间,下面是泛型类的使用...

    普通类实现字符串创建实例:

    var type =Assembly.Load("SqlSugar").GetType("SqlSugar.SqlServerDb");
    IDb IDb=(IDb)Activator.CreateInstance(type, true);

    泛型类就比较坑了,花了我一些时间,下面是泛型类的使用方法:

     var type =Assembly.Load("SqlSugar").GetType("SqlSugar.SqlServerQueryable"+ "`1")
                    .MakeGenericType(typeof(Student));
    ISugarQueryable<Student> IDb= (ISugarQueryable<Student>)Activator.CreateInstance(type, true);

    注意:

    "SqlSugar.SqlServerQueryable"+ "1" 如果没有 "1" 那就不会执行成功。

    转载于:https://www.cnblogs.com/lfzm/p/9801367.html

    展开全文
  • Java中创建实例化对象的五种方式 1、用new语句创建对象,这是最常见的创建对象的方法。 2、通过工厂方法返回对象,如:String str = String.valueOf(23);  3、运用反射手段,调用java.lang.Class或者java.lang....
  • 深入理解Java对象创建过程:类的初始化与实例化

    万次阅读 多人点赞 2017-05-18 14:17:45
    在Java中,一个对象在可以被使用之前必须要被正确地初始化,这一点是Java规范规定的。...本文试图对JVM执行类初始化和实例化的过程做一个详细深入地介绍,以便从Java虚拟机的角度清晰解剖一个Java对象创建过程。
  • 实例化泛型对象 在你发布的代码中,不可能创建一个泛型T,因为你不知道它是什么类型: public class Abc<T> { public T getInstanceOfT() { // There is no way to create an instance of T here // since...
  • 问题:不同的客户端去请求Servlet,该Servlet是同一个实例化对象还是不同的实例化对象?(即,是每次请求Servlet都会实例化一个该Servlet对象,还是每次请求都使用的是同一个Servlet对象?) 难道Servlet是单例模式吗?...
  • 声明对象和实例化对象的区别

    千次阅读 2015-11-04 11:17:20
    声明对象和实例化对象的区别
  • java反射实例化对象

    千次阅读 2018-06-08 13:43:41
    可通过Class类提供的方法为一个类实例化对象,区别与new关键字创建对象,前者是在类已经编译好的情况下,通过指定类名来创建实例化对象,后者是在编译之后之间创建实例化对象。也可通过Class类在运行时获得某个类...
  • spring内部创建对象的方式(bean实例化方式) 方式一:采用默认构造函数创建对象(重点)     方式二:采用静态工厂的方式 首先提供一个工厂类 public class HelloWorldFactory { /** * 静态方法 * ...
  • 反射:对对象的反向处理,通过对象获取对象的来源信息(即可以知道这个对象是通过什么类型实例化出来的)。 通过对象获取创建对象的类型信息。 对类型(类)的一个抽象,就是JDK中的Class类; Class也是一个类,用来...
  • 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
  • C# 实例化对象

    千次阅读 2018-03-14 16:05:46
    实例化对象,其实就是创建对象过程;要用一个类中的一个方法。如果这个类是静态类,那么ok,可以直接调用这个方法。可是如果这个类不是静态类呢?就需要用对象来引用这个方法了。那么对象如何来呢?就需要new一下了...
  • 私有化构造方法如何实例化对象

    千次阅读 2019-04-16 17:02:47
    私有的构造方法如何创建对象 在java中,对象创建都是由构造方法实现的,如果将构造方法私有,根据private的用法,就只能在类的内部创建类的对象。外部又怎么得到这个对象呢,是否可以提供一个public方法返回在...
  • 写TS的时候,经常创建数组变量,并且声明了类型就直接去使用。 比如在一个Object里的一个属性是一个数组 ts: export class Car { tires: string[], length: number, height: number } let car = new ...
  • AssetBundle的创建 using UnityEngine; using UnityEditor; using System.IO; using System; public class BuildAssetBundlesFromDirectory { [@MenuItem("Asset/Build AssetBundles From Directory of Files...
  • 一、首先说一下什么是构造函数: 构造函数:用来在创建对象时初始化对象。...原型:构造函数在实例化对象的过程中,系统自动创建出来与其相关联的一个空的对象。可以由构造函数.prototype来访问到。 举例:在实例
  • 3.2、抽象一个类和实例化对象

    千次阅读 2018-03-28 19:20:36
    一、抽象一个类 二、实例化对象 1、实例化对象 2、对象类型在内存中分配情况 三、$this 四、构造函数和析构函数
  • 用spring管理和实例化对象的四种方式 方式一:无参构造函数(最常用) 对象是spring创建,创建的对象还要交给spring容器管理 bean:豆子 id:在spring容器中Hello对象的名,在容器中id的值必须唯一 class:要对哪个类实例化...
  • 对C#中用new关键字实例化对象的理解

    千次阅读 2019-12-27 16:27:50
    【前置知识】 对值类型和引用类型的理解 公共语言运行时CLR ...实例化是从类创建对象的过程。 举例而言:类可以看做是图纸,我们根据这个图纸做出来一个东西(即对象),做出来的东西就是图...
  • C++类的实例化对象

    千次阅读 2018-09-02 18:47:11
    C语言使用函数对内容进行封装的,而C++是用类进行封装的 ...类在创建实例化对象时,类本身并不被分配空间 类对象包括类里的成员变量 若计算类的大小,只需计算成员变量大小之和,但要注意内存对齐 空类大小为一个...
  • 这样便出现了 获取对象类型 并创建该类型对象实例 的需求。 问题解决方法: step1 : 根据对象获取对象类型 使用getQualifiedClassName方法,可以返回类型String step2:创建该类型对象
  • Java中实例化对象是什么意思

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

    千次阅读 2014-10-04 10:06:22
    /* * java 使用反射实例化一个类对象 * 第一种方式:创建类类对象,... * 第二种方式:使用类类对象的getConatructor方法构造Constructor类对象,然后用构造器类对象调用newIntance方法创建实例化的类F对象。 *
  • Java实例化对象的几种方式

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

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,281,177
精华内容 512,470
关键字:

创建或实例化对象