帮助构建对象模型

Question

请帮助我构建对象模型。

我需要代表游戏中每个军事单位的抽象类 Unit 。有 Soldier、Tank、Jet 和 Bunker（Unit 的子级）。它们每个都有 int 属性 Count 和 Defense，具有单个 int count 参数和一个方法 的构造函数获取全面防御。

我的想法如下。

private abstract class Unit
{
    private int Count { get; set; }
    private const int Defense = 0;

    protected Unit(int count)
    {
        Count = count;
    }

    public int GetTotalDefense()
    {
        return Count * Defense;
    }
}

private class Tank : Unit
{
    private const int Defense = 5;
}

每个单位都有不同的计数和不同的防御。构造函数的主体和 GetTotalDefense 的主体始终相同。 我需要是在子类重写Defense中，因为每个单位都有不同。该属性应该是常量，所有坦克实例（士兵，...）都具有相同的防御力。是否有可能继承 const 属性，或者每个孩子都需要自己的 const Defense 属性？

这是我想实现的一个例子。

哦，还有类 Troop

public class Troop
{
    private Soldier Soldiers { get; set; }
    private Tank Tanks { get; set; }
    private Jet Jets { get; set; }
    private Fort Forts { get; set; }

    public Troop(int soldiers, int tanks, int jets, int forts)
    {
        Soldiers = new Soldier(soldiers);
        Tanks = new Tank(tanks);
        Jets = new Jet(jets);
        Forts = new Fort(forts);
    }

    public int GetTotalDefense()
    {
        return Soldiers.GetTotalDefense() + Tanks.GetTotalDefense() + Jets.GetTotalDefense() + Forts.GetTotalDefense();
    }
}

另外，请随时提出更好的解决方案，谢谢。

PS：我对访问修饰符非常严格，所以你的例子要精确，谢谢。

Answer 1

您不能真正使用 const，但您可以创建只读属性，并且您确定希望这些类是私有的而不是内部或公共的吗？

public abstract class Unit { 

    protected Unit(int count) {
      Count=count;
    }

    protected int Count { get; private set; }
    protected abstract int Defense {get;}

    public int TotalDefense {
      get { return Count*Defense; }
    }

}

public class Tank : Unit {

   public Tank(int count) : base(count) {}

   protected override int Defense {
     get { return 5; }
   }
}

public class Troop {

   private Unit[] Troops;

   public Troop(int soldiers, int tanks, int jets, int forts) {
     Troops = new Unit[] {
                new Soldier(soldiers),
                new Tank(tanks),
                new Jet(jets),
                new Fort(forts)
              };
   }

   // The using System.Linq you can do
   public int TotalDefense {
     get { return Troops.Sum(x=>x.TotalDefense);}
   }
}

Answer 2

虽然这个解决方案没有使用const，但它实现了你想要的：

internal abstract class Unit
{
    private int Count { get; set; }
    private int Defense { get; set; }
    public int TotalDefense { get { return Count * Defense; } }

    protected Unit(int defense, int count)
    {
        Defense = defense;
        Count = count;
    }
}

internal class Tank : Unit
{
    protected Tank(int count)
        : base(5, count)  // you can use a const variable instead of 5
    {
    }
}

或者也许这更合适：

internal abstract class Unit 
{ 
    private int Count { get; set; } 
    public abstract int Defense { get; }
    public int TotalDefense { get { return Count * Defense; } }

    protected Unit(int count) 
    { 
        Count = count;
    }
} 

internal class Tank : Unit 
{
    override public int Defense { get { return 5; } }

    protected Tank(int count) : base(count)
    {
    } 
}

Answer 3

您正在寻找的实际上是readonly。另外，由于 Defense 在子类中使用，因此您需要将其设置为受保护的。

private abstract class Unit  
{  
    private int _Count;  
    protected readonly const int Defense;

    public int TotalDefense
    { get { return Count * Defense; } }

    protected Unit (int count, int defense)
    {
        Defense = defense;
        _Count = count;
    }
}  

private class Tank : Unit  
{
    public Tank (int Count)
        : base (Count, 5)
    { }        
}

public class Troop
{
    public IEnumerable<Unit> Units { get; protected set; }

    public Troop (int soldiers, int tanks, int jets, int forts)
    {
        Troops = new Unit[]
        {
            new Soldier (soldiers),
            new Tank (tanks),
            new Jet (jets),
            new Fort (forts)
        }
    }
}

Answer 4

也许是这样的（但这是在java中）

abstract class Unit {
    Unit(int defense,int count) {
        this.defense = defense;
        this.count=count;
    }
    final int defense;
    int count;
}
class Soldier extends Unit {
    Soldier(int count) {
        super(1,count);
    }
}
class Tank extends Unit {
    Tank(int count) {
        super(5,count);
    }
}
public class Main {
    public static void main(String[] args) {
        Unit[] units = { new Soldier(2), new Tank(3) };
        for(Unit unit:units)
            System.out.println(unit.count+" "+unit.defense);
    }
}