标签: solid-principles

我总是尝试应用SOLID原则,我真的很喜欢Qt工具包,但我发现自己一直都在使用单继承规则.

如果使用多重继承,则moc假定第一个继承的类是QObject的子类. 另外,请确保只有第一个继承的类是QObject.

如何组合QObject规则和接口隔离原则的单一继承.
我想用信号和插槽定义接口,但我不允许这样做.

你如何解决这个缺点？

在数据库世界中,我们进行了规范化.您可以从设计开始,转动步骤并最终使用正常形式的数据库.这是基于数据的语义完成的,可以被认为是一系列设计重构.

在面向对象的设计中,我们拥有SOLID原则和各种其他特殊设计指南.

您是否认为可以为OO定义等效的正规形式,这样一系列重构步骤可以将程序性的代码片段(或者设计不当的OO设计)转换为正确的(在一些定义明确的意义上)相同的功能？

(NB.很高兴制作这个社区wiki)

我对DI中的几点感到困惑.让我解释一下:首先,依赖注入必须遵循依赖倒置原则吗？如果是这样,我们就不能将具体的类实例注入依赖.因为,此操作违反了DIP.让我们通过一个例子问我的问题:

public class Client {

private Service service; // Service is concrete class !

Client(Service service) {this.service = service;}
}

所以在这个例子中,依赖和依赖都是具体的.这违反了DIP原则,我们可以说这是依赖注入吗？在我的意见中,是的,我们可以.因为DI是所有对象创建,这些代码履行实际职责并从依赖中获取创建对象的操作.但同时它也没有遵循DIP.我在等你的想法:)先谢谢你的朋友.

我刚刚安装了Microsoft Code Contracts.它是.NET Framework和Visual Studio插件的一部分.它提供运行时检查和定义合同的静态检查.

该工具有四个警告级别,所以我设置最高.

我已经宣布了违反Liskov替代原则的课程.

public class Person
{
    protected int Age { get; set; }

    public Person(int age)
    {
        Contract.Requires(age > 0);
        Contract.Requires(age < 130);
        this.Age = age;
    }
}

public class Child : Person
{
    public Child(int age) : base(age)
    {
        Contract.Requires(age > 0); 
        Contract.Requires(age < Consts.AgeOfMajority);
        Contract.Requires(age < 130);
        this.Age = age;
    }
}

public static class Consts
{
    public readonly static int AgeOfMajority = 18;
}

LSP声明:

如果S是T的子类型,那么类型T的对象可以用类型S的对象替换而不改变该程序的任何所需属性

在我的例子中,违规将是这个对齐:Person person = new Child(23); …

我正在阅读有关SOLID原则的内容,我在这里停止了" 依赖性倒置原则" ,这意味着对象应该已经通过实例化到另一个对象,这意味着组合 不能应用依赖性倒置原则对吗？或者有什么我想念的？更新**************************************************假设你有一个类,这个类有一个引用anther对象的属性,我们有2个解决方案(对我来说):

1. 在类外创建对象并将其传递给类.(依赖项)
2. 在类中自己创建对象(组合).

谢谢.

所以我处在一种情况,我希望有一个包含要运行的类的对象数据库.它看起来像:

id  | Description       | pricingClass
1   | "static pricing"  | staticDeliveryPrice.class
2   | "Dynamic pricing" | dynamicDeliveryPrice.class

这样做的目的是允许我的编码灵活.我的想法是,这将允许多种方式来确定如何计算deliveryMethod的价格.

我担心的问题是,在这种情况下反映不好吗？有没有更好的方法呢？它是否遵循坚实的原则.(我会说是的,但我的一部分不同意).

我有java接口和类实现,在调用类似的行为时需要不同的参数.以下哪项最适合？

在第一个选项中,我有不同的类从基接口继承公共行为,所有差异只在类中直接实现,而不是在接口中实现.这个似乎最合适,但我必须在代码中进行手动类型转换.

public class VaryParam1 {

    static Map<VehicleType, Vehicle> list = new HashMap<>();

    static List<Car> carsList = new ArrayList<>();
    static List<TruckWithTrailer> trucksList = new ArrayList<>();

    public static void main(String[] args) {
        list.put(VehicleType.WITHOUT_TRAILER, new Car());
        list.put(VehicleType.WITH_TRAILER, new TruckWithTrailer());

        //violates LSP?
        ((Car)list.get(VehicleType.WITHOUT_TRAILER)).paint(1); //ok - but needed manual cast
        ((TruckWithTrailer)list.get(VehicleType.WITH_TRAILER)).paint(1, "1"); //ok - but needed manual cast

        carsList.add(new Car());
        trucksList.add(new TruckWithTrailer());

        //Does not violate LSP
        carsList.get(0).paint(1);
        trucksList.get(0).paint(1, "1");
    }
}

enum VehicleType {
    WITHOUT_TRAILER,
    WITH_TRAILER;
}

interface Vehicle{
    //definition of all common methods …

Arrayclass实现IList具有Add成员的接口.Array.Add调用抛出NotSupportedException.这是违反Liskov替代原则还是接口隔离原则或两者兼而有之？

我知道从C#7.0开始我们可以创建本地函数,但是如何通过SOLID原则来实现一个好的设计模型呢？

我的意思是,这不会破坏单一责任原则,在另一个功能中添加一个功能吗？

我们可以委托在另一个方法或另一个新类中计算这个简单的任务吗？而对于Open-Closed原则,它允许我继承SomeClass来修改它现在更复杂,我现在需要重写整个基函数而不仅仅是我的代码的一部分？

可能我们只需要重新编写方法的某些部分而不是改变它的整个功能.

我正在努力理解单一责任原则,但我很难掌握这个概念.我正在阅读"Lucian-Paul Torje的Java设计模式和最佳实践; Adrian Ianculescu; Kamalmeet Singh."

在本书中,我正在阅读单一责任原则章节,其中有一个汽车类,如下所示:

他们说Car拥有Car逻辑和数据库操作.将来,如果我们想要更改数据库,那么我们需要更改数据库逻辑,并且可能还需要更改汽车逻辑.反之亦然......

解决方案是创建两个类,如下所示:

我的问题是,即使我们创建了两个类,让我们考虑我们在CAR类中添加一个名为'price'的新属性[或者将属性'model'更改为'carModel']然后你认为我们还不需要更新CarDAO类就像改变SQL一样.

那么SRP在这里有什么用？