精华内容
下载资源
问答
  • 1、用new语句创建对象,这是最常见创建对象的方法...3、运用反射手段,调用java.lang.Class或者java.lang.reflect.Constructor类newInstance()实例方法。如:Object obj = Class.forName("java.lang.Object...
    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()方法。

    展开全文
  • WCF服务对象实例化基础 在普通WCF请求和相应过程中,将产生下列活动: WCF客户端向WCF服务端对象发起一个请求。 WCF服务端对象实例化 WCF服务实例响应请求并给客户端发送响应 针对上述场景,WCF提供了三种...

    很多情况下,我们都需要控制wcf服务端对象的初始化方式,用来控制wcf实例在服务端的存活时间。

    Wcf框架提供了三种创建wcf实例的方式。

    WCF服务对象实例化基础

    在普通的WCF请求和相应过程中,将产生下列活动:

    • WCF客户端向WCF服务端对象发起一个请求。
    • WCF服务端对象实例化
    • WCF服务实例响应请求并给客户端发送响应

     

    针对上述场景,WCF提供了三种便捷方式

    • 每次调用 —— 为每个WCF客户端请求创建一个新的WCF服务端实例
    • 每个会话 —— 为每个WCF客户端会话只创建一个WCF实例
    • 单个实例 —— 所有的WCF客户端都使用一个全局的WCF服务端实例

    每次调用模式

    当我们将WCF服务设置为每次调用模式时,在使用WCF代理客户端每次方法调用时都将产生新的服务端实例

    • WCF客户端第一次调用
    • 服务端为客户端的这个方法调用创建新的实例
    • WCF服务处理请求并向客户端发送应答,销毁服务实例,让gc来清理
    • 当客户端第二次调用了第二个方法时,创建了新的实例,处理请求,销毁实例

     

    如何实现WCF的每次调用实例化模式

    要指定实例化模式,我们需要在标签ServiceBehavior中提供InstanceContextMode的值。这个标签是放在Service类上的。如下列代码所示:

    [ServiceBehavior(InstanceContextMode=InstanceContextMode.Percall)]

    public class Service:IService

    {

        private int intCounter;

        public int Increment()

        {

            intCounter++;

            return intCounter;

        }

    }

    假定在客户端两次调用该方法

    ServiceReferrence1.ServiceClient obj=new ServiceReference1.ServiceClient();

    MessageBox.Show(obj.Increment().ToString());

    MessageBox.Show(obj.Increment().ToString());

    此时,尽管我们调用了两次Increment方法,但是得到的结果都是'1'。换句话说,WCF服务实例在每次方法调用时都被重新创建了,所以这个值始终为1。

    每次会话实例模式

    很多时候,我们都需要在多个方法调用时或者针对一个特定的会话来维护状态。对于这样的场景,我们就需要将服务配置为每个会话模式。在每个会话模式时,

    在一次会话的交互过程中将只创建一个WCF服务对象,过程如下:

    • 客户端创建WCF服务代理,进行方法调用
    • 创建一个服务实例来处理方法响应
    • 客户端在同一个会话中做一个或多个方法调用
    • 使用同一个服务实例来处理这些方法调用
    • 当客户端结束了它的活动时,销毁WCF实例,提供给gc来清理资源

    如何实现会话实例模式

    要将服务配置为每个会话模式,我们需要配置标签ServiceBehavior的InstanceContextMode对象的值设置为PerSession

    [ServiceBehavior(InstanceContextMode=InstanceContextMode.PerSession)]

    public class Service:IService

    {

        private int intCounter;

        public int Increment()

        {

            intCounter++;

            return intCounter;

        }

    }

    在客户端,当使用如下代码时,在客户端最后的代码执行时,将得到'2'

    ServiceReference1.ServiceClient obj=new ServiceReference1.ServiceClient();

    MessageBox.Show(obj.Increment().ToString());

    MessageBox.Show(obj.Increment().ToString());

     

    单例模式

    有时候我们也会创建一个全局WCF实例为所有的WCF客户端提供服务。要创建一个单例模式WCF服务,可采取如下方式:

    WCF客户端向服务端发起一个请求

    创建一个服务端实例来为请求服务。这个实例不会被销毁,而是持续为其他客户端请求服务

    假如这时候,某个其他的客户端如Client2,请求了同一个方法调用

    将使用这个唯一的服务实例(由Client1创建的)来为Client2提供服务。

     

    如何实现单例模式

    为实现单例模式,将InstanceContextMode设置为Single

    [ServiceBehavior(InstanceContextMode=InstanceContextMode.Single)]

    public class Service:IService

    {

    }

    当你从不同的客户端发起请求时,这个Counter计数同样会增加。该Counter技术成为了一个全局变量

     

    使用每次调用,每个会话,单例模式的选择依据

    每次调用

    无状态服务

    • 服务持有了大量资源时,如连接对象和大量的内存对象
    • 最主要的需求是可扩展,需要使用一个可扩展体系时
    • 在调用WCF函数时是在一个单线程模式时

    每个会话

    • 你需要在多个WCF调用之间维护状态时
    • 扩大体系时?
    • 轻量级资源引用

    单例

    • 想在你的WCF服务中共享全局数据
    • 不考虑扩展
    展开全文
  • 一)对象实例化常用方式 方式一:直接new一个对象,最常用一种。 方式二:反射,通过Class.forName("类全限定名")。 方式三:构造器,通过Class.forName("类全限定名"),再获取构造方法。 方式四:序列化...

    一)对象实例化常用方式

    方式一:直接new一个对象,最常用的一种。

    方式二:反射,通过Class.forName("类的全限定名")。

    方式三:构造器,通过Class.forName("类的全限定名"),再获取构造方法。

    方式四:序列化,通过java.io.ObjectInputStream对象流的方式。

    备注:工厂模式实例化、克隆实例化两种比较少用。

     

    二)new一个对象

    声明一个对象

    public class NewObject {
    	
        /** 测试方法 */
        public void print() {
            System.out.println("NewObject print-------");
        }
    }

    实例化

    NewObject newObject = new NewObject();
    newObject.print();

     

    三)反射

    声明一个对象

    public class NewObject {
    	
        /** 测试方法 */
        public void print() {
            System.out.println("NewObject print-------");
        }
    }

    实例化

    Class<?> cla = Class.forName("com.oysept.instance.NewObject"); // 包名+类名
    NewObject newObject = (NewObject) cla.newInstance(); // 实例化
    newObject.print(); // 调用测试方法

     

    四)构造器

    声明一个对象

    public class NewObject {
    	
        public NewObject() {
            System.out.println("构造器1-------");
        }
    	
        public NewObject(Object str) {
            System.out.println("构造器2-------");
        }
    	
        public NewObject(String str, Integer s) {
            System.out.println("构造器3-------");
        }
    	
        /** 测试方法 */
        public void print() {
            System.out.println("NewObject print-------");
        }
    }

    场景一:无参构造方法

    Class<?> cla = Class.forName("com.oysept.instance.NewObject"); // 包名+类名
    			
    // 场景一: 无参构造方法
    Constructor<?> constructor = cla.getConstructor(); // 构造器
    NewObject newObject = (NewObject) constructor.newInstance(); // 获取无参构造方法实例
    newObject.print(); // 调用测试方法

    场景二:带Object参数的构造方法

    Class<?> cla = Class.forName("com.oysept.instance.NewObject"); // 包名+类名
    			
    // 场景二: 带Object参数的构造方法
    Constructor<?> constructor = cla.getConstructor(Object.class);
    NewObject newObject = (NewObject) constructor.newInstance("Object");
    newObject.print(); // 调用测试方法

    场景三: 带String和Integer参数的构造方法

    Class<?> cla = Class.forName("com.oysept.instance.NewObject"); // 包名+类名
    			
    // 场景三: 带String和Integer参数的构造方法
    Constructor<?> constructor = cla.getConstructor(String.class, Integer.class);
    NewObject newObject = (NewObject) constructor.newInstance("String", 0);
    newObject.print(); // 调用测试方法

     

    五)序列化

    声明一个对象,必须继承java.io.Serializable接口,才能序列化

    import java.io.Serializable;
    
    public class NewObject implements Serializable {
    	
        /**
         * 
         */
        private static final long serialVersionUID = 1L;
    
        /** 测试方法 */
        public void print() {
            System.out.println("NewObject print-------");
        }
    }

    序列化方法

    /** 序列化 */
    public static void serializable(Object obj, String file) {
        ObjectOutputStream objectOutputStream = null;
        try {
            objectOutputStream = new ObjectOutputStream(new FileOutputStream(new File(file)));
            objectOutputStream.writeObject(new NewObject());
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (objectOutputStream != null) {
                    objectOutputStream.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    反序列化方法

    /** 反序列化 */
    public static Object unSerializable(String file) {
        Object obj = null;
        ObjectInputStream objectInputStream = null;
        try {
            objectInputStream = new ObjectInputStream(new FileInputStream(new File(file)));
            obj = objectInputStream.readObject();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            try {
                if (objectInputStream != null) {
                    objectInputStream.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return obj;
    }

    序列化实例测试

    public static void main(String[] args) {
        try {
            String file = "D:\\object.object"; // 对象存放地址
            // 先序列化
            serializable(new NewObject(), file);
    			
            // 再反序列化
            NewObject new4 = (NewObject) unSerializable(file);
            new4.print(); // 调用测试方法
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

     

    识别二维码关注个人微信公众号

    本章完结,待续、欢迎转载!
     
    本文说明:该文章属于原创,如需转载,请标明文章转载来源!

    展开全文
  • 根据对象类复杂度,由简至繁,可考虑依次使用以下方式进行对象实例化操作: 通过构造函数实例化(最常用,参考博文:构造函数设计) 通过设置Builder内部类(setter方法集合工厂)实例化(参考android.app....

    这方面其实设计模式里面提及到很多,但好像缺少了一种使用顺序关系的描述,目前我读到的设计模式不是很多,不拿来描述了,按自己理解整理一下自己的研究思路

     

    根据对象类的复杂度,由简至繁,可考虑依次使用以下方式进行对象实例化操作:

    • 通过构造函数实例化(最常用,参考博文: 构造函数设计
    • 通过设置Builder内部类(setter方法集合工厂)实例化(参考 android.app.AlertDialog.Builder)
    • 通过设置独立静态Factory类(工厂模式,调用上面的Builder类方法)实例化
    • 通过设置抽象工厂类进行系统实例化(实例化上面的子Factory实现类,再由其执行具体类实例化过程

     

     

    ps.  工厂方法命名参考:

    • cteate***();
    • new***();
    • newInstance();
    • getInstance();
    • obtain***();

    转载于:https://www.cnblogs.com/wavky/p/3473433.html

    展开全文
  • 实例化对象的方式

    2017-12-15 10:11:42
    1 使用new一个对象的方法实例化对象,这个是最常用方法; 2通过工厂防范实例化对象 例:String string = String.valueOf(123); 3运用反射手段,调用java.lang.Class或者java.lang.reflect.Constructor类new...
  • java对象实例化的几种方式

    千次阅读 2018-04-21 13:34:38
    转载https://blog.csdn.net/csolo/article/details/53841241 1)用类new ()创建 2)用clone方法创建, 需要类...4)将一个对象实例化后,进行序列化,再反序列化,也可以获得一个对象(远程通信场景下使用...
  • Java获取Class对象的方式实例化对象的方式 获取Class对象的方式 User类 1、 Class clazz1 = User.class; 2、 User user = new User(); Class clazz2 = user.getClass(); 3、 Class clazz3 = Class.forName(...
  • 直接赋值 方法 : String str = “字符串 ”; 只会开辟一块内存空间,并且会自动存在对象池中以供下次方法直接使用。...在所有开发中,String类对象实例化永远直接采用直接赋值的方式完成。 ...
  • 对象实例化方式以及直接内存对象实例化方式以及直接内存1,对象实例化2,创建对象的步骤**步骤:**每一小步说明1,加载、链接、初始化2,为对象分配内存3,指针碰撞4,空闲列表分配5,测试对象实例化的过程6,给对象...
  • 一、实例化普通Model对象(命名空间方式实例化对象) $goods=new \Model\GoodsModel();//Model为命名空间 二、D()函数实例化Model对象 1.实例化父类Model对象(可用于执行原生sql语句) $model=D(); //D()想当...
  • String类两种对象实例化方式 直接赋值 只会产生一个实例化对象,并且可以自动保存到对象池之中,以实现该字符串实例重用; 构造方法 会产生两个实例化对象,并且不会自动入池,无法实现对象重用,但是可以利用...
  • --userDao创建 ,这个beanid可以任意起名, 默认使用构造函数实例化对象 <bean id="userDaoDemo" class="com.ljf.spring.demo.ioc.dao.impl.UserDaoImpl" scope="singleton"></bean> 二.工厂...
  • 第四章示例代码__对象的实例化方式
  • 实例化对象有两种方式:一种是通过关键字new,另一种是通过反射机制完成。 转载于:https://www.cnblogs.com/Hellorxh/p/10876279.html
  • Spring的对象实例化

    2020-05-14 17:03:30
    现在开发最常用的方式, 通过标注声明告诉Spring容器,让其扫描时将其实例化。 主要标注为@Component,以及它的别名@Service,@Controller, @Resource, @Repository等。 Spring会扫描@ComponentScan(basePackages=...
  • C++三种实例化对象方式 2019-05-04 19:15:43d89538239阅读数 385 一、隐式创建 class CEmployee { private: int age; int id; public: CEmployee() { cout << "这是构造函数" << endl; } ...
  • String 对象实例化两种方式的区别 直接赋值:只会产生一个实例化对象,并且库自动保存到对象池之中,以实现字符串实例重用 构造方法:会产生两个实例化对象,并且不会自动入池,无法实现对象重用,但是可以利用...
  • Java实例化对象的几种方式

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

    千次阅读 2020-01-02 21:19:50
    java实例化对象的4种方式 用new 语句创建对象,这是最常用创建对象方法。 package test; public class Father { public void print() { System.out.println("我是father"); } public static void main...
  • <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation=...
  • 简单说下对象的实例化过程: 首先我们需要有个意识,就是创建一个类的实例化对象,内存中必须要加载了这个类 所以,不论是 new 还是反射或是 Unsafe.allocateInstance(Class),都必须要先找到类对象的内存地址 ...
  • 一、构造器实例化(默认方式):要求Bean对象中要提供无参构造 TypeDao:bean对象 public class TypeDao { private String str; //无参构造 public TypeDao() { } public TypeDao(String str) { this.str = str...
  • Spring实例化Bean对象的三种方式

    千次阅读 2019-09-18 20:36:26
    Spring实例化Bean对象的三种方式 一、Instantiation with a constructor (使用构造函数实例化) 二、Instantiation with a static factory method (使用静态工厂方法实例化) 三、Instantiation using an instance ...
  • 七、对象实例化

    2021-01-27 09:50:03
    七、对象实例化对象实例化创建对象的方式创建对象的步骤对象内存布局对象头实例数据对齐填充对象访问定位直接内存 对象实例化 创建对象的方式 new对象和调用静态方法 Class的newInstance() 反射方式,只能调用空参...
  • JAVA对象实例化的方法 本贴主要对JAVA实例化方式做个简单的总结,尤其是Unsafe的方式,可能很多人都没了解过,这个是sun工程师留的一个后门,可以称为“黑科技” New对象实例 // 直接new对象实例 Productor ...
  • 对象实例化

    2020-07-11 10:01:15
    一、创建对象的方式 1、new (1)直接new 对象 (2)单例模式,构造器是私有的,通过静态方法获取对象 (3)工厂类产生对象 2、class的newInstance() 反射的方式,只能调用空参构造器,权限是public 3、...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 15,137
精华内容 6,054
关键字:

对象实例化的方式