Posso avere diverse copie di una variabile statica per ogni diverso tipo di sottoclasse

Question

Io voglio avere la stessa variabile statica con un valore diverso a seconda del tipo di classe.

Così avrei

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 poi nel mio go programma principale:

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

Non voglio per memorizzare lo stesso sprite in ogni istanza della classe. Voglio uno per ogni tipo di classe. Voglio per ereditare la variabile sprite statica e la funzione di disegno che attirerà lo sprite. Ma non voglio che lo sprite Genstealer di ignorare lo sprite Marine.

È possibile?

Come potrei fare?

Answer 1

Utilizzare un metodo astratto:

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

Lo sprite restituito da getSprite può essere una statica, se volete. Cose belle di questo approccio:

• Non si può (facilmente) dimenticare di includere uno sprite nella sottoclasse, dal momento che il compilatore si lamenterà se non si implementa il metodo astratto.

• E 'flessibile. Supponiamo che un marine dovrebbe avere un aspetto diverso una volta che "i livelli di up". Basta cambiare il metodo di getSprite Marine di prendere il livello di conto.

• E 'il OO-linguaggio standard per questo genere di cose, così la gente a guardare il loro codice non saranno lasciati a grattarsi la testa.

Answer 2

Non è possibile per essere statica nella classe eccellente. Quella variabile statica nella classe Super è condivisa (effettivamente un Singleton) da tutte le classi secondarie. Ogni volta che si cambia che (ad esempio, per un'istanza di una classe secondaria), che il cambiamento si riflette in tutti gli altri casi sub di classe.

Invece, fare l'oggetto statico in sottoclassi, e quindi utilizzare la struttura metodo descritto da Laurence.

Answer 3

Ho avuto la stessa domanda ed è venuto alla soluzione di utilizzare un mapping statico

Class -.> Oggetto

Il seguente esempio di codice utilizza intero come il tipo di variabile desiderato "classe statica".

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

L'output è:

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

Spero che questo aiuta qualcuno. Si prega di essere gentile.

Answer 4

Quindi, fare una Sprite e dare variabili di istanza tutti. Sono solo i riferimenti; poco più di puntatori.

Answer 5

Un test rapido vi mostrerà che, sì, è possibile ignorare variabili statiche nelle sottoclassi.

ho messo insieme una semplice struttura di ereditarietà per testare questo. StaticTest è il super di StaticTestSub. Entrambi dichiarano int statici TEST1, TEST2, e TEST3 con vari gradi di accesso. Per semplificare l'esempio, ho lasciato la versione 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;
}

Si può provare questo a casa. Il messo fuori era:

  

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

Per le vostre esigenze specifiche, però, vi consiglio l'approccio adottato da Laurence Gonsalves