Question

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

这是请求：应用创建适当策略对象的Simple Factory模式。请记住，这是一个简单的工厂模式。绘制新的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

这里有一个关于Simple Factory Pattern [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] - Learning Design Patterns - Factory Pattern

编辑：

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

在以下示例中。＆＃34;文件＆＃34;是抽象类和＆＃34; html＆＃34;文献。＆＃34; myDocument中＆＃34;和＆＃34; pdf＆＃34;是具体的课程。只要您提供有效字符串的参数，您将获得相应的具体类。例如，如果你把＆＃34; pdf＆＃34;作为参数，您将获得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 ();
}

有一篇文章更好的文章帖子 Examples of GoF Design Patterns in Java's core libraries

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

}

如何应用Simple Factory Pattern Java

3 个答案: