标签: object-oriented-analysis

有一个相同的概念Strategy Pattern和Inheritance,这样我就可以实现Strategy Pattern与Inheritance这听起来很简单和清晰比Strategy Pattern.

Startegy Pattern:

class IBase
{
public:
    virtual void processAction(void *data) = 0; // pure virtual
}

class Worker: public IBase
{
public:
    virtual void processAction(void *data)
    {
        // define logic
    }
}

Inheritance:

class Base
{
public:
    virtual void processAction(void *data) {}
}

class Worker: public Base
{
public:
    virtual void processAction(void *data) override
    {
        // define logic
    }
}

我的问题是它们之间有什么区别 …

什么是"进化发展方法论"在移动开发(Android)的背景下意味着什么？

与"面向对象的方法论"有什么相似之处吗？有人有一段代码示例吗？

您是否通常测量类方法比实例方法更快,因为它不需要加载实例？如果是这样,我们应该尽可能使用类方法吗？谢谢

据我所知,适配器和代理模式使两个不同/不同的类/对象与每个相互兼容以进行通信.它们都是结构模式.我发现他们两个都非常相似.

有人可以解释究竟是什么让他们与众不同？

编辑:我经历了这个问题.但我更愿意在Adapter和Proxy之间进行密切的比较.

我目前正在设计一个需要管理某个硬件设置的软件.

硬件设置如下:

系统 - 系统包含两个相同的设备,并具有相对于整个系统的某些功能.

设备 - 每个设备包含两个相同的子设备,并且具有相对于两个子设备的某些功能.

子设备 - 每个子设备有4个可配置实体(通过相同的硬件命令控制 - 因此我不将它们视为子子设备).

我想要实现的目标:

我想通过系统管理器控制所有可配置实体(实体以串行方式计数),这意味着我可以执行以下操作:

system_instance = system_manager_class(some_params)
system_instance.some_func(0) # configure device_manager[0].sub_device_manager[0].entity[0]
system_instance.some_func(5) # configure device_manager[0].sub_device_manager[1].entity[1]
system_instance.some_func(8) # configure device_manager[1].sub_device_manager[1].entity[0]

我想到的是:

我正在考虑创建一个抽象类,它包含所有子设备函数(调用转换函数)并让system_manager,device_manager和sub_device_manager继承它.因此,所有类都将具有相同的函数名称,我将能够通过系统管理器访问它们.围绕这些线的东西:

class abs_sub_device():
    @staticmethod
    def convert_entity(self):
        sub_manager = None
        sub_entity_num = None
        pass

    def set_entity_to_2(entity_num):
        sub_manager, sub_manager_entity_num = self.convert_entity(entity_num)
        sub_manager.some_func(sub_manager_entity_num)


class system_manager(abs_sub_device):
    def __init__(self):
        self.device_manager_list = [] # Initiliaze device list
        self.device_manager_list.append(device_manager())
        self.device_manager_list.append(device_manager())

    def convert_entity(self, entity_num):
        relevant_device_manager = self.device_manager_list[entity_num // 4]
        relevant_entity         = entity_num % 4
        return relevant_device_manage, relevant_entity …

可以说我有两个接口A和接口B:

public interface A {
  public int data();
}

public interface B {
  public char data();
}

接口A有一个方法public int data(),接口B有一个方法public char data().

当我在某个C类中实现接口A和B时,编译器给出了一个错误.这是java中的一个缺陷吗？我认为这是我们不允许扩展多个类的主要原因之一,那么当这个问题仍然存在时,为什么我们允许实现多个接口呢？

设计模式代表了经验丰富的面向对象软件开发人员使用的最佳实践.设计模式是软件开发人员在软件开发过程中遇到的一般问题的解决方

设计模式有三种基本类型:

1.Structural

2.Creational

3.Behavioral

不同的设计模式有1. MVC 2. Singlton 3.工厂方法4.懒惰初始化等

我一直在寻找哪种设计模式适合Android.一些帖子说android是基于MVC而其他人说没有.

那么任何人都可以指导我支持哪种设计模式或适合Android应用程序.

我对面向对象编程非常陌生，并且正在尝试通过制作一个简单的纸牌游戏（似乎是传统的！）来开始学习 Python。我已经完成了以下工作正常的示例，并教我如何PlayingCard()创建类的多个实例以创建类的实例Deck()：

class PlayingCard(object):
    def __init__(self, suit, val):
        self.suit = suit
        self.value = val

    def print_card(self):
        print("{} of {}".format(self.value, self.suit))

class Deck(object):
    def __init__(self):
        self.playingcards = []
        self.build()

    def build(self):
        for s in ["Spades", "Clubs", "Diamonds", "Hearts"]:
            for v in range(1,14):
                self.playingcards.append(PlayingCard(s,v))

deck = Deck()

我现在想用更复杂的卡片制作一些东西，而不仅仅是标准的 52 副牌（它有很好的递增值）。我想到的牌组是大富翁纸牌游戏：

卡片有 3 种基本类型 - 行动卡片、财产卡片和金钱卡片。动作卡执行不同的动作，属性卡属于不同的颜色组，钱卡可以有不同的值。此外，属性卡可以是“通配符”，并且可以用作两组之一的一部分。最后，每张卡还具有等值的货币价值（在每张卡的顶角标明）。在租金行动卡中，该卡只能适用于卡上标明的颜色属性。

我的问题通常是如何处理这样的情况，以及将这些不同的卡片包含在基于类的 Python 程序中的好方法是什么？我应该保留我的单一PlayingCard()课程，并且只有很多输入，例如PlayingCard(type="PROPERTY", value="3M"). 还是会更好地创建单独的类，如ActionPlayingCard()，PropertyPlayingCard()等？或者，还有更好的方法？正如我所说，我刚刚开始在这里学习，以及如何根据更高级别的设计来组织这些类型的情况。

非常感谢。

有人可以解释一下复合设计模式的真实例子吗？

我的方案是关于开发数学问题.作为一个IProblem接口,我认为它应该包含的两个主要属性是QuestionText和Response.QuestionTextalways总是一个字符串,但Response有时可以是一个复杂的对象(一个自定义的Fractionstruc)或另一个数据类型,如string,decimal,int等.

    public interface IProblem
    {
        string QuestionText { get; set; }
        object Response { get; }

        bool IsComplete();
        bool IsCorrect();
    }

如你所见,Response是对象.我猜这个数据类型,因为所有问题本质上都有一个响应.因为它是一个对象,我只定义了未来的错误(投射问题).

我的想法是稍后,在具体类中访问此属性(Response),而无需强制转换.看看这个？

    public abstract class Problem : IProblem
    {
        public string QuestionText { get; set;}
        public object Response { get; protected set; } 
        public virtual bool IsComplete()
        {
            return true;
        }
        public abstract bool IsCorrect();
    }

    public class BinaryProblem : Problem
    {
        public …