Posso ter cópias diferentes de uma variável estática para cada tipo diferente de classe herdando

Question

Eu quero ter a mesma variável estática com um valor diferente, dependendo do tipo de classe.

Então, eu teria

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
{

}

E, em seguida, na minha página go programa:

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

Eu não quero para armazenar a mesma Sprite em cada instância da classe. Eu quero um para cada tipo de classe. Eu quero herdar a variável Sprite estática e a função de sorteio que vai chamar o sprite. Mas eu não quero que o Genstealer Sprite para substituir o sprite Marinha.

Isso é possível?

Como eu faria isso?

Answer 1

Use um método abstrato:

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

O Sprite retornado por getSprite pode ser uma estática, se quiser. coisas agradáveis ??sobre esta abordagem:

• Você não pode (facilmente) se esqueça de incluir um sprite na sua subclasse, uma vez que o compilador vai reclamar se você não implementar o método abstrato.

• É flexível. Suponha que um fuzileiro naval deve olhar diferente, uma vez que ele "níveis para cima". Basta alterar método getSprite da Marinha para levar o nível em conta.

• É o OO-idioma padrão para este tipo de coisa, então as pessoas que olham seu código não vai ficar coçando suas cabeças.

Answer 2

Não é possível para que possa ser estático na classe super. Essa variável estática na classe de super é compartilhado (efetivamente um singleton) por todos os sub classes. Toda vez que você mudar isso (digamos, por instanciar uma classe sub), que a mudança se reflete em todas as outras instâncias sub classe.

Em vez disso, fazer a estática Sprite nas subclasses, e depois usar a estrutura método descrito por Laurence.

Answer 3

Eu tive a mesma pergunta e chegou à solução para usar um mapeamento estático

Class -.> Objeto

O exemplo de código a seguir usa Integer como o tipo da variável desejada "class-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());
    } 
} 

A saída é:

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 isso ajude alguém. Por favor, seja gentil.

Answer 4

Então, faça um Sprite e dar variáveis ??de instância todos. Eles são apenas referências; pouco mais do que os ponteiros.

Answer 5

Um teste rápido irá mostrar-lhe que, sim, você pode substituir variáveis ??estáticas em subclasses.

Tenho juntos uma estrutura de herança simples para testar isso. StaticTest é o super de StaticTestSub. Ambos declaram ints estáticos TEST1, TEST2 e TEST3 com diferentes graus de acesso. Para simplificar o exemplo, eu deixei de fora a versão 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;
}

Você pode tentar isso em casa. O posto para fora foi:

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

Para as suas necessidades específicas, no entanto, eu recomendo a abordagem adoptada por Laurence Gonsalves