Variabili astratte in Java?

Question

Vengo da C# dove questo è stato facile e possibile.

ho questo codice:

public abstract class clsAbstractTable { 

    public abstract String TAG; 
    public abstract void init(); 

} 

ma Eclipse mi dice che uso modificatore di illegale.

ho questa classe:

public class clsContactGroups extends clsAbstractTable { 


} 

voglio la variabile e metodo definito in modo tale, che Eclipse a richieda me, ho non attuate astratti variabili e metodi.

Come è necessario definire la mia classe astratta, quindi è necessario che venga richiesto di implementare gli abstract?

EDIT 1

creerò classi diverse per le diverse tabelle di db. Ogni classe dovrebbe avere la propria variabile TABLENAME, nessuna eccezione. Devo assicurarmi che questa variabile sia statica ogni volta che creo una nuova classe che estende la classe astratta.

Quindi nella classe astratta avrò un metodo es .: init();

Se in questo metodo init() chiamo TABLENAME, dovrebbe prendere il valore dalla sottoclasse.

qualcosa come questo dovrebbe funzionare anche fuori

String tablename=(clsAbstract)objItem.TABLENAME; 
// where objItem can be any class that extended clsAbstract; 

EDIT 2

Voglio una costante (statica) definita in ogni classe ha il suo nome definito in astratto.

• Definisco la variabile TABLENAME in astratto, ma nessun valore dato.
• Creo un clsContactGroups, dovrei richiedere di implementare TABLENAME, questo è dove ottenere alcuni dati. es .: TABLENAME = "gruppi di contatti";
• Creo un clsContacts di seconda classe, dovrei richiedere di implementare TABLENAME, questo è dove ottenere alcuni dati. es .: TABLENAME = "contatti";
  ecc ...

Answer 1

Penso che la tua confusione sia con le proprietà C# rispetto a campi/variabili. In C# non è possibile definire campi astratti, anche in una classe astratta. Tuttavia, è possibile definire proprietà astratte poiché si tratta di metodi efficaci (ad esempio compilati in get_TAG() e set_TAG(...)).

Come alcuni hanno ricordato, non dovresti mai avere campi/variabili pubblici nelle tue classi, anche in C#. Diverse risposte hanno suggerito ciò che raccomanderei, ma non l'ho chiarito. Dovresti tradurre la tua idea in Java come una proprietà JavaBean, usando getTAG(). Allora le tue sottoclassi dovranno implementarlo (ho anche scritto un progetto con classi di tabelle che lo fanno).

Così si può avere una classe astratta definita come questo ...

public abstract class AbstractTable { 

    public abstract String getTag(); 
    public abstract void init(); 

    ... 
} 

Poi, in qualsiasi sottoclassi concrete si avrebbe bisogno di definire una variabile statica finale (costante) e restituire che dal getTag(), qualcosa in questo modo:

public class SalesTable extends AbstractTable { 

    private static final String TABLE_NAME = "Sales"; 

    public String getTag() { 
     return TABLE_NAME; 
    } 

    public void init() { 
     ... 
     String tableName = getTag(); 
     ... 
    } 

} 

EDIT:

campi

non è possibile sostituire ereditate (in C# o Java). Né puoi sovrascrivere i membri statici, che siano campi o metodi. Quindi anche questa è la soluzione migliore per questo. Ho modificato il mio esempio di metodo init in alto per mostrare come sarebbe stato usato, ancora una volta, pensiamo al metodo getXXX come a una proprietà.

Answer 2

Poiché non v'è alcuna implementazione di una variabile non può essere astratta;)

Answer 3

No, Java non supporta le variabili astratte. Non ha molto senso, neanche.

Quale modifica specifica alla "implementazione" di una variabile si aspetta che una sottoclasse faccia?

Quando ho una variabile abstractString nella classe base, cosa dovrebbe fare la sottoclasse per renderla non astratta?

Answer 4

Non esistono variabili astratte in Java (o C++).

Se la classe genitore ha una variabile e una classe figlio estende il genitore, il bambino non ha bisogno di implementare la variabile. Ha solo bisogno di accedere all'istanza del genitore. L'accesso get/set o protetto funzionerà.

"... quindi mi dovrebbe essere richiesto di implementare gli abstract"? Se estendi una classe astratta e non riesci ad implementare un metodo astratto, il compilatore ti dirà di implementarla o di contrassegnare la sottoclasse come astratta. Questo è tutto il suggerimento che otterrai.

Answer 5

Definire un costruttore nella classe astratta che imposta il campo in modo che le implementazioni concrete siano conformi alle specifiche richieste per chiamare/sovrascrivere il costruttore.

E.g.

public abstract class AbstractTable { 
    protected String name; 

    public AbstractTable(String name) { 
     this.name = name; 
    } 
} 

Quando si estende AbstractTable, la classe non compilerà finché non si aggiunge un costruttore che chiama super("somename").

public class ConcreteTable extends AbstractTable { 
    private static final String NAME = "concreteTable"; 

    public ConcreteTable() { 
     super(NAME); 
    } 
} 

In questo modo gli implementatori devono impostare name. In questo modo puoi anche eseguire controlli (nulli) nel costruttore della classe astratta per renderlo più robusto. Ad esempio:

public AbstractTable(String name) { 
    if (name == null) throw new NullPointerException("Name may not be null"); 
    this.name = name; 
} 

Answer 6

Basta aggiungere questo metodo per la classe di base

public abstract class clsAbstractTable { 

    public abstract String getTAG(); 
    public abstract void init(); 

} 

Ora ogni classe che estende la classe base (e non vuole essere astratto) dovrebbe fornire un TAG

È potrebbe anche andare con la risposta di BalusC

Answer 7

Il meglio che si possa fare è disporre di accessor/mutatori per la variabile.
Qualcosa come getTAG()
In questo modo tutte le classi di implementazione dovrebbero implementarle.

Le classi astratte vengono utilizzate per definire il comportamento astratto e non i dati.

Answer 8

Perché si desidera che tutte le sottoclassi definiscano la variabile? Se ogni sottoclasse dovrebbe averlo, basta definirlo nella superclasse. A proposito, dato che è buona pratica OOP non esporre campi comunque, la tua domanda ha ancora meno senso.

Answer 9

Modificare il codice a:

public abstract class clsAbstractTable { 
    protected String TAG; 
    public abstract void init(); 
} 

public class clsContactGroups extends clsAbstractTable { 
    public String doSomething() { 
    return TAG + "<something else>"; 
    } 
} 

In questo modo, tutte le classi che ereditano questa classe avrà questa variabile. Puoi fare 200 sottoclassi e ognuna di esse avrà questa variabile.

Nota a margine: non utilizzare CAPS come nome variabile; la saggezza comune è che tutti gli identificatori di maiuscole si riferiscono a costanti, cioè a parti di dati non modificabili.

Answer 10

Per aggiungere metadati per classe, forse un'annotazione potrebbe essere la strada giusta da percorrere.

Tuttavia, non è possibile imporre la presenza di un'annotazione nell'interfaccia, così come non è possibile applicare membri statici o l'esistenza di un costruttore specifico.

Answer 11

Esistono due modi per definire proprietà astratte in java senza contrassegnare una proprietà come astratta.

1 ° modo: Definire un costruttore con parametri nella classe astratta, qualcosa di simile:

public abstract class clsAbstractTable { 
     private String TAG; 
     public clsAbstractTable (String TAG) { 
      this.TAG= TAG; 
     } 
} 

Quando si definisce un costruttore parametrizzata in una classe astratta, le sottoclassi sono costretti a definire i propri costruttori e chiamata il super costruttore, quindi passa il proprio TAG.

2 ° modo: Definire la proprietà come metodo getter, qualcosa di simile:

public abstract class clsAbstractTable { 
    public abstract String getTAG(); 
} 

In questo modo il valore di TAG proprietà è delegata a essere definito da ciascuna classe concreta.

Fonte: Define an abstract property in java