精华内容
下载资源
问答
  • Java实例化对象几种方式

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

    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()方法。

    package org.whb.test.demo724;
    /*
     *测试Cloneable接口的使用
     *包含第一种和第三种方法clone()
     *不过要注意在clone()中深复制和潜复制的理解
     *实例化对象 
     */
    class Person implements Cloneable{
        private String name;
        private int age;
     
      public Person( String name,int age) {
        this.name = name; 
        this.age = age;
      }
     
      public int getAge() {
       return age;
      }
      
      public void setAge(int age) {
       this.age = age;
      }
     
     public String getName() {
      return name;
     }
     
     public void setName(String name){
          this.name =name;
        }
     
    @Override
     public Object clone() throws CloneNotSupportedException {
      // TODO Auto-generated method stub
      return super.clone();
     }
      @Override
     public String toString() {
      // TODO Auto-generated method stub
      return "姓名是:"+name+"; 年龄是:"+age;
     }
       
    }
    public class TestClone{
     public static void main(String[] args){
       Person p1 = new Person("王豪博",25);
       System.out.println(p1);
       Person p2 =null;
       try {
         p2 = (Person)p1.clone();
       } catch (CloneNotSupportedException e) {
        // TODO Auto-generated catch block
         e.printStackTrace();
       }
       p2.setName("春香");
       p2.setAge(24);
       System.out.println(p2);
      }
    }
    /*
     *通过反射对对象进行初始化
     *注意必须有无参数的Constructor
     *实例化Class类然后调用newInstance()方法
     *
     */
    package org.whb.test.demo715;
    class Person{
     private int age;
     private String name;
     public int getAge() {
      return age;
     }
     public void setAge(int age) {
      this.age = age;
     }
     public String getName() {
      return name;
     }
     public void setName(String name) {
      this.name = name;
     }
     public String toString(){
      return "年龄是:"+this.age+"  姓名是:"+this.name;
      
     } 
     
    }
    public class TestClass {
      public static void main(String[] args){
       Class< ?> c1 = null;
       try{
            c1 = Class.forName("org.whb.test.demo715.Person");
       }catch(ClassNotFoundException e){
        e.printStackTrace();
       }   
       Person p1 = null;
       try {
       p1 =(Person)c1.newInstance();
     } catch (InstantiationException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
     } catch (IllegalAccessException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
     }
     
     
       p1.setAge(12);
       p1.setName("haobo");
       System.out.println(p1);
      }
    }
    

    ---------------------------------------------------------

    package org.whb.test.demo724;

    import java.io.*; 
    import java.util.Date;

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

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

    public class ObjectSaver { 
    public static void main(String[] args) throws Exception { 
     ObjectOutputStream out = new ObjectOutputStream (new FileOutputStream("D:/objectFile.swf")); 
     //序列化对象 
     Customer customer = new Customer("haobo", 24); 
     out.writeObject("你好!"); 
     out.writeObject(new Date()); 
     out.writeObject(customer); 
     out.writeInt(123); //写入基本类型数据 
     out.close(); 
     //反序列化对象 
     ObjectInputStream in = new ObjectInputStream(new FileInputStream("D:/objectFile.swf")); 
     System.out.println("obj1=" + (String) in.readObject()); 
     System.out.println("obj2=" + (Date) in.readObject()); 
     Customer obj3 = (Customer) in.readObject(); 
     System.out.println("obj3=" + obj3); 
     int obj4 = in.readInt(); 
     System.out.println("obj4=" + obj4); 
     in.close(); 
     } 
    } 
    class Customer implements Serializable { 
     /** 
     * 
     */ 
     private static final long serialVersionUID = -88175599799432325L; 
     private String name; 
     private int age; 
     public Customer(String name, int age) { 
      this.name = name; 
      this.age = age; 
     } 
      public String toString() { 
       return "name=" + name + ", age=" + age; 
      } 
     } 
    /*
     * obj1=你好!
    obj2=Sat Jul 24 21:18:19 CST 2010
    obj3=name=haobo, age=24
    obj4=123
     */


                                                                                                                        

    0
    展开全文
  • [超级通道 : Java反射学习系列-绪论...获取Class对象方式有三种。 公有属性class 方法getClass() Class.forName() 下面是示例代码: /** * &lt;p&gt;Title: Java获取Class对象的三种方式&lt;/...

    [超级通道 : Java反射学习系列-绪论]

    1.Class对象获取的三种方式

    上一章节已经说过,一般情况下,Java反射操作都需要首先获取Class对象。获取Class对象的方式有三种。

    1. 公有属性class
    2. 方法getClass()
    3. Class.forName()

    下面是示例代码:

    /**
     * <p>Title: Java获取Class对象的三种方式</p>
     * @author 韩超 2018/2/24 13:56
     */
    public class ReflectClassDemo {
        /** log4j */
        private static final Logger LOGGER = Logger.getLogger(ReflectClassDemo.class);
        /**
        * <p>获取Class对象的三种方式</p>
        * @author hanchao
        */
        public static void main(String[] args) throws ClassNotFoundException {
            LOGGER.info("获取Class对象方式01:类的public属性class");
            Class clazz1 = User.class;
            LOGGER.info(clazz1);
    
            System.out.println();
            LOGGER.info("获取Class对象方式02:类的public方法getClass()");
            User user = new User();
            Class clazz2 = user.getClass();
            LOGGER.info(clazz2);
    
            System.out.println();
            LOGGER.info("获取Class对象方法03:Class.forName(需要抛出异常)");
            Class clazz3 = Class.forName("pers.hanchao.reflect.common.User");
            LOGGER.info(clazz3);
        }
    }

    运行结果:

    2018-02-24 13:59:06 INFO  ReflectClassDemo:18 - 获取Class对象方式01:类的public属性class
    2018-02-24 13:59:06 INFO  ReflectClassDemo:20 - class pers.hanchao.reflect.common.User
    
    2018-02-24 13:59:06 INFO  ReflectClassDemo:23 - 获取Class对象方式02:类的public方法getClass()
    2018-02-24 13:59:06 INFO  ReflectClassDemo:26 - class pers.hanchao.reflect.common.User
    
    2018-02-24 13:59:06 INFO  ReflectClassDemo:29 - 获取Class对象方法03:Class.forName(需要抛出异常)
    2018-02-24 13:59:06 INFO  ReflectClassDemo:31 - class pers.hanchao.reflect.common.User

    总结:

    1. 通过公有属性class获取Class对象:通过类获取,无需创建类对象。
    2. 通过方法getClass()获取Class对象:需要类的对象。常用于不知道类名但是能获取对象的情况下。
    3. 通过方法Class.forName()获取Class对象:需要类的全名,需抛出异常。常用于加载配置。

    2.通过反射实例化对象的两种方式

    除了通过new实例化对象,我们还可以通过反射实例化对象对象,有两种方式:

    1. Class.newInstance()
    2. Constructor.newInstance()

    下面是示例代码:

    /**
     * 通过反射创建对象的两种方式
     * Created by 韩超 on 2018/2/24.
     */
    public class CreateObjectDemo {
        private final static Logger LOGGER = Logger.getLogger(CreateObjectDemo.class);
    
        /**
         * <p>Title: 通过反射创建对象的两种方式</p>
         * @author 韩超 2018/2/24 14:11
         */
        public static void main(String[] args) throws Exception {
            //通过new实例化对象
            User user = new User();
            LOGGER.info("通过new实例化对象:" + user.toString());
    
            //通过反射实例化对象
            Class userClass = User.class;
            //通过反射实例化对象01-Class.newInstance()(需要强制类型转换[无参构造])
            User user1 = (User) userClass.newInstance();
            LOGGER.info("通过反射实例化对象01-Class.newInstance()(需要强制类型转换[无参构造]):" + user1.toString());
            //通过反射实例化对象02-Constructor.newInstance()(需要强制类型转换[可带参数])
            Constructor constructor = userClass.getDeclaredConstructor();
            User user2 = (User) constructor.newInstance();
            LOGGER.info("通过反射实例化对象02-Constructor.newInstance()(需要强制类型转换[无参构造]):" + user2.toString());
            Constructor constructor1 = userClass.getDeclaredConstructor(String.class,String.class);
            User user3 = (User) constructor1.newInstance("李四","000000");
            LOGGER.info("通过反射实例化对象02-Constructor.newInstance()(需要强制类型转换[有参构造]):" + user3.toString());
        }
    }

    运行结果:

    2018-02-24 14:23:29 INFO  CreateObjectDemo:22 - 通过new实例化对象:User{username='张三', password='123456'}
    2018-02-24 14:23:29 INFO  CreateObjectDemo:27 - 通过反射实例化对象01-Class.newInstance()(需要强制类型转换[无参构造]):User{username='张三', password='123456'}
    2018-02-24 14:23:29 INFO  CreateObjectDemo:31 - 通过反射实例化对象02-Constructor.newInstance()(需要强制类型转换[无参构造]):User{username='张三', password='123456'}
    2018-02-24 14:23:29 INFO  CreateObjectDemo:34 - 通过反射实例化对象02-Constructor.newInstance()(需要强制类型转换[有参构造]):User{username='李四', password='000000'}

    总结:

    1. 通过Class.newInstance()进行对象实例化:实际调用的是无参数的构造函数进行实例化。
    2. 通过Constructor.newInstance()进行对象实例化:可以选择调用哪个构造函数进行实例化。
    展开全文
  • 创建(实例化对象的五种方式

    万次阅读 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
    
    
    展开全文
  • Spring实例化Bean对象的三种方式

    千次阅读 2019-09-18 20:36:26
    Spring实例化Bean对象的三种方式 一、Instantiation with a constructor (使用构造函数实例化) 二、Instantiation with a static factory method (使用静态工厂方法实例化) 三、Instantiation using an instance ...
    Spring实例化Bean对象的三种方式
    一、Instantiation with a constructor (使用构造函数实例化)
    二、Instantiation with a static factory method (使用静态工厂方法实例化)
    三、Instantiation using an instance factory method (使用实例工厂方法实例化)
    
    • 下面通过代码来讲解三种方式的实现:
    1、构造函数实例化
    当您使用构造函数方法创建bean时,所有普通类都是可用的。也就是说,正在开发的类不需要实现任何特定的接口。是最常见也是最简单的一种实例化bean的方式。
    需要的准备工作:
    	创建一个动态web项目-->创建配置文件-->创建测试类-->创建service接口以及实现类;
    	导入jar包: 4+1 beans、context、core、expression  依赖包commmons-logging;
    

    applicationContext.xml

    	<!-- class中为实现类的全路径 id即在测试类中通过getBean(id)获取 -->
    	<bean id="userService" class="com.hym.service.impl.UserService"></bean>
    

    UserService

    public class UserService implements IUserService{
    
    	@Override
    	public void show() {
    		//方法自己定义,目前只需要测试能否成功拿到bean对象即可
    		System.out.println("Construct Func...");
    	}
    
    }
    

    测试类:

    public class InstanceBeanTest {
    	
    	@Test
    	public void constructBean(){
    		//加载Spring的主配置文件--要导包
    		ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    		//方式一、通过id拿到配置文件中的bean对象--类型为IUserService
    		IUserService userService = (IUserService) context.getBean("userService");
    		//方式二、通过传入接口的反射对象从而在配置文件中获取到相同类型的对象.
    		//【注意通过类型得到对象时,不能存在两个class指向路径一样的bean对象,否则会报错】
    		IUserService userService2 = context.getBean(IUserService.class);
    		//得到对象就可以调用其中的方法
    		userService.show();
    	}
    
    }
    
    2、静态工厂方法实例化
    用于生成实例对象,所有的方法必须是static。定义使用静态工厂方法创建的bean时,使用class属性指定包含要指定的静态工厂方法和名为
    factory-method的属性的类工厂方法本身的名称。
    相对第一种实现方式,多了工厂类;
    

    applicationContext.xml

    	<!-- id依旧自己命名,class中的值为静态工厂类的全路径 需要多写返回对象的静态方法,并且值要与方法名一致 -->
    	<bean id="userStaticService" class="com.hym.factory.StaticFactory" factory-method="getInstance"></bean>
    

    StaticFactory静态工厂类

    public class StaticFactory {
    	//通过静态工厂的方式来实例化对象
    	private static IUserService userService = new UserService();
    
    	public static IUserService getInstance() {
    		return userService;
    	}
    
    }
    

    测试类:

    	@Test
    	public void staticFactoryBean(){
    		//加载Spring的主配置文件--要导包
    		ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    		//方式一、通过id拿到配置文件中的bean对象--类型为IUserService
    		IUserService userService = (IUserService) context.getBean("userStaticService");
    		//方式二、通过传入接口的反射对象从而在配置文件中获取到相同类型的对象.
    		IUserService userService2 = context.getBean(IUserService.class);
    		//得到对象就可以调用其中的方法
    		userService2.show();
    	}
    
    3、实例工厂方法实例化
    必须先有工厂实例对象,通过实例对象创建对象。提供所有的方法都是“非静态”的。与通过静态工厂方法实例化类似,使用实例工厂方法实例化从容器中调用
    现有bean的非静态方法来创建新bean。使用这个机制,保留class属性为空,在factory-bean属性中指定a的名称包含要调用的实例方法的当前(或父/父)
    容器中的bean创建对象。
    

    applicationContext.xml

    	<bean id="userInstanceService" class="com.hym.factory.InstanceFactory"></bean>
    	<!-- 因为不是静态的返回对象,所以要先获取到工厂对象,然后再通过工厂对象使用非静态成员方法,得到userService对象 -->
    	<!-- 这里的factory-bean中的值为前面写的指向实例工厂类bean的id -->
    	<bean id="userService" factory-bean="userInstanceService" factory-method="getInstance"></bean>
    

    实例工厂类

    public class InstanceFactory {
    	
    	private IUserService userService = new UserService();
    	
    	public IUserService getInstance(){
    		return userService;
    	}
    
    }
    

    测试类

    	@Test
    	public void instanceFactoryBean(){
    		//加载Spring的主配置文件--要导包
    		ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    		//方式一、通过id拿到配置文件中的bean对象--类型为IUserService
    		IUserService userService = (IUserService) context.getBean("userService");
    		//方式二、通过传入接口的反射对象从而在配置文件中获取到相同类型的对象.
    		IUserService userService2 = context.getBean(IUserService.class);
    		//得到对象就可以调用其中的方法
    		userService.show();
    	}
    
    展开全文
  • java实例化对象的五种方式

    千次阅读 2017-10-07 15:11:48
    1、用new语句创建对象,这是最常见的创建对象的方法。 Student student = new Student(); 2、通过工厂方法返回对象,如:String str = String.valueOf(23); public interface Factory{ Product createProduct...
  • Spring 实例化方式有几种?为什么会用到 Cglib?

    千次阅读 多人点赞 2021-05-31 08:35:04
    在上一章节我们扩充了 Bean 容器的功能,把实例化对象交给容器来统一处理,但在我们实例化对象的代码里并没有考虑对象类是否含构造函数,也就是说如果我们去实例化一个含有构造函数的对象那么就要抛异常了。...
  • 实例化接口的几种方式

    千次阅读 2019-07-14 16:15:53
    1.接口自身无法被实例化,只能通过它的实现类来实现。 2.采用interface关键字来声明一个接口。 3.接口里面的抽象方法可以直接使用 返回值 方法名(参数);来定义。会自动加上public abstract 修饰符。 4.接口里面...
  • java对象实例化几种方法

    万次阅读 2016-12-23 16:23:56
    Java 对象实例化几种方法
  • Java实例化几种方式

    千次阅读 2017-04-21 09:32:23
    Java创建种方式:(1)用new 语句创建对象,这是最常用的创建对象方法。(2)运用反射手段,调用java.lang.Class或者java.lang.reflect.Constructor类的newInstance()实例方法。(3)调用对象的clone()方法(4)...
  • Java中创建(实例化对象的五种方式 1、用new语句创建对象,这是最常见的创建对象的方法。 2、通过工厂方法返回对象,如:String str = String.valueOf(23);  3、运用反射手段,调用java.lang.Class或者java.lang....
  • js对象实例化的常见三种方式

    万次阅读 2015-08-08 19:08:57
    三种常见模式:工厂模式,构造函数模式,原型模式 Object ...创建对象常见的三种方式 window.onload=function(){ //工厂模式 function oj(){ var lio=new Object(); lio.name='lio';
  • 实例化对象的三方法

    万次阅读 2019-05-18 23:59:29
    1.任何类的实例化对象可以通过Object类中的getClass()方法取得Class类对象 public class Test { public static void main(String[] args) { Date date=new Date(); Class aClass = date.getClass(); System.....
  • 在学习Bean实例化前,先让我们来看下IoC容器到底是如何工作。 在此我们以xml配置方式来分析一下: 一、准备配置文件:就像前边Hello World配置文件一样,在配置文件中声明Bean定义也就是为Bean配置元数据。 二、...
  • C++的三种实例化对象方式

    万次阅读 多人点赞 2019-05-04 19:15:43
    这种创建方式和第一一样,在进程虚拟地址空间中的栈中分配内存,它的分配和释放由系统决定,函数内局部变量的存储单元可以在栈上创建,函数执行完毕,系统会自动释放这些存储单元。 三、显示new创建 int ...
  • Java实例化类的几种方法

    千次阅读 2018-01-12 14:45:40
    这里写的是类的实例化的三种方式 1. 用new 关键字直接实例化一个对象 ExampleClass example = new ExampleClass ();2.用Java内部的反射机制 Object example = Class.forName("完整的类路径").newInstance();
  • Java中类实例化几种方式

    千次阅读 2012-02-21 14:04:34
    实例化一个类一共途径: 1. 使用new操作符 2. 调用Class或java.lang.reflect.Constructor对象的newInstance()方法 3. 调用任何对象的clone()方法 4. 通过java.io.ObjectInputStream类的getObject() ...
  • Spring三种实例化方式

    千次阅读 2018-08-21 23:15:44
    Spring容器支持两种格式的配置文件.properties .xml这...实例化Bean种方式,分别为构造器实例化、静态工厂方式实例化和实例工厂方式实例化(其中最常用的是构造器实例化) 1.构造器实例化 public class Insta...
  • Spring实例化bean的四种方式

    千次阅读 2019-05-04 15:44:18
    Spring实例化bean的三种方式: 无参构造方法实例化(Spring默认,常用,需要bean类中存在无参构造方法); 静态工厂实例化 实例化工厂实例化 注解方式实例化 1. 使用无参构造方法实例化 要求 bean所属类中...
  • 与new运算符一起使用来实例化对象。 举例: function Person(){} //Person构造函数 var p=new Person(); //Person构造函数创建对象,也可叫做实例化 二、什么是原型? 原型:构造函数在实例化对象的过程中,系统...
  • Java创建对象几种方式

    千次阅读 2018-07-22 22:15:57
    其实创建对象的方式有很多中,在此,准备将实例化对象的方式进行总结,归纳整理。 在此之前,先简单的说明一般会有以下五种方式实例化对象: ①、使用new关键字; ②、使用Class类的newInstance方法; ③、使用...
  • 其实对于初级java程序员来说,一说到类的对象实例总是会混淆。Class是java中api中的类名。class是一个关键字。Class是反射技术的核心。...那么通常我们创建对象方式有几种呢? 五种: 1.通过new 语句创建对象
  • js创建自定义对象几种方式

    千次阅读 2017-08-27 17:26:26
    js创建对象几种方式
  • 深入理解Java对象的创建过程:类的初始化与实例化

    万次阅读 多人点赞 2017-05-18 14:17:45
    实例化一个对象时,JVM首先会检查相关类型是否已经加载并初始化,如果没有,则JVM立即进行加载并调用类构造器完成类的初始化。在类初始化过程中或初始化完毕后,根据具体情况才会去对类进行实例化。本文试图对JVM...
  • Bean实例化的三种方式

    万次阅读 2018-01-22 15:36:58
    bean 实例化的三种方式实现: 第一种:使用类的无参数构造创建(第一种是重点,第二三种已经没太多人用了) 目录树: 1.首先定义一个 bean: bean1.java: package com.spring.demo; public class Bean1 { ...
  • Spring-- Ioc 容器Bean实例化几种场景

    千次阅读 2014-11-23 20:32:43
    Bean实例化几种场景   1、BeanDefinitionRegistryPostProcessor:标准BeanFactoryPostProcessor的扩展,BeanFactoryPostProcessor的作用是用来进一步定义注册的BeanDefinition,IoC 容器本质就是Bean管理,...
  • Java 创建对象几种方式

    万次阅读 2017-02-22 17:09:52
    我们总是讨论没有对象就去new一个对象,创建对象的方式在我这里...这里就总结一下创建对象几种方式,来好好学习一下java创建对象的方式。一、使用new关键字这是我们最常见的也是最简单的创建对象的方式,通过这种方式
  • Spring 中Bean的实例化种方式

    千次阅读 2018-09-21 23:14:35
    这三种实例化方式分别为构造器实例化,静态工厂实例化,实例工厂实例化,其中最最最最最重要的也是最常见的实例化方式是构造器实例化!   构造器实例化 构造器实例化是指spring容器通过Bean对应的类中的默认的无...
  • Spring中四种实例化bean的方式

    千次阅读 2020-07-28 17:27:57
    在Spring IoC容器中根据Bean定义创建Bean主要以下几种方式: 第一种:使用构造器实例化Bean:这是最简单的方式,Spring IoC容器即能使用默认空构造器也能使用参数构造器两种方式创建Bean,如以下方式指定要创建...
  • 实例化Class类的5种方式

    千次阅读 2017-02-21 11:02:08
    对于每类型的对象,Java虚拟机会实例化不可变的java.lang. Class对象。它提供了在运行时检查对象属性的方法,这些属性包括它的成员和类型信息。更重要的是Class对象是所有反射API的入口。本实例演示如何获得Class...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 594,251
精华内容 237,700
关键字:

实例化对象有几种方式