8

我希望根据类的类型具有具有不同值的相同静态变量。

所以我会

public class Entity
{
     public static Bitmap sprite;

     public void draw(Canvas canvas, int x, int y)
     {
          canvas.drawBitmap(sprite, x, y, null);
     }
}

public class Marine extends Entity
{

}

public class Genestealer extends Entity
{

}

然后在我的主程序中去：

Marine.sprite = // Load sprite for all instances of Marine
Genestealer.sprite = // Load sprite for all instances of Genestealer

我不想在类的每个实例中存储相同的精灵。我想要一个用于每种类型的课程。我想继承静态精灵变量和绘制精灵的绘制函数。但我不希望 Genstealer 精灵覆盖 Marine 精灵。

这可能吗？

我该怎么做？

4

5 回答 5

14

使用抽象方法：

public class Entity
{
     public abstract Bitmap getSprite();

     public void draw(Canvas canvas, int x, int y)
     {
          canvas.drawBitmap(getSprite(), x, y, null);
     }
}

public class Marine extends Entity
{
    public Bitmap getSprite() {
        return /*the sprite*/;
    }
}

如果您愿意，getSprite 返回的精灵可以是静态的。这种方法的好处：

  • 你不能（轻易地）忘记在你的子类中包含一个精灵，因为如果你不实现抽象方法，编译器会抱怨。

  • 它很灵活。假设一名海军陆战队员“升级”后看起来应该有所不同。只需更改 Marine 的 getSprite 方法以将级别考虑在内。

  • 这是这类事情的标准 OO 习惯用法，因此查看他们的代码的人不会摸不着头脑。

于 2009-09-19T08:12:56.513 回答
2

我有同样的问题，并找到了使用静态映射的解决方案

类 --> 对象。

以下代码示例使用 Integer 作为所需“类静态”变量的类型。

import java.util.Map;
import java.util.HashMap;

class C
{
    static Map<Class<?>,  Integer> class2IntegerMap = new HashMap<Class<?>, Integer>();


    public void setClassSpecificInteger(Integer _i)
    {
        class2IntegerMap.put(this.getClass(), _i);
    }

    public Integer getClassSpecificInteger()
    {
        return class2IntegerMap.get(this.getClass());    
    }           
}

class CA extends C
{
}

class CB extends C
{
}

class CAA extends CA
{
}

public class MainClass
{
    public static void main(String []args)
    {
        CA a1 = new CA();
        CA a2 = new CA();
        CB b1 = new CB();
        CB b2 = new CB();
        CAA aa1 = new CAA();

        a1.setClassSpecificInteger(Integer.valueOf(-1));
        b1.setClassSpecificInteger(Integer.valueOf(+33));

        System.out.println("The int-value for a1 is: "+a1.getClassSpecificInteger());
        System.out.println("The int-value for b1 is: "+b1.getClassSpecificInteger());

        System.out.println("The int-value for aa1 is: "+aa1.getClassSpecificInteger());

        System.out.println("The int-value for a2 is: "+a2.getClassSpecificInteger());
        System.out.println("The int-value for b2 is: "+b2.getClassSpecificInteger());

        CA a3 = new CA();
        CB b3 = new CB();

        System.out.println("The int-value for a3 is: "+a3.getClassSpecificInteger());
        System.out.println("The int-value for b3 is: "+b3.getClassSpecificInteger());

        CAA aa2 = new CAA();

        aa2.setClassSpecificInteger(Integer.valueOf(8));

        System.out.println("The int-value for aa1 now is: "+aa1.getClassSpecificInteger());
    } 
}

输出是：

The int-value for a1 is: -1
The int-value for b1 is: 33
The int-value for aa1 is: null
The int-value for a2 is: -1
The int-value for b2 is: 33
The int-value for a3 is: -1
The int-value for b3 is: 33
The int-value for aa1 now is: 8

我希望这可以帮助别人。请善待。

于 2018-11-26T12:41:35.143 回答
1

它不可能在超类中是静态的。超类中的静态变量由所有子类共享（实际上是单例）。每当您更改它（例如，通过实例化子类），该更改都会反映在所有其他子类实例中。

相反，在子类中使精灵静态，然后使用劳伦斯描述的方法结构。

于 2009-09-19T16:06:35.867 回答
0

所以制作一个 Sprite 并给每个人实例变量。它们只是参考；几乎不超过指针。

于 2009-09-19T08:11:24.517 回答
-1

一个快速测试会告诉你，是的，你可以覆盖子类中的静态变量。

我整理了一个简单的继承结构来测试它。StaticTest 是 StaticTestSub 的上级。它们都声明静态 int TEST1、TEST2和 ，并 TEST3具有不同程度的访问权限。为了简化示例，我省略了private版本。 

public class StaticTest {
    public static int TEST1 = 1;
    protected static int TEST2 = 1;
    static int TEST3 = 1;

    public static void main(String[] args) {
            System.out.println("StaticTest.TEST1: " + StaticTest.TEST1);
            System.out.println("StaticTest.TEST2: " + StaticTest.TEST2);
            System.out.println("StaticTest.TEST3: " + StaticTest.TEST3);
            System.out.println("StaticTestSub.TEST1: " + StaticTestSub.TEST1);
            System.out.println("StaticTestSub.TEST2: " + StaticTestSub.TEST2);
            System.out.println("StaticTestSub.TEST3: " + StaticTestSub.TEST3);
    }
}


public class StaticTestSub extends StaticTest {
    public static int TEST1 = 2;
    protected static int TEST2 = 2;
    static int TEST3 = 2;
}

你可以在家里试试这个。输出是：

StaticTest.TEST1：1
StaticTest.TEST2：1
StaticTest.TEST3：1
StaticTestSub.TEST1：2
StaticTestSub.TEST2：2
StaticTestSub.TEST3：2

但是，对于您的特定需求，我推荐 Laurence Gonsalves 采用的方法

于 2009-09-19T14:09:49.920 回答