¿Puedo tener diferentes copias de una variable estática para cada tipo diferente de la clase que hereda

Question

Quiero tener la misma variable estática con un valor diferente dependiendo del tipo de clase.

Así que tendría

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
{

}

Y luego, en mi principal Go programa:

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

No quiero para almacenar el mismo en todos los sprites instancia de la clase. Quiero uno para cada tipo de clase. Quiero heredar la variable de sprites estática y la función de drenaje que se basará el sprite. Pero no quiero que el sprite Genstealer para anular el sprite marina.

¿Es esto posible?

¿Cómo iba a hacerlo?

Answer 1

Utilice un método abstracto:

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*/;
    }
}

El sprite devuelto por getSprite puede ser un estático si lo desea. cosas buenas de este enfoque:

• No se puede (fácilmente) se olvide de incluir un sprite en la subclase, ya que el compilador se quejará si no se implementa el método abstracto.

• Es flexible. Supongamos que un marino debería ser diferente una vez que "los niveles de arriba". Sólo cambia el método getSprite de Marina para tomar el nivel en cuenta.

• Es la OO-lenguaje estándar para este tipo de cosas, por lo que las personas que miran a su código no se dejará rascándose la cabeza.

Answer 2

No es posible para que sea estático en la superclase. Esa variable estática en la superclase es compartida (efectivamente un conjunto unitario) por todas las subclases. Cada vez que se cambia (por ejemplo, creando una instancia de una subclase), que el cambio se refleja en todas las otras instancias de la clase sub.

lugar, hacer el sprite estática en las subclases, y luego utilizar la estructura método descrito por Laurence.

Answer 3

Yo tenía la misma pregunta y llegué a la solución de utilizar una asignación estática

Clase -.> Objeto

El ejemplo de código siguiente utiliza entero como el tipo de la variable deseada "clase-estático".

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());
    } 
} 

La salida es:

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

Espero que esto ayude a alguien. Por favor bueno.

Answer 4

Así que una Sprite y dar a las variables de instancia todos. Ellos son sólo referencias; Apenas más de punteros.

Answer 5

Una prueba rápida se mostrará que, sí, puede anular las variables estáticas en las subclases.

He reunido una estructura de herencia simple de probar esto. StaticTest es el súper de StaticTestSub. Ambos declaran enteros estáticas TEST1, TEST2 y TEST3 con diferentes grados de acceso. Para simplificar el ejemplo, me he dejado la versión 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;
}

Usted puede intentar esto en casa. El apagada, era:

  

StaticTest.TEST1: 1 |   StaticTest.TEST2: 1 |   StaticTest.TEST3: 1 |   StaticTestSub.TEST1: 2
  StaticTestSub.TEST2: 2
  StaticTestSub.TEST3: 2

Para sus necesidades específicas, sin embargo, recomiendo el enfoque adoptado por Laurence Gonsalves