如何应用简单的工厂模式Java

Question

我正在尝试了解如何将简单的工厂模式应用于我拥有的 assigment，但我不明白该怎么做。

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

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

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

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());
        }
    }

Answer 1

这里有一个关于简单工厂模式[1]的可能有用的部分：

The simple factory isn't actually a pattern; it's more of a design principle. The simple factory encapsulates the object creation code, but keeps control over how the object is created. Simple factories are often designed as a class with a static method (aka static factory) that returns the object requested.

这里有一个例子，不直接适合你的例子，让你对你的家庭作业:)有点困难

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();
  }
}

• [1] - 学习设计模式 - 工厂模式

编辑：

class LoanFactory{
    public static double getComplexLoan(Loan l){
        return new ComplexLoan().CapitalLoan(l);
    }
}

另一种方式（有其用途，但在这种情况下，我更喜欢上面的方法）：

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();
    }
}

另一件需要注意的重要事项：惯例说方法名称应以小写字母开头，因此您的CapitalLoan()将capitalLoan()。

此外，无需在接口前面加上I，因此您的ICapitalStrategy将变为CapitalStrategy。

Answer 2

在下面的示例中。"文档"是抽象类和"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 ();
}

有一个更好的文档记录的文章线程Java核心库中的GoF设计模式示例

Answer 3

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();
    }
}