标签: solid-principles

我正在介绍SOLID设计原则,我正在尝试将单一责任原则和开放式原则联系起来以设计模式.

目前我有

• SRP:代理,外观
• OCP:战略,指挥

我应该包括其他基本模式吗？

我想指的是在之前使用的例子SO 与鸭和鸭电:

public interface IDuck
{
    void Swim();
}

public class Duck : IDuck
{
    public void Swim()
    {
        //do something to swim
    }
}

 public class ElectricDuck : IDuck
{
    public void Swim()
    {
        if (!IsTurnedOn)
            return;

        //swim logic  
    }

    public void TurnOn()
    {
        this.IsTurnedOn = true;
    }

    public bool IsTurnedOn { get; set; }
}

LSP的原始违规将如下所示:

 void MakeDuckSwim(IDuck duck)
    {
        if (duck is ElectricDuck)
            ((ElectricDuck)duck).TurnOn();
        duck.Swim();
    }

作者的一个解决方案是将Logic放入电动鸭子的游泳方法中以使自己开启:

public class ElectricDuck : IDuck
{
    public void Swim() …

DIP声明:

• 高级模块不应该依赖于低级模块.两者都应该取决于抽象.
• 抽象不应该依赖于细节.细节应取决于抽象.

OCP声明:

软件实体(类,模块,函数等)应该是可以扩展的,但是关闭以进行修改.

我认为如果我们满足DIP,它也会涵盖OCP,那么,为什么我们将这两个原则分开呢？

我正在研究单一职责原则（SRP）和开闭原则（OCP）。

SRP 规定，一个类必须只有一个改变的理由。OCP 规定类必须对修改关闭，但对扩展开放。

我觉得这是矛盾的。一个原则规定类必须足够简单，您可以出于单一原因进行更改，但另一条原则规定类不得更改而只能扩展。

有人有更好的解释吗？

我有一个类似于下面的类（C#）：

public class Product {

    public int ID {get;set;}
    public string Name {get;set;}
    public double Price {get;set;}

    public void Save() {
        string sql = "INSERT INTO Product.....";
        Database.Execute(sql);
    }

    public void Delete() {
        string sql = "DELETE Product WHERE.....";
        Database.Execute(sql);
    }
}

我主要担心的是上面的代码违反了 SOLID 原则，因为它负责创建和删除自己。

也许这些 Save 和 Delete 方法应该放在 Product 实体之外的某个地方（也许是 Factory/Repository？）。

根据接口隔离原则

不应该强迫客户端实现不需要的接口方法

...因此我们应该定义接口以进行逻辑分离。

但是defaultJava 8 中引入的方法提供了在 Java 接口中实现方法的灵活性。似乎 Java 8 提供了增强接口的可行性，使其具有一些与其核心逻辑无关的方法，但具有一些默认或空的实现。

它不违反ISP吗？

我有两种在我的应用程序中保存数据的方法：保存到数据库和保存到文件。由于我不希望客户端代码处理对象的构造，因此我创建了一个类（据我所知）是带有工厂方法的简单工厂。代码如下：

public static DataPersister createDataPersister(Boolean saveToDb, Session session, String filename) {
    if (saveToDb) {
        return new DatabaseDataPersister(session);
    } else {
        return new FileDataPersister(filename);
    }
}

使用此设置，客户端代码不必处理构建任何内容或决定是否保存到数据库或文件 - 它只需调用save()工厂返回的对象上的方法，如下所示：

DataPersister dataPersister = DataPersisterSimpleFactory.createDataPersister(this.savetoDb, this.session, this.filename);
dataPersister.save(this.data);

我的问题是 - 这个解决方案是否违反了 SOLID 原则？例如，为了创建一个DatabaseDataPersister客户端代码需要传递一个filename参数，并且这个实现DataPersister不会使用它。我觉得它与类似于接口隔离原则的东西并不相符，但并非如此。

如果解决方案确实是代码异味 - 我该如何清理它？

我有以下结构可以使用开闭原理

class Payment{ 

    //this is not a model class
    // according to OC principle this class should not focus on the implementation

    private $paymentInterface;

    public function __construct(PaymentInterface $paymentInterface)
    {
        $this->paymentInterface = $paymentInterface;
    }


    //so store method does not know which implementation it will get
    public function store($request,$id)
    {
        return $this->paymentInterface->store($request,$id);
    }

}

接口

interface PaymentInterface{
    public function store($request,$id = null);
}

包含实现的支付服务类

class PaymentService implements PaymentInterface{
    public function store($request,$id = null){
        //payment store logic is here
    }
}

控制者 …

我对单一职责原则很困惑。该原则指出，类更改的原因应该只有一个。

我面临的问题是，对方法的任何更改或做事中的任何逻辑更改都会更改类。例如，考虑以下类：

class Person{
    public void eat(){ };
    public void walk(){ };
    public void breathe(){ };
    public void run(){ };
    public void driveCar(Car car){ };
}

鲍勃叔叔将其描述为应该只有一个人/演员负责更改。我有以下两个问题：

1. 对于上面的类，谁是可以负责变化的演员/人？
2. 饮食、呼吸或行走的逻辑的任何变化不会改变 Person 类吗？那么这是否意味着每一种方法都是改变的理由，因为做事的逻辑可能会改变？

我有 3 个班级，Account, CappedAccount, UserAccount,

CappedAccount，并且UserAccount都扩展Account。

Account 包含以下内容：

abstract class Account {
   ...
   /**
   * Attempts to add money to account.
   */
   public void add(double amount) {
      balance += amount;
   }
}

CappedAccount 覆盖此行为：

public class CappedAccount extends Account {
   ...
   @Override
   public void add(double amount) {
      if (balance + amount > cap) { // New Precondition
         return;
      }
      balance += amount;
   }
}

UserAccount不会覆盖来自 的任何方法Account，因此不需要说明。

我的问题是，是否CappedAccount#add …