【Effective Java】1、静态工厂的方式代替构造函数

使用一个服提供者对进行服务的提供,服务的请求通过不同的提供者提供不同的服务,服务提供者首先必须在工厂中进行注册,然后才可以通过工厂实例化服务

Service.java

package cn.xf.cp.ch02;

/**
 *
 *功能:这是一个服务类
 *时间:下午6:03:23
 *文件:Service.java
 *@author Administrator
 *
 */
public interface Service
{
    //比如服务类提供一个hello world的服务
    public void sayHello();
}
Provider.java
package cn.xf.cp.ch02;

/**
 *
 *功能:服务的提供者
 *时间:下午6:05:29
 *文件:Provider.java
 *@author Administrator
 *
 */
public interface Provider
{
    public Service newInstance();
}

ServicesFactory.java

package cn.xf.cp.ch02;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 *
 *功能:服务工厂,提供服务的实体类
 *    这是是进行服务的注册和连接。只有先注册了的服务才可以进行连接9
 *时间:下午6:06:32
 *文件:ServicesFactory.java
 *@author Administrator
 *
 */
public class ServicesFactory
{
    //构造函数私有化,避免别的调用者不通过静态工厂方法实例
    private ServicesFactory(){};

    //服务注册的时候保存在容器中,并如果没有指定的实例方式,那么还得设定一个默认的实例方式
    private static final Map<String, Provider> providers = new ConcurrentHashMap<String, Provider>();

    private static final String DEFAULT_PROVIDER_NAME = "<def>";

    //进行注册方法的API,注册一个提供服务的人
    public static void registerDfaultProvider(Provider p)
    {
        resgisterProvider(DEFAULT_PROVIDER_NAME, p);
    }

    public static void resgisterProvider(String name, Provider p)
    {
        providers.put(name, p);
    }

    //进行连接方法的API,和注册的方法类型
    public static Service newInstance()
    {
        return newInstance(DEFAULT_PROVIDER_NAME);
    }

    //根据提供者的名字提供相应的服务
    public static Service newInstance(String name)
    {
        Provider p = providers.get(name);
        if(p == null)
        {
            //如果没有注册的话,就抛出异常
            throw new IllegalArgumentException("这个提供服务的对象没有进行注册" + name);
        }

        return p.newInstance();
    }
}

测试代码

package cn.xf.cp.ch02;

public class Test
{
    public static void main(String[] args)
    {
        // 首先注册服务请求人
        ServicesFactory.registerDfaultProvider(DEFAULT_PROVIDER);
        ServicesFactory.resgisterProvider("comp", COMP_PROVIDER);
        ServicesFactory.resgisterProvider("armed", ARMED_PROVIDER);

        // 实例化服务
        Service s1 = ServicesFactory.newInstance(); // 默认的
        Service s2 = ServicesFactory.newInstance("comp");
        Service s3 = ServicesFactory.newInstance("armed");

        s1.sayHello();
        s2.sayHello();
        s3.sayHello();
    }

    private static Provider    DEFAULT_PROVIDER    = new Provider()
                                                {
                                                    public Service newInstance()
                                                    {
                                                        return new Service()
                                                                                                    {
                                                                                                        @Override
                                                                                                        public String toString()
                                                                                                        {
                                                                                                            return "Default service";
                                                                                                        }

                                                                                                        @Override
                                                                                                        public void sayHello()
                                                                                                        {
                                                                                                            System.out
                                                                                                                    .println(
                                                                                                                            "DEFAULT_PROVIDER这个排版很有问题啊");

                                                                                                        }
                                                                                                    };
                                                    }

                                                };

    private static Provider    COMP_PROVIDER        = new Provider()
                                                {
                                                    public Service newInstance()
                                                    {
                                                        return new Service()
                                                                                                    {
                                                                                                        @Override
                                                                                                        public String toString()
                                                                                                        {
                                                                                                            return "Complementary service";
                                                                                                        }

                                                                                                        @Override
                                                                                                        public void sayHello()
                                                                                                        {
                                                                                                            System.out
                                                                                                                    .println(
                                                                                                                            "COMP_PROVIDER这个排版很有问题啊");

                                                                                                        }
                                                                                                    };
                                                    }
                                                };

    private static Provider    ARMED_PROVIDER        = new Provider()
                                                {
                                                    public Service newInstance()
                                                    {
                                                        return new Service()
                                                                                                    {
                                                                                                        @Override
                                                                                                        public String toString()
                                                                                                        {
                                                                                                            return "Armed service";
                                                                                                        }

                                                                                                        @Override
                                                                                                        public void sayHello()
                                                                                                        {
                                                                                                            System.out
                                                                                                                    .println(
                                                                                                                            "ARMED_PROVIDER这个排版很有问题啊");

                                                                                                        }
                                                                                                    };
                                                    }
                                                };
}

结果显示:

时间: 2024-10-12 23:28:41

【Effective Java】1、静态工厂的方式代替构造函数的相关文章

静态工厂方法的介绍

本文略长,所以先来个内容提要 序:什么是静态工厂方法 静态工厂方法的优势 2.1 静态工厂方法与构造器不同的第一优势在于,它们有名字 2.2 第二个优势,不用每次被调用时都创建新对象 2.3 第三个优势,可以返回原返回类型的子类 2.4 第四个优势,在创建带泛型的实例时,能使代码变得简洁 除此之外 3.1 可以有多个参数相同但名称不同的工厂方法 3.2 可以减少对外暴露的属性 3.3 多了一层控制,方便统一修改 总结 1. 序:什么是静态工厂方法 在 Java 中,获得一个类实例最简单的方法就是

[Effective Java]考虑用静态工厂方法代替构造器

本文主要介绍如何使用静态工厂方法已经在那种场合来使用这种方式代替构造方法. 众所周知,对于类而言,我们为了获得一个类的实例对象,通常情况下会提供一个公有的(public) 的构造器.当然除了这种方法以外,我们还可以通过给类提供一个public的静态工厂方法(static factory method)的方式来完成,让它返回一个类的实例. 先看一个简单的Boolean的示例,这个示例将boolean基本类型值转换成一个Boolean对象的引用. public static Boolean valu

Effective Java 读书笔记(一):使用静态工厂方法代替构造器

这是Effective Java第2章提出的第一条建议: 考虑用静态工厂方法代替构造器 此处的静态工厂方法并不是设计模式,主要指static修饰的静态方法,关于static的说明可以参考之前的博文<java中final与static的使用场景总结>. 什么是静态工厂方法? 可以参考书中的例子(摘自JDK1.7 java.lang.Boolean) public final class Boolean implements java.io.Serializable, Comparable<

Effective java读书札记第一条之 考虑用静态工厂方法代替构造器

对于类而言,为了让客户端获取它资深的一个实例,最常用的方法就是提供一个共有的构造器.还有一种放你发,也应该子每个程序员的工具箱中占有一席之地.类可以提供一个共有的静态 工厂方法,它只是返回类的实例的静态方法. 类可以通过静态工厂方法类提供它的客户端(对象),而不是通过构造器.提这样做的好处有: 1.静态工厂方法与构造器不同的第一大优势在于,它们有名称.比如构造器BigInteger(int,int,Random)返回的BigInteger可能为素数,如果用名为BigInteger.probabl

Effective Java第三版(一) ——用静态工厂代替构造器

此文做为<Effective Java>系列的第一篇,所以有必要大概说下此书的特点,当然很多人可能都看过,毕竟是有着Java四大名著之一的大名在外,不过总会有萌新不了解,例如我!<Effective Java>第三版较之上一版新增了对Java7.8.9的一些新特性的条目.而条目的概念可以理解为武功秘籍中的一招一式,学完了每一招一式,就是神功大成之时.第三版在第二版的基础上新增了一些条目数,达到了90条.书就介绍到这里,下面介绍第一条——用静态工厂代替构造器. 对于创建对象,最熟悉的

EFFECTIVE JAVA 第一天 静态工厂方法

静态工厂方法:(这里指的是就是普通static方法),类可以通过静态工厂方法提供给它的客户端,而不是通过构造器.提供静态工厂方法而不是公有构造器,这样做有几大优势. 在类的实现中使用了API的类被称为该API的客户(client) 使用API编写程序的程序员称为该API的用户(user) 术语:基本类型:primitive,引用类型:reference type 方法的签名:由名称和所有参数类型组成,不包括返回类型 优点: 1. 有名称(当一个类有多个相同签名的构造器,用静态工厂代替更容易理解)

Effective JAVA NO1考虑用静态工厂方法代替构造器

NO1.考虑用静态工厂方法代替构造器 静态工厂方法与构造器不同的第一大优势在于它们有名称: 静态工厂方法与构造器不同的第二大优势在于,不必在每次调用它们的时候都创建一个新对象: 第三大优势,它们可以返回原返回类型的任何子类型的对象: 第四大优势,在创建参数化类型实例的时候,它们使代码变得更加简洁: 缺点: 1.类如果含公有的或者受保护的构造器,就不能被子类化. 2.它们与其他的静态方法实际不上没有任何区别.

【读书笔记 - Effective Java】01. 考虑用静态工厂方法代替构造器

获取类的实例有两种方法: 1. 提供一个公有的构造器(最常用). 2. 提供一个公有的静态工厂方法(static factory method). // 静态工厂方法示例 public static Boolean valueOf(boolean b) { return b ? Boolean.TRUE : Boolean.FALSE; } 静态工厂方法的优势: 1. 有名称.当一个类需要多个带有相同签名(方法签名 = 方法名 + 参数列表)的构造器时,就用静态工厂方法代替构造器,并且慎重选择名

Spring 使用静态工厂方式实例化Bean

知识点介绍: 静态工厂顾名思义,就是通过调用静态工厂的方法来获取自己需要的对象,为了让spring管理所有对象,我们不能直接通过"工程类.静态方法()"来获取对象,而是依然通过spring注入的形式获取. [转载使用,请注明出处:http://blog.csdn.net/mahoking] 操作步骤: 1.创建Speaker对象. /** * 静态工厂类 * */ public class Speaker { private String name ; private String t