为两个现有类实例设计适配器类的正确方法

本文关键字：适配器 方法 实例 两个 | 更新日期: 2023-09-27 18:18:30

假设，我有两个类RichMan和TaxiDriver的适配器类ManYouCanHit，它们都派生自Person。我只能访问RichMan或TaxiDriver的实例

public interface IManYouCanHit
{
    bool CanIHitThisGuy;
}
public class ManYouCanHit : IManYouCanHit
{
    private enum ManType
    {
        Rich = 0,
        TaxiDriver = 1
    }
    private RichMan richMan;
    private TaxiDriver driver;
    private ManType type;
    public Object ManReference
    {
        get
        {
            if(this.type == ManType.Rich)
            {
                return this.richMan;
            }
            else
            {
                return this.driver;
            }
        }
    }
    public bool CanIHitThisGuy
    {
        get{
            bool canHit = true;
            if(this.type == ManType.RichMan)
            {
                canHit = false;
            }
            return canHit;
        }
    }
    public ManYouCanHit(Person someone)
    {
        if(someone is RichMan)
        {
            this.richMan = someone;
            this.type = ManType.Rich;
        }
        else if(someone is TaxiDriver)
        {
            this.driver = someone;
            this.type = ManType.TaxiDriver;
        }
        else
        {
            // throw an error
        }
    }
}

实际的逻辑比示例复杂，有许多属性和方法要实现，如CanIHitThisGuy

是否可以将两个对象包装到一个适配器中?我还能遵循什么模式?

这个设计是好还是坏?你能给我一些建议吗?

我应该通过ManReference暴露原始对象吗?

为两个现有类实例设计适配器类的正确方法

是否可以将两个对象包装成一个适配器?

是的，如果你指的是两种类型的对象，你可以。不像你那样。你没有很好地使用OO。

我还可以遵循什么模式?

适配器模式很酷，如果它有意义，你应该使用它。但是，如果有更好的选择，那么只有你现在才能根据你提供的信息做出决定。

这个设计是好还是坏?

。

我应该通过ManReference暴露原始对象吗?

只有你知道。如果你担心，让它不可变。

你能给我一些建议吗?

我会这样重写:

public interface IManYouCanHit
{
    bool CanIHitThisGuy;
}
public class ManYouCanHit : IManYouCanHit
{
    public ManYouCanHit(Person someone)
    {
        if (!(someone is RichMan) && !(someone is TaxiDriver))
            throw;
        Man = someone;
    }
    public Person Man { get; private set; }
    public bool CanIHitThisGuy
    {
        get
        {
           //this is not good, better to have IsHittable property on Person class
           //so that you can return just Man.IsHittable
            return !(Man is RichMan);
        }
    }
}

在类中只需要Person引用，因为在构造函数中只接收一个人。如果有必要，仍然可以在构造函数中抛出异常。

似乎适合为每个ManType创建一个Person层次结构和一个子类。这将允许你摆脱ManYouCanHit类中的一些依赖，这些依赖表现为条件。

我的意思是，比起代码:

  public ManYouCanHit(Person someone)
    {
        if(someone is RichMan)
        {
            this.richMan = someone;
            this.type = ManType.Rich;
        }
        else if(someone is TaxiDriver)
        {
            this.driver = someone;
            this.type = ManType.TaxiDriver;
        }
        else
        {
            // throw an error
        }
    }

你会得到这样的SMTH:

public void ManYouCanHit(Person someone)
  {
        someone.CanHit();
  }

这使您在添加新类型的人或修改具体的人的行为时更容易。

相关文章：