Posso ter cópias diferentes de uma variável estática para cada tipo diferente de classe herdando
-
11-09-2019 - |
Pergunta
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?
Solução
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.
Outras dicas
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.
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.
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.
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