标签: static-factory

我一直在使用工厂方法创建模式一段时间.我刚刚被告知这个:

public static class ScheduleTypeFactory
{
    public static IScheduleItem GetScheduleItem(ScheduleTypeEnum scheduleType)
    {
        IScheduleItem scheduleItem = null;

        switch (scheduleType)
        {
            case ScheduleTypeEnum.CableOnDemandScheduleTypeID:
                {
                    scheduleItem = new VODScheduleItem();
                    break;
                }
            case ScheduleTypeEnum.BroadbandScheduleTypeID:
                {
                    scheduleItem = new VODScheduleItem();
                    break;
                }
            case ScheduleTypeEnum.LinearCableScheduleTypeID:
                {
                    scheduleItem = new LinearScheduleItem();
                    break;
                }
            case ScheduleTypeEnum.MobileLinearScheduleTypeID:
                {
                    scheduleItem = new LinearScheduleItem();
                    break;
                }
        }

        return scheduleItem;
    }
}

不是我的"技术"主管的工厂方法创建模式,而没有告诉我为什么或给我她的解释.我很友好地要求解释,她告诉我她没有时间.我被告知要重命名它.如果我错了,那么毫无疑问我会接受我已经错误地实施了多年.这是你如何实现工厂方法创建模式？提前致谢.

这是关于工厂模式.我有点困惑.

我看到了createInstance()方法是静态的实现和一些非静态的实现.

有人说这取决于"风格"或"味道",有些人说它没有.维基百科说它应该是非静态的,并且http://www.dofactory.com/Patterns/PatternFactory.aspx也表示它应该是非静态的,根据Gang of Four的说法.

我的问题是:它是否依赖于风格和品味,或者它是否违反了工厂模式,如果它是以静态方式实现的？什么是对的？

使用 JDK 11 时，我无法理解以下类型安全问题。谁能解释当我直接传递Set.of参数时没有收到编译错误的原因：

public static void main(String[] args) {
    var intSet1 = Set.of(123, 1234, 101);
    var strValue = "123";
    isValid(strValue, intSet1);// Compilation error (Expected behaviour)
    **isValid(strValue, Set.of(123, 1234, 101));// No Compilation error**
}

static <T> boolean isValid(T value, Set<T> range) {
    return range.contains(value);
}

您可以在 IdeOne.com 上实时运行此代码。

如果我正在编写一个静态工厂方法来创建对象,我如何使用该工厂类的'@Component'注释并指示(带有一些注释)静态工厂方法,应该调用该方法来创建该类的bean？以下是我的意思的伪代码:

@Component
class MyStaticFactory
{
    @<some-annotation>
    public static MyObject getObject()
    {
        // code to create/return the instance
    }
}

背景:

这是我目前正在处理的代码.首先,基类是一个帐户类,它包含有关帐户的信息,并且有一些方法可以在很大程度上更改类属性的值.

public class Account {
    private string _username; [...]

    public string Username { get { return _username; } } [...]

    public Account() { }

    public Account(string[] args) { [...] }

    public virtual void ChangePassword(string newPassword) { [...] }
}

然后,我在创建帐户时有另一个类,我将其命名为ActiveAccount.这包含了我想要为帐户使用的操作的大部分逻辑,只有在创建帐户后才可以使用.不需要包括一些课程来解释这个问题; 用你的想象力来假设这些课程可以做什么:

public class ActiveAccount : Account
{
    private List<Conversation> _conversations; [...]

    public List<Conversation> Conversations { get { return _conversations; } } [...]

    private ActiveAccount() { }

    public static ActiveAccount CreateAccount(Account account)
    {
        // Navigate to URL, input fields, create …

我正在阅读有效的java教科书.第一项是关于使用静态工厂方法而不是公共构造函数.我怀疑的是,如果我指定一个Interface如何指定静态工厂方法Interface？因为java里面不支持静态方法interface.教科书指定了如何创建包含公共静态工厂方法的不可实例化的类.但是这些方法如何访问实现类的私有构造函数呢？

教科书说,如果要定义Interface Type,则创建一个不可实例化的类,Types并在该类中包含静态工厂方法.但是,如何在Types类中定义的方法访问具体实现的私有构造函数Interface Type

编辑: - 下面的句子引用了教科书.请解释一下它的含义

"接口不能有静态方法,因此按照惯例,名为Type的接口的静态工厂方法放在名为Types的不可实例化的类(Item 4)中"

编辑: - 取自Effective Java作者:Joshua Bloch:第1项 - 静态工厂方法

     public interface Foo{ //interface without plural 's' (question 1)
     public void bar();
 }
 public abstract class Foos(){ // abstract factory with plural 's' (question 1)
    public static Foo createFoo(){
        return new MyFoo();
    }
    private class MyFoo implements Foo{ // a non visible …

我有一个(Java)类,有许多实例字段(其中许多是可选的).我希望所有字段(因此类)都是不可变的.所以,我想使用Builder Pattern来构造类的实例.

我可以使用Builder模式配置myBatis来创建类的实例吗？我知道我可以让myBatis返回一张地图并使用该地图在我的代码中构建实例.但是,我正在寻找一种方法来配置这种映射(或使用一些约定),类似于如何通过使用Java Bean和构造函数来创建实例.

编辑(包括一个例子)

这是一个例子:

package com.example.model;

// domain model class with builder
public final class CarFacts {

private final double price;
private final double numDoors;
private final String make;
private final String model;
private final String previousOwner;
private final String description;

public static class Builder {
// required params
private final double price;
private final String make;
private final String model;

// optional params
private final String previousOwner;
private final String description;
private final double numDoors;

public Builder(double …

使用enum或String分派到正确的对象以在static工厂方法中创建更好吗？

示例String：

public static Car createCar(String carName){
    if(carName.equals("Ferrari")){
        return new Ferrari();
    }
    else if(carName.equals("Porsche")){
        return new Porsche();
    }
    ....
}

示例enum：

public static Car createCar(CarEnum carEnum){
    if(CarEnum.FERRARI.equals(carEnum)){
        return new Ferrari();
    }
    else if(CarEnum.PORSCHE.equals(carEnum)){
        return new Porsche();
    }
    ....
}

目前，据我所知：

使用的好处enum：

• 避免用户使用未经处理的carName.

使用的缺点Enum：

增加依赖项，因为更改为enum（例如FERRARI变成ENZO_FERRARI）将需要在客户端上进行修改。但是，String我们可以Ferrari在Enzo Ferrari不重新编译客户端代码的情况下重定向到实例。当然，我们可以使用enum重定向FERRARI到的旧值为客户端做同样的事情，ENZO-FERRARI enum但对我来说，这意味着 …

我用Java有这个简单的记录：

public record DatePair( LocalDate start , LocalDate end , long days ) {}

我希望所有三个属性 ( start、end、 & days) 都可供公开阅读，但我希望第三个属性 ( days) 自动计算，而不是在实例化期间传入。

所以我添加一个静态工厂方法：

public record DatePair( LocalDate start , LocalDate end , long days ) {}

我只想使用这个静态工厂方法进行实例化。我想隐藏构造函数。因此，我显式地编写了隐式构造函数，并对其进行了标记private。

public record DatePair( LocalDate start , LocalDate end , long days )
{
    public static DatePair of ( LocalDate start , LocalDate end )
    {
        return new DatePair ( start , end …

我已经看到了至少三种在Java对象中获取依赖关系的方法,而没有将对象耦合到依赖项的创建;

依赖注入 - 一些框架基于外部配置将所需对象注入另一个对象,例如:Spring托管bean

依赖查找 - 类在某种目录服务中查找必需的依赖项,例如:Java EE容器中的JNDI查找

静态工厂 - 全局范围内的对象按需提供实例 - 标准Java SE API似乎充满了这些,例如:java.util.Logger.getLogger(name),java.util.Calendar.getInstance()

您可以提供哪种指导最适合某种情况？

在 JavaFX 中，有一些类（例如 javafx.scene.text.Font 和 javafx.scene.paint.Color）具有类似于构造函数的静态方法。在 Font 类中，可以使用语句创建一个新的 Font 对象new Font(name, size)，但它相当于调用静态方法Font.font(name, size)，其中 Font.font 方法返回对新 Font 对象的引用。JavaFX 通过创建这些 \xe2\x80\x98static\xe2\x80\x99 构造函数获得了哪些客观好处？它们看起来是多余的。为什么不直接声明更多的重载构造函数来实现相同的目标呢？

我正在学习有效的Java。第一项为构造器上的静态工厂方法提供了令人信服的案例。

我没有第一个缺点是

仅提供静态工厂方法的主要缺点是没有公共或受保护的构造函数的类不能被子类化。

由于静态方法不能被继承，为什么我需要对具有静态工厂方法的类进行子类化？

有人可以解释一下。

我正在查看 Java 中内置的一个接口，并注意到它有返回其自己类型的对象的方法。

具体来说，IntStreamrange接口有一个返回 IntStream 对象（即实现 IntStream 的某个对象）的方法。该方法只需导入接口即可使用，如下：

import java.util.stream.IntStream;

class Foo {
    public static void main(String[] args) {
        IntStream s = IntStream.range(0,10);
        System.out.println(s.average());
    }
}

因此，似乎“在幕后”界面正在为我选择一个实现，并允许我使用它。这究竟是如何运作的？

至关重要的是，我将如何做同样的事情？如果我想导出一个可以实例化其自己类型的对象的接口，以便用户可以简单地导入我的接口并拖动我的实现，我该怎么做？或者这只是Java内置接口的特殊特权？