标签: solid-principles

我在设计数据库的过程中工作了很长时间,而且这些天我也在使用C#.OO对我来说很有意义,但我并不觉得我对OO设计的深层理论有很好的基础.

在数据库领域,关于如何设计数据库结构有很多理论,主要概念是规范化.规范化直接控制数据库的结构,并在某种程度上决定如何在数据库中排列实体.

在如何设计面向对象程序的结构方面是否有任何类似的概念？

我所要达到的是一个或多个潜在的理论原则,它自然地引导开发人员进入解决特定问题的"正确"设计.

我在哪里可以找到更多信息？
我应该读一下上班的工作吗？

更新:

感谢大家的回答.我正在阅读的内容似乎没有"OO设计的大理论",但是有一些重要的原则 - 主要是设计模式的例子.

再次感谢您的回答:)

我读过有关SOLID的文章但我没有看到OCP和DIP之间有任何区别.看看这个OCP的例子:

http://www.oodesign.com/open-close-principle.html

持有OCP的代码也满足DIP.任何人都可以给我一个持有OCP但不是DIP的代码示例吗？

我最近在很多代码中都注意到,人们在类/方法的深处放置了硬编码配置(如端口号等),这使得很难找到,也无法配置.

这违反了SOLID原则吗？如果没有,是否还有另一个"原则",我可以向我的团队成员介绍为什么这不是一个好主意？我不想只说"这很糟糕,因为我不喜欢它",但我很难想出一个好的论点.

我正在尝试使用Robert C. Martin原理ISP.

来自维基百科,

该ISP最初是由Robert C. Martin在为Xerox提供咨询时使用和制定的.施乐创建了一个新的打印机系统,可以执行各种任务,如装订和传真.该系统的软件是从头开始创建的.随着软件的发展,修改变得越来越困难,即使是最小的改变也需要一个小时的重新部署周期,这使得开发几乎不可能.

设计问题是几乎所有任务都使用了单个Job类.每当需要执行打印作业或装订作业时,都会对Job类进行调用.这导致了一个"胖"类,其中包含针对各种不同客户的多种方法.由于这种设计,主要作业将知道打印作业的所有方法,即使它们没有用处.

Martin建议的解决方案今天使用了所谓的接口隔离原理.应用于Xerox软件,使用依赖性倒置原则添加了Job类与其客户端之间的接口层.创建了一个Staple Job接口或一个Print Job接口,而不是一个大的Job类,它们分别由Staple或Print类使用,调用Job类的方法.因此,为每个作业类型创建了一个接口,这些接口都是由Job类实现的.

我想要了解的是how the system functioned and what Martin proposed to change it.

interface IJob
{
    bool DoPrintJob();
    bool DoStaplingJob();
    bool DoJob1();
    bool DoJob2();
    bool DoJob3();
}

class Job : IJob
{
  // implement all IJob methods here.
}

var printClient = new Job(); // a class implemeting IJob
printClient.DoPrintJob();  // but `printClient` also knows about DoStaplingJob(), DoJob1(), DoJob2(), DoJob3() also.

我可以尝试到这一点,并坚持到这里

an interface layer …

我是OOP的新手。最近，我读到了《里斯科夫替代原理》。

在下面给出的代码中，Square类继承了Give_Area。假设Square类与平方有关（例如有效性检查）。Give_Area给出正方形的面积（4个顶点在一个圆的周长上）和一个圆的面积。因此，如果给我一个Radius，我必须打印圆和正方形的区域（由放置在该圆的周长上的顶点组成）。为了得到一个圆的面积，我使用了一个参数。但是获取平方面积时没有参数。因此，我在这里做了重载。

#include<iostream>
#include<cmath>
using namespace std;

class Give_Area
{
    public:
    double Radius;

    double Area(double pi)
    {
        return pi*Radius*Radius;
    }

    double Area()
    {
        double temp = sqrt(2.0)*Radius;
        return temp*temp;
    }
};

class Square : public Give_Area
{
    public:
    bool Validity()
    {
        //checking validity
    }
};

int main()
{
    Give_Area* area = new Square();
    area->Radius = 3.0;
    cout<< "Area of Circle: " << area->Area(3.14159) <<endl;
    cout<< "Area of Square: " << …

使用SOLID原则特别是SRP,我们有很多类.
我的意思是,它就像你想要构建一个数据库类
那么,你有
DatabaseHandler类来处理数据库(选择,插入,更新,删除等),

DatabaseAdapter class是一个扩展的PDO类(可以在构造中设置首选的默认模式,一个新的prepare方法直接准备语句,将它与param绑定,然后执行它,

QueryBuilder类是SelectStatementBuilder类的父,InsertStatementBuilder类, DeleteStatementBuilder类,UpdateStatementBuilder类(用于构建SQLStatement),

Expression类,用于构建WHERE子句

SQLStatement Class中所需的表达式(其行为就像普通字符串,但其接口是SQLStatementInterface,因此我们可以知道它是一个SQL语句等.

而且,我知道如果我深入挖掘并重新进行重构,将会有更多的课程.

SRP原则实施是否导致了Lasagna代码？烤宽面条的代码好吗？

有一个这样的课:

class Application
{
    private Process _process; 

    private static string _applicationPath = string.Empty;

    public void Start(string arguments)
    {
        if (!File.Exists(_applicationPath))
            Deploy();
        _process = Process.Start(_applicationPath, arguments);
    }

    public void SomeMethod()
    {
        //method that manipulate _process
    }

    private void Deploy()
    {
        // copying, installation steps (takes some time) and assign _applicationPath
    }
}

1. 我使用静态字段是不是很糟糕？预计Application的其他实例将使用相同的_applicationPath.
2. 这是违反SRP原则(SOLID)的一个例子吗？我应该向其他班级提取"部署责任"吗？

我正在尝试制作开源缓存库.库的目的是提供将变量(可以是对象,可以是数组,可以是任何东西)存储到文件中然后在调用时检索它的方法.(通常那些变量值是大量数据库查询和计算的结果).

该项目的基本目标是实践面向对象的设计原则,称为实体.

如果任何人可以指出我违反固体原则的地方以及如何解决它

我完全理解stackoverflow不是代码编写服务,但是我正在使这个库开源,所以它会使我们的社区受益.

所以这是我的文件结构.

我是UML的新手,所以如果发现任何错误,请忽略

这是类的实现.

高速缓存

namespace library\pingle\cache;

use library\pingle\cache\config\CacheConfigurator;
use library\pingle\cache\file\FileHandler;

/**
 * @property CacheReader $cache_reader
 * @property CacheWriter $cache_write
 */
Class Cache {

    private $config;
    private $file_hander;
    private $cache_reader;
    private $cache_write;
    private $cache_directory;
    private $cache_kept_days;
    private $cache_file_prams;
    private $function_name;
    private $file_path;

    function __construct(CacheConfigurator $config) {
        $this->file_hander = new FileHandler();
        $this->config = $config;
        list($this->cache_directory, $this->function_name, $this->cache_kept_days, $this->cache_file_prams) = $this->config->getConfig();
        $this->file_path = $this->generateFileName($this->cache_file_prams);
    }

    public function read() {
        if (is_null($this->cache_reader)) {
            $this->cache_reader = new CacheReader($this->file_hander);
        }
        return $this->cache_reader->readCache($this->file_path); …

在java中,如果我们使用枚举并且最终我们想要从该枚举中添加/删除属性,因此它的用法,我们在实体原则中违反了开放/封闭原则.

如果是这样,枚举的更好用法是什么？

所以我想学习SOLID原理和依赖注入.我已经阅读了一些关于这个主题的博客文章,我开始明白了一点.但是,有一种情况我无法找到答案,并会尝试在此解释.

我已经开发了一个用于文本匹配的库,它包含一个Matcher具有调用函数的类,该函数Match将结果返回给MatchResult对象.此对象包含百分比,已用时间,是否成功等信息.现在从我在依赖注入中理解的是,高级别的类不应该"知道"关于低级别的类或模块.所以我已经设置了我的库和Matcher类来使用类的接口Matcher,这将允许我使用IoC容器注册它.但是,因为该函数返回一个MatchResult对象,所以"高级类"必须知道MatchResult违反DI规则的对象.

我该如何解决这个问题,建议的方法是什么？