精华内容
下载资源
问答
  • 2022-04-07 10:53:16

    对于类而言,为了让客户端获取它自身的一个实例.最传统的方法就是提供一个公有
    的构造器。还有一种方法,也应该在每个程序员的工具箱中占有一席之地。类可以提供一个公有的静态工厂方法(static factory method),它只是一个返回类的实例的静态方法。下面是一个来自Boolean(基本类型boolean 的装箱类)的简单示例。这个方法是boolean 基本类型值转换成了一个 Boolean 对象引用:
    public static Boolean value0f(boolean b){
                 return b ? Boolean. TRUE : Boolean. FALSE:


    注意,静态工厂方法与设计模式[ Gamma9s〕中的工厂方法(Factory Method) 模式不同。

    静态工厂的优点:

    1.静态工厂方法与构造器不同的第一大优势在于,它们有名称。

    2.静态工厂方法与构造器不同的第二大优势在于,不必在每次调用它们的时候都创建一个新对象。

    3.静态工厂方法与构造器不同的第三大优势在于,它们可以返回原返回类型的任何子类型的对象。

    4.静态工厂的第四大优势在于,所返回的对象的类可以随着每次调用而发生变化,这取决于静态工厂方法的参数值。

    5.静态工厂的第五大优势在于,方法返回的对象所属的类,在编写包含该静态工厂方法的类时可以不存在。

    静态工厂方法的主要缺点在于:

    1.类如果不含公有的或者受保护的构造器,就不能被子类化。

    2.静态工厂方法的第二个缺点在于,程序员很难发现它们。

    下面是静态工厂方法的一些惯用名称。这里只列出了其中的一小部分:
    口from一类型转换方法.它只有单个参数,返回该类型的一个相对应的实例,例如:
    Date d = Date…From(instant)
    口of-一聚合方法,带有多个参数,返回该类型的一个实例,把它们合并起来,例如:
    Set<Ranks faceCards = EnumSet.of(JACK, QUEEN, KING):
    口valueOf一此from 和of 更烦琐的一种替代方法,例如:
    BigInteger prime = BigInteger.valueof (Integer.MAX_VALUE);
    口instance 或者 getInstance.-返回的实例是通过方法的(如有)参数来描述的.但是不能说与参数具有同样的值,例如:
    Stackwalker luke = Stackwalker.getInstance Coptions);
    口create 或者 newInstance-一像instance 或者 getInstance 一样.目 create或者 newInstance 能够确保每次调用都返回一个新的实例,例如:
    Object newArray = Array .newInstance (classobject, arraylen);
    口get Type- 像getInstance一样.但是在工厂方法处于不同的类中的时候使用。Tpe 表示工厂方法所返回的对象类型,例如:
    Filestore fs = Files.getFilestore (path);
    口newType---你newInstance 一样,但是在工厂方法处于不同的类中的时候使用。

    Type 表示工厂方法所返回的对象类型,例如:
    BufferedReader br = Files. newBufferedReader (path);
    type-getType 和newTpe的简版,例如:
    List Complaint> litany = Collections. list (legacyLitany);
    简而言之,静态工厂方法和公有构造器都各有用处,我们需要理解它们各自的长处。
    静态工厂经常更加合适,因此切忌第一反应就是提供公有的构造器,而不先考志静态工厂。

    更多相关内容
  • 本文目录一、什么是静态工厂方法?二、静态工厂方法的优势三、静态工厂方法的缺点四、总结 一、什么是静态工厂方法? 对于类而言,在我们需要获取一个实例时,最传统的方法都是通过new新建一个对象,这是jvm通过调用...
  • 主要介绍了Spring的实例工厂方法和静态工厂方法实例代码,具有一定借鉴价值,需要的朋友可以参考下
  • 主要介绍了 Java静态工厂方法的实例详解的相关资料,希望通过本文大家能掌握java今天工厂方法,需要的朋友可以参考下
  • 主要介绍了Spring实战之使用静态工厂方法创建Bean操作,结合实例形式分析了静态工厂方法创建Bean的相关实现步骤与操作注意事项,需要的朋友可以参考下
  • 主要介绍了C#的静态工厂方法与构造函数对比的优缺点,文中示例代码非常详细,帮助大家更好的理解和学习,感兴趣的朋友可以了解下
  • 简单工厂模式是属于创建型模式,在简单工厂模式中用于被创建实例的方法通常为静态(static)方法,因此又叫做静态工厂方法(Static Factory Method)模式,但不属于23种GOF设计模式之一。简单工厂模式是由一个工厂对象...


    一、定义

    简单工厂模式是属于创建型模式,在简单工厂模式中用于被创建实例的方法通常为静态(static)方法,因此又叫做静态工厂方法(Static Factory Method)模式,但不属于23种GOF设计模式之一。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式,可以理解为是不同工厂模式的一个特殊实现。


    二、使用场景

    • 工厂类负责创建的对象比较少;
    • 客户只知道传入工厂类的参数,对于如何创建对象(逻辑)不关心;
    • 由于简单工厂很容易违反高内聚责任分配原则,因此一般只在很简单的情况下应用。

    三、代码样例

    1.需求

    用面向对象语言实现一个计算器控制台程序,要求输入两个数和运算符号,得到结果。

    2.类图

    在这里插入图片描述

    3.运算操作类

    /**
     * 操作类抽象类
     * 
     */
    public abstract class Operation {
        public double numberA;
        public double numberB;
    
        public abstract double result();
    }
    
    /**
     * 加法类
     * 
     */
    public class OperationAdd extends Operation {
    
        @Override
        public double result() {
    	return numberA + numberB;
        }
    
    }
    
    /**
     * 除法类
     * 
     */
    public class OperationDiv extends Operation {
    
        @Override
        public double result() {
    	if (numberB == 0) {
    	    throw new RuntimeException("divided by 0");
    	}
    	return numberA / numberB;
        }
    
    }
    
    /**
     * 乘法类
     * 
     */
    public class OperationMul extends Operation {
    
        @Override
        public double result() {
    	return numberA * numberB;
        }
    
    }
    
    /**
     * 减法类
     * 
     */
    public class OperationSub extends Operation {
    
        @Override
        public double result() {
    	return numberA - numberB;
        }
    
    }
    

    4.操作工厂类

    /**
     * 操作类工厂类
     * 
     */
    public class OperationFactory {
        public static Operation createOperation(char operator) {
    	Operation operation = null;
    
    	switch (operator) {
    	case '+':
    	    operation = new OperationAdd();
    	    break;
    	case '-':
    	    operation = new OperationSub();
    	    break;
    	case '*':
    	    operation = new OperationMul();
    	    break;
    	case '/':
    	    operation = new OperationDiv();
    	    break;
    	default:
    	    throw new RuntimeException("unsupported operation");
    	}
    
    	return operation;
        }
    }
    

    5.客户端类

    /**
     * 使用工厂方法生成实例完成运算操作
     * 
     */
    public class Calculator {
        public static void main(String[] args) {
    	Operation operation;
    	char operator;
    
    	operator = '+';
    	operation = OperationFactory.createOperation(operator);
    	operation.numberA = 1.2;
    	operation.numberB = 2.3;
    
    	System.out.println(operation.result());
        }
    }
    

    四、优缺点

    优点:

    • 工厂类包含必要的逻辑判断,可以决定在什么时候创建哪一个产品的实例。客户端可以免除直接创建产品对象的职责
    • 客户端无需知道所创建具体产品的类名,只需知道参数即可
    • 也可以引入配置文件,在不修改客户端代码的情况下更换和添加新的具体产品类。(这也是我在开始的披萨店里遇到没有的披萨的解决情况)

    缺点:

    • 工厂类集中了所有产品的创建逻辑,职责过重,一旦异常,整个系统将受影响
    • 使用简单工厂模式会增加系统中类的个数(引入新的工厂类),增加系统的复杂度和理解难度
    • 系统扩展困难,一旦增加新产品不得不修改工厂逻辑,在产品类型较多时,可能造成逻辑过于复杂
    • 简单工厂模式使用了static工厂方法,造成工厂角色无法形成基于继承的等级结构。

    这些缺点在工厂方法模式中得到了一定的克服。


    结尾

    • 感谢大家的耐心阅读,如有建议请私信或评论留言。
    • 如有收获,劳烦支持,关注、点赞、评论、收藏均可,博主会经常更新,与大家共同进步
    展开全文
  • Java 静态工厂方法详解

    千次阅读 多人点赞 2019-04-08 19:09:54
    第一次使用静态工厂方法是在HIT《Software Construction》课程的Lab2-P1的Graph.java中,对静态工厂方法的理解也相当有限,因此撰写此博客加深对静态工厂方法的理解。 Java 静态工厂方法在实际开发中经常使用,在...

    Java 静态工厂方法详解

    本文章主要是对《Effective Java》对静态工厂方法的理解

    第一次使用静态工厂方法是在HIT《Software Construction》课程的Lab2-P1的Graph.java中,对静态工厂方法的理解也相当有限,因此撰写此博客加深对静态工厂方法的理解。

    Java 静态工厂方法在实际开发中经常使用,在《Effective Java》中第二章第一条即为:考虑使用静态工厂方法代替构造器。

    静态工厂方法的含义

    静态工厂方法指的是在类中提供一个公有的静态方法,返回类的一个实例。

    静态工厂方法的第一大优势:它们有名称

    类的构造器名称被限制为类名,然而当构造器因不同的参数类型而无法确切的描述被返回的对象时,静态工厂方法却可以提供不同的函数名称作为不同构造方法。
    例如如下代码:

    public class Person {
        private final SEX sex;
        private final String name;
        private final int age;
    
        private Person(String name, int age, SEX sex){
            this.sex = sex;
            this.name = name;
            this.age = age;
        }
    
        public static Person getManInstance(String name, int age){
            return new Person(name, age, SEX.man);
        }
        
        public static Person getWomanInstance(String name, int age){
            return new Person(name, age, SEX.woman);
        }
    }
    
    enum SEX{
        man,
        woman;
    }
    

    在实际开发中,也如果是需要定义相同参数的构造器,可以通过交换参数位置的方法完成,但是这并不是一个好的方法,降低客户端代码的阅读性。

    静态工厂方法的第二大优势:不必在每次调用时都创建新的对象

    这种方法使得immutable的类可以使用预先构造好的实例或者是已经构造好的静态实例对象、进行重复利用。

    这里提供以下immutable类的五条规则:

    1. 不提供任何mutator
    2. 保证类不会被扩展
    3. 所有的域都是final的
    4. 所有的域都是私有的
    5. 确保对于任何可变组件的互斥性访问
      示例代码如下:
    public class Position{
        private final int x;
        private final int y;
        private static Position ORIGIN = new Position(0,0);
        private Position(int x, int y){
            this.x = x;
            this.y = y;
        }
    
        public static Position getORIGIN(){
            return ORIGIN;
        }
        
        public int getX(){
            return x;
        }
        
        public int getY(){
            return y;
        }
    }
    

    静态工厂方法第三大优势:他们可以返回原返回类型的任何子类型的对象

    这样我们在选择返回对象的类时就有了更大的灵活性。
    这种灵活性的一种应用是,API可以返回对象,同时又不会使对象的类变成公有的。以这种方式隐藏实现类会使API变得非常简洁。这项技术适用于基于接口的框架(interface-basedframework),因为在这种框架中,接口为静态工厂方法提供了自然返回类型。接口不能有静态方法,因此按照惯例,接口Type的静态工厂方法被放在一个名为Types的不可实例化的类(见第4条)中。
    示例代码如下:

    public class Person {
        public static Person getStudent(){
            return new Student();
        }
    }
    class Student extends Person {
    
    }//仅为一无内涵的示例
    

    静态工厂方法的第四大优势在于,在创建参数化类型的实例的时候,他们使代码变得更加简介

    此优势主要体现在泛型初始化时,示例代码如下:

        // 不使用静态工厂方法的情况:
        Map<String, Integer> map = new HashMap<String, Integer>();
        
        
        // HashMap中如果存在此方法:
        public Map<K,V> getInstance(){
            return new HashMap<K,V>();
        }
        
    //    即可简化成以下代码
        Map<String, Integer> map = HashMap.getInstance();
    

    静态方法的主要缺点是,类如果不含有共有的或受保护的构造器,就不能被子类化。

    这一部分较有体会,例如以下代码(错误示例)

    public class Person {
        private final SEX sex;
        private final String name;
        private final int age;
    
        private Person(String name, int age, SEX sex){
            this.sex = sex;
            this.name = name;
            this.age = age;
        }
    
        public static Person getManInstance(String name, int age){
            return new Person(name, age, SEX.man);
        }
    
        public static Person getWomanInstance(String name, int age){
            return new Person(name, age, SEX.woman);
        }
    }
    
    class Student extends Person {
        
    }
    

    实际在编译器的静态检查中会报错,原因是父类缺少公有的构造方法,而子类无法调用父类的私有构造器,导致子类无法生成构造器。

    静态工厂方法的第二个缺点在于,他们与其他的静态方法实际没有任何区别

    下面是一些静态工厂方法的惯用名称:

    1. valueOf——不太严格地讲,该方法返回的实例与它的参数具有相同的值。这样的静态工厂方法实际上是类型转换方法。
    2. of—— valueOf的一 种更为简洁的替代,在EnumSet (见第32条)中使用并流行起来。
    3. getInstance-返回的实例是通过方法的参数来描述的,但是不能够说与参数具有同样的值。 对于Singleton来说, 该方法没有参数,并返回唯一的实例。
    4. newInstance——像 getInstance-样, 但newInstance 能够确保返回的每个实例都与所有其他实例不同。
    5. getType——像getInstance- 样, 但是在工厂方法处于不同的类中的时候使用。Type表示工厂方法所返回的对象类型。
    6. newType——像newinstance一样,但是在工厂方法处于不同的类中的时候使用。Type表示工厂方法所返回的对象类型。

    要不,点个赞?~

    展开全文
  • Effective Java学习:静态工厂方法

    多人点赞 2019-04-30 17:29:25
    静态工厂方法 静态工厂方法是什么?直接从字面应该就很好理解: 工厂方法:大家应该都知道,就是构建实例的方法呗。(比如:“江南皮革厂”就是创建“皮包”这个对象的工厂) 静态方法:这还有解释的必要么..........

    最近在啃《Effective Java》这本神书。简单记录一下,方便以后温习。

    静态工厂方法

    静态工厂方法是什么?直接从字面应该就很好理解:

    工厂方法:大家应该都知道,就是构建实例的方法呗。(比如:“江南皮革厂”就是创建“皮包”这个对象的工厂)

    静态方法:这还有解释的必要么.......

    合起来就是静态的构建对象的方法呗。。哦了,这就是静态工厂方法。本文到此结束,感谢大家观看!

    哈哈,开个玩笑。 虽然静态工厂方法是什么很好理解。可是静态工厂方法到底有什么用呢,我们又为什么要用它呢?


    一般情况下,java中我们创建对象要写一个公有的构造函数,外部调用构造函数来创建一个对象。静态工厂方法就是与它相对应的。代码分别如下:

    class People {
    
        private String sex = "男";
        private String appearance = "一般";
        private String asset = "穷";//原则上来讲,默认数据要符合普遍情况。
    
        //普通构造函数--无参
        public People() {
        }
    
        //普通构造函数--有参
        public People(String sex) {
            this.sex = sex;
        }
    
        public People(String sex, String appearance) {
            this.sex = sex;
            this.appearance = appearance;
        }
    
        public People(String sex, String appearance, String asset) {
            this.sex = sex;
            this.appearance = appearance;
            this.asset = asset;
        }
    
        //静态工厂方法
        public static People createGirlfriend() {//程序员的基本操作,new一个女朋友。
            People people = new People();
            people.sex = "女";
            people.appearance = "倾国倾城";
            people.asset = "市中心十栋楼";
            return people;
        }
    
    }

    上面就是一个简单的静态工厂方法,其实本质上就是加了一层封装。有了这层封装自己可以操作和控制很多东西。

    下面看看两者的区别:

     

    1.静态工厂方法的优点

    1.1 静态工厂方法是有名称的

    我们在java中应该经常看到类似这种构造函数:

    class People {
    
        private String sex = "男";
        private String appearance = "一般";
        private String asset = "穷";
    
        //普通构造函数--无参
        public People() {
        }
    
        //普通构造函数--有参
        public People(String sex) {
            this.sex = sex;
        }
    
        public People(String sex, String appearance) {
            this.sex = sex;
            this.appearance = appearance;
        }
    
        public People(String sex, String appearance, String asset) {
            this.sex = sex;
            this.appearance = appearance;
            this.asset = asset;
        }
    
    }

    当然,官方文档的注释还是很完善和规范的。我们可以看到每个构造函数的用处和每个参数的作用。可是如果在多点参数呢,又如果是自己写方法呢。(有时候懒再少些两行注释~~后期维护两行泪~) 调用的时候是不是就会一脸懵逼?我该调用哪个?这个参数是什么?要传什么值?况且每次构建对象的时候都要点进去看注释也挺麻烦的。

    为了解决上述问题,我们可以使用静态工厂方法。因为静态工厂方法是可以有名字的,这样构建对象时就非常直观。比如文章开始的第一个demo。通过静态工厂方法createGirlfriend()方法可以直接创建一个“People”的实例,同时我们可以直接从方法名看出我们创建出来的“people”实例是“女朋友”。是不是很方便易懂呢~~

     

    1.2 静态工厂方法可以不必在每次调用他们的时候都创建一个新对象

    这个应该很好理解,因为静态工厂方法是多一层封装的。所以在这里面我们可以自由控制返回的对象,可以全局只使用一个对象(单例)或者控制什么时候创建新的实例,什么时候使用缓存的实例。代码如下:

    class People {
    
        private String sex = "男";
        private String appearance = "一般";
        private String asset = "穷";
    
        //静态工厂方法
        public static People createGirlfriend() {
            People people = new People();//这里是我们可控制的,所以你可以选择new新的对象或者使用缓存的已创建的对象
            people.sex = "女";
            people.appearance = "倾国倾城";
            people.asset = "市中心十栋楼";
            return people;
        }
    
    }

     

    1.3 静态工厂方法可以返回原返回类型的任何子类型

    这一点也好理解,先看代码:

    class People {
    
        //静态工厂方法
        public static People createChildren() {
            Children people = new Children();
            return people;
        }
    
    }
    
    //People的子类
    class Children extends People {
        public Children() {
        }
    }

    这个很好理解了,Children是People的子类。所以在静态工厂方法中可以直接返回Children的实例。

    不过这里我们不得不提一下设计原则--里式替换原则:任何基类可以出现的地方,子类一定可以出现。 --百度百科

    最通俗的讲,就是我们在写子类的时候要注意:可以拓展父类功能和属性,但是不能修改。(也就是对扩展开放,对修改关闭)

     

    1.4 静态工厂方法返回的对象的类可以随着每次调用而发生改变,这取决于所传参数值

    理解:静态工厂方法可以根据参数不同返回不同的子类对象。代码如下:

    class People {
    
        /**
         * @param timeForSingle 单身时长
         * @return 对象
         */
        public static People createGirlfriend(int timeForSingle) {
            if (timeForSingle < 5) {//根据所传参数,返回不同的子类对象。
                EighteenBeauty eighteenBeauty = new EighteenBeauty();
                return eighteenBeauty;
            } else {//单身超过五年,看男生都感觉很清秀了呢~~
                Man man = new Man();
                return man;
            }
        }
    
    }
    
    //18岁年轻漂亮的小姑娘
    class EighteenBeauty extends People {
        public EighteenBeauty() {
        }
    }
    
    //男人
    class Man extends People {
        public Man() {
        }
    }

    OK,看代码就很好理解了。根据所传递参数不同返回了不同的子类对象。

     

    1.5 静态工厂方法返回的对象所属的类,在编写包含该静态工厂方法的类时可以不存在(该篇唯一难点)

    重头戏到了,这是本篇唯一难点。这个概念理解起来倒是很简单:静态工厂方法返回对象所属的类,在编写包含该静态工厂方法时可以不存在。(好像是把概念又抄了一遍,不过单从字面实在没什么可解释的了~~)。

    不过重点在于,怎么实现呢?

    这里直接从 这种静态工厂方法最典型的实现--服务提供者框架 来探讨。

    服务提供者框架包含四大组件:(概念不太好理解,可以直接先看下面的例子讲解,然后回过头来再看概念)

    1. 服务接口:这是服务提供者要去实现的接口
    2. 服务提供者接口:生成服务接口实例的工厂对象(就是用来生成服务接口的)(可选)
    3. 提供者注册API:服务者 提供服务者自身的实现
    4. 服务访问API:根据客户端指定的某种条件去实现对应的服务提供者

    概念太拗口,上栗子讲解:

    //四大组成之一:服务接口
    public interface LoginService {//这是一个登录服务
        public void login();
    }
    
    //四大组成之二:服务提供者接口
    public interface Provider {//登录服务的提供者。通俗点说就是:通过这个newLoginService()可以获得一个服务。
        public LoginService newLoginService();
    }
    
    /**
     * 这是一个服务管理器,里面包含了四大组成中的三和四
     * 解释:通过注册将 服务提供者 加入map,然后通过一个静态工厂方法 getService(String name) 返回不同的服务。
     */
    public class ServiceManager {
        private static final Map<String, Provider> providers = new HashMap<String, Provider>();//map,保存了注册的服务
    
        private ServiceManager() {
        }
    
        //四大组成之三:提供者注册API  (其实很简单,就是注册一下服务提供者)
        public static void registerProvider(String name, Provider provider) {
            providers.put(name, provider);
        }
    
        //四大组成之四:服务访问API   (客户端只需要传递一个name参数,系统会去匹配服务提供者,然后提供服务)  (静态工厂方法)
        public static LoginService getService(String name) {
            Provider provider = providers.get(name);
            if (provider == null) {
                throw new IllegalArgumentException("No provider registered with name=" + name);
    
            }
            return provider.newLoginService();
        }
    }

    OK,代码中注释的很清楚了。

    思考下,这么做有什么好处呢??重点看一下上面demo中的 “四大组成之四:服务访问API ”


    想一想,是不是以后想要增加服务时只需要实现服务提供者接口、服务接口,然后约定一个服务名就可以了?

     

    2.静态工厂方法的缺点

    2.1 如果类不含公有的或者受保护的构造器时,就是能被子类化

    如果类的构造方法是私有的,那么这个类就不能被继承了。这时候建议用复合代替继承实现类的拓展。

     

    2.2 静态工厂方法实际上就是静态方法,如果命名不规范的话程序员很难发现他们

    这时候就需要我们自我约束了,利用静态工厂方法时一定要遵循命名规范,下面是一些常用的静态工厂方法命名:

    1. from    类型转换方法,它只有单个参数,返回该类型的一个实例,并把它们合并起来。
    2. of    聚合方法,带有多个参数,返回该类型的一个实例,把他们合并起来。
    3. valueOf    比from和of更繁琐的一种替代方法。
    4. instance或者getInstance    返回的实例是通过方法的(如有)参数来描述的,但是不能说与参数具有同样的值。
    5. create或者newInstance    像instance或者getInstance一样,但create或者newInstance能够确保每次调用都返回一个新的实例
    6. getType    像getInstance一样,但是在工厂方法处于不同的类中的时候使用。Type表示工厂方法所返回的对象类型。
    7. newType    像getInstance一样,但是在工厂方法处于不同的类中的时候使用。
    8. type    getType和newType的精简版。

     

    展开全文
  • Java 使用静态工厂方法替代构造方法

    千次阅读 2020-04-13 09:35:06
    1. 考虑使用静态工厂方法替代构造方法 一个类允许客户端获取其实例的传统方式是提供一个公共构造方法。 其实还有另一种技术应该成为每个程序员工具箱的一部分。 一个类可以提供一个公共静态工厂方法,它只是一个返回...
  • 静态工厂方法模式

    2020-10-23 09:36:56
    静态工厂方法模式 今天我们来聊一聊静态工厂方法模式。 (这是我在实验室做完实验后无聊写的,可能会有遗漏和不足,敬请见谅!) 首先我们来看下面这道题目: 参照以下UML类图片段,并使用JAVA语言及静态工厂方法...
  • Java 设计模式之静态工厂方法模式

    千次阅读 2019-09-16 17:12:12
    静态工厂方法模式,又称为简单工厂模式,是最简单最易理解的工厂模式,本文通过一个 “月饼” 例子,一起来学习下这种设计模式吧!
  • java的静态工厂方法

    千次阅读 2019-11-19 20:41:03
    1.什么是静态工厂方法 类可以提供一个共有的静态工厂方法(static factory method),它只是一个放回类的实例的静态方法。 下面是一个来自Boolean(基本类型boolean的装箱类)的简单实例。 /** 将boolean基本类型转换...
  • 什么是静态工厂方法 对于类而言,为了让使用者获取它自身的一个实例,最常用的方法就是提供一个公有的构造器。 当然,这里要介绍的是另一种方法——静态工厂方法,一个返回类的实例的静态方法。 举个例子,Boolean...
  • 它包含三种静态工厂方法,包括: 一种创建规则凸多边形的方法。 一种创建规则星形多边形的方法。 一种创建圆的方法。 API public static Path regularConvexPolygon(int left, int top, int right, int bottom,...
  • 类还有一种方法,应该成为程序员工具箱中的一把利器,[2]提供一个共有的静态工厂方法,只是一个返回类的实例的静态方法. 这里的静态工厂方法与设计模式中的工厂方法模式不同,两者并不直接对应 与公有的构造器相比,优...
  • 静态工厂方法代替构造器

    千次阅读 2019-12-18 20:40:17
    除了提供构造器以外,静态工厂方法也应该被考虑到程序的设计当中。 静态工厂方法 本质上就是类的一个静态方法,返回值是类的实例对象。 通过私有化构造器,无法直接new对象,而是通过运行静态工厂方法获取对象实例。...
  • 静态工厂方法和实例工厂方法区别

    千次阅读 2019-12-26 17:55:13
    在学习Spring bean的实例化方式的时候遇到的一个问题,Spring bean实例化有3种方法 1、构造器生成 2、静态工厂方法 3、实例工厂方法 那么问题来了,什么是静态工厂方法,什么是实例工厂方法? 1、静态工厂方法 就是...
  • 公有的静态工厂方法(staticfactorymethod),它只是一个返回类的实例的静态方法。 ①静态工厂方法与构造器不同的第一大优势在于,它们有名称。如果构造器的参数本 身没有确切地描述正被返回的对象,那么具有适当...
  • Java静态工厂方法与工厂模式

    千次阅读 2019-02-25 14:02:56
    静态工厂方法和工厂模式很像,但是在java中还是有很大区别的。 (一)静态工厂方法vs工厂模式 对于一个类来说,为了让客户端获得一个自身的实例,最常用的方法就是提供一个公有的构造器。除了这种使用构造器的方法...
  • 静态工厂方法

    2016-09-02 12:17:06
    静态工厂方法讲解  创建类的实例的最常见的方式是用new语句调用类的构造方法。在这种情况下,程序可以创建类的任意多个实例,每执行一条new语句,都会导致Java虚拟机的堆区中产生一个新的对象。假如类需要进一步...
  • Java 静态工厂方法静态工厂方法参考 静态工厂方法 参考 1、Java 的静态工厂方法 2、java静态工厂方法详细解析——使用静态工厂方法代替构造器 3、Effective Java——第一条:用静态工厂方法代替构造器 ...
  • 在简单工厂模式中用于被创建实例的方法通常为静态(static)方法,因此简单工厂模式又被成为静态工厂方法(Static Factory Method) 需要什么,只需要传入一个正确的参数,就可以获取所需要的对象,而无需知道其实现过程 ...
  • 简单工厂模式是属于创建型模式,又叫做静态工厂方法(Static Factory Method)模式,但不属于23种GOF设计模式之一。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单...
  • 在学习Spring bean的实例化方式的时候遇到的一个问题,Spring bean实例化有3种方法 1、构造器生成 2、静态工厂方法 3、实例工厂方法  那么问题来了,什么是静态工厂方法,什么是实例工厂方法? 静态工厂方法 就是...
  • 但还有一种技术,一个类可以提供public的静态工厂方法,只是一个返回类实例的静态方法。 静态工厂方法与设计模式的工厂方法模式不同。在设计模式中并无直接等价的说法。 2 优点 2.1 实名制 如果构造器的参数本身并...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 174,704
精华内容 69,881
关键字:

静态工厂方法

友情链接: Projec12C887.rar