标签: object-oriented-analysis

为了好玩,我正在设计一个简单的系统来存储记录(黑胶唱片)数据和一些与记录有关的一般项目(袖子,记录清洁工等).

由于90%的数据将是黑胶唱片和其他10%的其他项目,我想把它们分成两类:记录和项目.请记住,尽管最后两者都是具有某些共同点的产品,如价格,数量等.

我怀疑是否应该创建一个抽象类,比如Item,以及两个扩展Item:Records和NonMusicalProducts的类.像这样的东西:

abstract class Item {

    static function getItemPrice($itemId, $type='record'){
        $result = 0;
        // query record table if type is record, otherwise query nonmusicalproduct table
        return $result;
    }

    abstract function getItemDetails();
}

而记录:

class Record extends Item {
    static function getItemDetails($id) {
        // query DB and return record details
    }
}

和NMProduct

class NMProduct extends Item {
    static function getItemDetails($id) {
        // query DB and return NMProduct details
    }
}

将NMProduct和Record中的两个方法定义为静态可以吗？我并不总是从一个对象访问该方法.

另一个选项是只有一个Item类和一个可以从item继承的Record类,但是我已经到了一个看起来不正确的点,特别是在尝试获取细节时:

class Item {
   function getItemDetails($id, $type){
        if …

UML中的序列图和通信(协作)图有什么区别？

我有一个定义一个方法的接口.此接口具有多个以不同方式实现该接口的类.

例如:

interface IJob {
  void DoSomething();
}

class SomeJob : IJob{
  public void DoSomething() {
    // Do something ...
  }
}

class AnotherJob : IJob {
  public void DoSomething() {
    // Do something ...
  }
}

...

我的工厂类将有一堆这些IF语句

if (some condition)
{
   IJob job = new SomeJob (); 
else
{
   IJob job = new AnotherJob (); 
}

有没有办法避免每次出现新情况时修改工厂类.这可以通过添加一个实现IJob的新类来完成吗？

编辑: [我想弄清楚Antiifcampaign的这些人正在尝试做什么]

谢谢你的时间...

在面向对象设计中,以下哪项更好？

使用以下方法发送参数:

obj.InsertRecord("raed","1987")

或使用以下属性:

obj.name= "raed"
obj.year= "1987"
obj.InsertRecord() 

class car{
    Salon s ;
}
class Salon{
     Radio musicsystem ;
}
class Radio{
    Button play ;
}
class Button{
     String s ;
}

void main(){
    car mustang = new car( new Salon( new Radio(new Button ("fight club song"))))
}

我很容易想象有很多新的(新的(新的(新的......))).你有多深？我"直觉地"觉得编译器/ jvm /系统有太多级别的对象可能会很糟糕......

java对深度有限制吗？

我是面向对象的 javascript 中的新手，并试图定义一个类，该类将数组作为数据成员。这个类的数据成员将另一个类的对象存储为数组。

这个例子会更清楚

function classA(id, objB_01)
{

    this.id = id;   // data member that store a simple value
    this.arrayname = objB_01  // How multiple instance of classB is stored in this array 


}

function classB( id, name, status)
{
     this.id = id;
     this.name = name;
     this.status = status 
}

objB_01 = new classB("01", "john", "single");
objB_02 = new classB("02", "smith" "single");
objB_03 = new classB("03", "nina", "married");

现在我的问题是我如何编写classA这样的单个实例来classA保存一个存储多个对象的数组classB

像这样的东西

objA = new classA("01",objB_01);
objA.arrayname …

我花了一天的时间试图找到这个问题的答案，但一无所获。

假设我有几个类，每个类都包含与其他类相同的方法。

class A:
    def __init__(self, attr1, attr2, color):
        self.__attr1 = attr1
        self.__attr2 = attr2
        self.__color = color

    def set_color(self, color):
        self.__color = color

class B:
    def __init__(name, attr3, attr4, color):
         self.__attr3 = attr3
         self.__attr4 = attr4
         self.__color = color

    def set_color(self, color):
        self.__color = color

在此示例中，相同的方法被简化为只有一个相同的方法 set_color，以说明我正在尝试执行的操作。

有没有办法消除重复代码，也许使用如下抽象类？

class Parent:
    def set_color(self, color):
        self.__color = color

class A(Parent):
    def __init__(self, attr1, attr2, color):
        self.__attr1 = attr1
        self.__attr2 = attr2
        self.__color = color


class B(Parent):
    def __init__(name, attr3, attr4, color): …

假设我的代码中已经有两个类:

class SomeOrder {
  String getOrderId() { return orderId; }
}

class AnotherOrder {
  String getOrderId() { return orderId; }
}

如何围绕这两个类创建一个接口:

interface Order {
    String getOrderId();
}

理想情况下,我将修改代码,以便SomOrder implements Order和AnotherOrder implements Order,但这里的前提条件是,他们在我无法控制或编辑一个包属于(即它们来自外部的jar).

我的算法目前看起来像这样:

void sorter(List<SomeOrder> orders) {
    ... <custom sort logic> ...
    someOrder.getOrderId();
}

void sorter(List<AnotherOrder> orders) {
    ... <custom sort logic> ...
    someOrder.getOrderId();
}

使用单一界面我可以写:

void sorter(List<Order> orders) {
        ... <custom sort logic> ...
        order.getOrderId();
}

我正在尝试为在线拍卖系统制作类图，但遇到了这个问题。出价属于拍卖和买方（如果我错了，请纠正我）。那么我可以说 User 由 bid 组成，而 racing 由 Bid 组成，或者这违反了 UML 规则？我很困惑

我想知道对于我的场景应该采用什么最好的OOP 设计模式。

场景：

我有两个班级，A 班和 B 班。我想将 ClassA 转换为新的 ClassB，但是 ClassA 可能会更改其成员变量和方法。这意味着可能必须更新 ClassA 转换为 ClassB 的方式。

促进从 ClassA 到新 ClassB 的转换的最佳 OOP 设计是什么？

目标：

创建一个设计模式，允许轻松更改将 ClassA 转换为 ClassB 的方式。

例子：

A级

public class ClassA {
    private String actionName;

    // With some getters & setters
}

B级

public class ClassB {
    private String action; // Note the subtle difference

    // With some getters & setters
}

处理程序

public class Handler {
    ClassB classB = new ClassB();

    // Convert ClassB to …