如何在Java中应用简单工厂模式

我试图理解如何将简单的工厂模式应用到我拥有的分配中，但我不知道如何做到这一点

这就是请求：应用创建适当策略对象的简单工厂模式。 记住，这是一个简单的工厂模式。绘制新模型的UML图 设计

我们已经实现了strategy模式，但我不明白如何将简单的工厂模式应用到代码中。我知道简单工厂模式应该为对象的创建提供封装，但我不知道我发现的示例如何应用于此。任何帮助都将不胜感激

编辑：更新代码 编辑：更改代码以使用多态性

package Client;

import domain.Loan;
import factory.StrategyFactory;
import strategy.ComplexLoan;
import strategy.ICapitalStrategy;

public class Client {
    public static void main(String[] args){
        Loan complexLoan = new Loan(2.2, 2, 3.3, 4.4, 5, 6, 7, StrategyFactory.getComplexStrategy());
        System.out.print("hello");

    }

}

package factory;

import strategy.ComplexLoan;
import strategy.ICapitalStrategy;
import strategy.RevolvingLoan;
import strategy.TermLoan;



public class StrategyFactory {
    /*
    public static ICapitalStrategy getStrategy(String type) {       
        if (type.equals("Complex")){
            return new ComplexLoan();
        }
        else if (type.equals("Revolving")){
            return new RevolvingLoan();
        }
        else if (type.equals("Term")){
            return new TermLoan();
        }
        return null;
    }
    */

    public static ICapitalStrategy getComplexStrategy() {
        return new ComplexLoan();
    }
    public static ICapitalStrategy getRevolvingStrategy() {
        return new RevolvingLoan();
    }
    public static ICapitalStrategy getTermStrategy() {
        return new TermLoan();
    }
}

    package domain;
    import strategy.ICapitalStrategy;


    public class Loan {
        private ICapitalStrategy strategy;

        double commitment;
        int duration;
        double riskFactor;
        double unusedPercentage;
        int outstandingRiskAmount;
        int unusedRiskAmount;
        double unusedRiskFactor;
        double capital;

        public Loan(double commit, int dura, double rskFact, double unusedPer,
                    int outStandRskAmt, int unusedRskAmt, double unusedRskFac,
                    ICapitalStrategy strat) {
            this.commitment = commit;
            this.duration = dura;
            this.riskFactor = rskFact;
            this.outstandingRiskAmount = outStandRskAmt;
            this.unusedRiskAmount = unusedRskAmt;
            this.unusedRiskFactor = unusedRskFac;
            this.strategy = strat;

        }

        public double CalculateCapital() {
            return strategy.CapitalLoan(this);
        }

        public double getCommitment() {
            return commitment;
        }

        public void setCommitment(double c) {
            commitment = c;
        }

        public int getDuration() {
            return duration;
        }

        public void setDuration(int dur) {
            duration = dur;
        }

        public double getRiskFactor() {
            return riskFactor;
        }

        public void setRiskFactor(double rskFac) {
            riskFactor = rskFac;
        }

        public double getUnusedPercentage() {
            return unusedPercentage;
        }

        public void setUnusedPercentage(double unusedPercent) {
            unusedPercentage = unusedPercent;
        }

        public double getOutstandingRiskAmount() {
            return outstandingRiskAmount;
        }

        public void setOutstandingRiskAmount(int outStandingRskAmt) {
            outstandingRiskAmount = outStandingRskAmt;
        }

        public double getUnusedRiskAmount() {
            return unusedRiskAmount;
        }

        public void setUnusedRiskAmount(int UnusedRskAmt) {
            unusedRiskAmount = UnusedRskAmt;
        }

        public double getUnusedRiskFactor() {
            return unusedRiskFactor;
        }

        public void setUnusedRiskFactor(double unusedRskFac) {
            unusedRiskFactor = unusedRskFac;
        }

        public Loan(ICapitalStrategy strategy) {
            this.strategy = strategy;
        }

        /*public double executeStrategy() {
            return this.strategy.CapitalLoan(this);
        }
        */
    }

    package strategy;

    import domain.Loan;

    public class ComplexLoan implements ICapitalStrategy {

        @Override
        public double CapitalLoan(Loan l) {
            return ((l.getOutstandingRiskAmount() * l.getDuration() * l.getRiskFactor()) + (l.getUnusedRiskAmount() 
                    * l.getDuration() * l.getUnusedRiskFactor() ));
        }

    }

    package strategy;

    import domain.Loan;

    public interface ICapitalStrategy {
        public double CapitalLoan(Loan l);
    }

    package strategy;

    import domain.Loan;

    public class RevolvingLoan implements ICapitalStrategy {

        @Override
        public double CapitalLoan(Loan l) {
            return (l.getCommitment() * l.getUnusedPercentage() * l.getDuration() *l.getRiskFactor());  
        }

    }

    package strategy;

    import domain.Loan;

    public class TermLoan implements ICapitalStrategy {
        public TermLoan() {

        }
        public double CapitalLoan(Loan l) {
            return (l.getCommitment() * l.getDuration() * l.getRiskFactor());
        }

    }

---

下面是一个关于简单工厂模式[1]的有用信息：

简单工厂实际上不是一种模式；这更多的是一个设计原则。简单工厂封装对象创建代码，但控制对象的创建方式。简单工厂通常被设计为一个带有静态方法的类，即返回所请求对象的静态工厂

这里有一个例子，不直接适合你的例子，为了让你的家庭作业思考有点困难：

interface Foo{
  double calculateStuff();
}

class MyClass implements Foo{
  @Override
  public double calculateStuff(){
    //logic goes here
  }
}

class MyFactory {
  public static double getCalculatedStuff(){
    return new MyClass().calculateStuff();
  }
}

class RunCode {
  public static void main(String[] args){
     double stuff = MyFactory.getCalculatedStuff();
  }
}

编辑：

另一种方法也有它的用途，但在这种情况下，我更喜欢上面的方法：

class ComplexLoan implements ICapitalStrategy{
    private ComplexLoan(){
    }

    public static double getLoan(Loan l){
        return new ComplexLoan().CapitalLoan(l);
    }
}

或者此选项显式显示多态性：

class LoanFactory{

    public static ICapitalStrategy getComplexLoan(){
        return new ComplexLoan();
    }
}

另一件需要注意的事情是：约定说方法名应该以小写字母开头，所以您的大写字母应该是大写字母

---

此外，不需要在接口前面加I，因此您的ICapitalStrategy将成为CapitalStrategy。

在下面的示例中。该文档是抽象类和html文档。MyDocument和pdf是具体的类。只要为参数提供有效字符串，就会得到相应的具体类。例如，如果您将pdf作为参数，您将获得pdf文档。文档类型是接受要创建的任何类型的文档所需的全部内容

public Document CreateDocument(String type){
if (type.isEqual("html"))
    return new HtmlDocument();
if (type.isEqual("proprietary"))
    return new MyDocument();
if (type.isEqual("pdf"))
    return new PdfDocument ();
}

在线程中有一个更好的文档化文章

---

我看不出我找到的示例如何说明如何应用于此。我们也在猜测。它应该在你的作业说明中。如果不是，你应该问指导老师。@Radiodef我在网上查阅了一些资源，这更像是一个提示，但仍然不清楚，因此我可以得到一个更具指导性的解释。OP说他们已经看过一些例子了。另外，你的例子也不完全正确。工厂模式通常是用于创建其他对象的对象，而不是用于执行计算的静态实用程序类。是的，我的关于计算的示例不是演示工厂模式的最佳选择，但我相信它足够简单，OP可以理解。另外，OP说他们不理解他们找到的例子。@victorantunes，所以我基本上需要为我的接口的每个子类创建一个因子？不是真的。关键是只有一个工厂类，实现策略接口的每个类都有一个方法，并让该方法返回所述类的实例。你现在有进展了吗？我试着给你指出正确的方向，而不给你家庭作业的确切答案。你应该想：p@victorantunes我在网上找到的所有例子似乎都比这个简单。我想我可能正在进步。现在有点油炸了。我想我已经弄明白了。如果它看起来正确，请告诉我。你也可以使用泛型。在我看来，为三种类型的具体类编写三种不同的方法可以影响可伸缩性。

public Document CreateDocument(String type){
if (type.isEqual("html"))
    return new HtmlDocument();
if (type.isEqual("proprietary"))
    return new MyDocument();
if (type.isEqual("pdf"))
    return new PdfDocument ();
}

public interface PaymentMethod {
    public void makePayment();
}

class CreditCard implements PaymentMethod {
    public void makePayment() {
        System.out.println("Payment through credit card...");
    }
}

class NetBanking implements PaymentMethod {
    public void makePayment() {
        System.out.println("Payment through net banking...");
    }
}

public class PaymentMethodFactory {
    public static PaymentMethod getPaymentMethod(String method) {
        if ("creditcard".equalsIgnoreCase(method)) {
            return new CreditCard();
        } else if ("netbanking".equalsIgnoreCase(method)) {
            return new NetBanking();
        } else {
            throw new IllegalArgumentException("Payment method not supported!");
        }
    }
}

public class SimpleFactoryTest {

    public static void main(String[] args) {
        PaymentMethodFactory factory = new PaymentMethodFactory();
        PaymentMethod paymentMethod = factory.getPaymentMethod("creditcard");
        paymentMethod.makePayment();
    }

}