In Java, perché non posso dichiarare un membro finale (senza inizializzarlo) nella classe genitore e impostare il suo valore nella sottoclasse? Come posso lavorare intorno?

Question

In un programma Java, ho più sottoclassi che ereditano da un genitore (che è astratto). Volevo esprimere che ogni bambino dovrebbe avere un membro impostato una sola volta (cosa che stavo pensando di fare dal costruttore). Il mio piano era di codificare s.th. In questo modo:

public abstract class Parent { 
    protected final String birthmark; 
} 

public class Child extends Parent { 
    public Child(String s) { 
     this.birthmark = s; 
    } 
} 

Tuttavia, questo sembra non piacere agli dei Java. Nella classe genitore, ricevo il messaggio che "birthmark" potrebbe non essere stato inizializzato ", nella classe figlia ottengo" Non è possibile accedere al campo finale birthmark ".

Quindi qual è il modo Java per questo? Cosa mi manca?

Answer 1

Non puoi farlo perché mentre confrontando la classe padre, il compilatore non può essere sicuri che la sottoclasse si inizializza. Dovrete inizializzare nel costruttore del genitore, e avere il bambino chiamata al costruttore del genitore:

public abstract class Parent { 
    protected final String birthmark; 
    protected Parent(String s) { 
     birthmark = s; 
    } 
} 

public class Child extends Parent { 
    public Child(String s) { 
     super(s); 
     ... 
    } 
} 

Answer 2

passarlo al costruttore genitore:

public abstract class Parent { 
    private final String birthmark; 
    public Parent(String s) { 
     birthmark = s; 
    } 
} 

public class Child extends Parent { 
    public Child(String s) { 
     super(s); 
    } 
} 

Answer 3

Un altro modo Java-ish per fare questo è probabilmente di avere la classe padre per definire un abstract "getter" e farli implementare dai bambini. Non è un ottimo modo per farlo in questo caso, ma in alcuni casi può essere esattamente quello che vuoi.

Answer 4

Sì, i membri finali devono essere assegnati nella classe in cui sono dichiarati. È necessario aggiungere un costruttore con un argomento String a Parent.

Answer 5

Dichiarare un costruttore nella superclasse chiamata dalla sottoclasse. È necessario impostare il campo nella superclasse per assicurarsi che sia inizializzato, altrimenti il ​​compilatore non può essere sicuro che il campo sia inizializzato.

Answer 6

Probabilmente si desidera avere un costruttore Parent (String birthmark) in modo da poter garantire nella classe Parent che final sia sempre inizializzato. Quindi puoi chiamare super (birthmark) dal tuo costruttore Child().

Answer 7

Perché non delegare l'inizializzazione a un metodo. Quindi sovrascrivere il metodo nella classe genitore.

public class Parent { 
    public final Object x = getValueOfX(); 
    public Object getValueOfX() { 
     return y; 
    } 
} 
public class Child { 
    @Override 
    public Object getValueOfX() { 
    // whatever ... 
    } 
} 

Ciò dovrebbe consentire l'inizializzazione personalizzata.

Answer 8

farei così:

public abstract class Parent 
{ 
    protected final String birthmark; 

    protected Parent(final String mark) 
    { 
     // only if this makes sense. 
     if(mark == null) 
     { 
      throw new IllegalArgumentException("mark cannot be null"); 
     } 

     birthmark = mark; 
    } 
} 

public class Child 
    extends Parent 
{ 
    public Child(final String s) 
    { 
     super(s); 
    } 
} 

finale significa che la variabile può essere inizializzata una volta per esempio. Il compilatore non è in grado di assicurarsi che ogni sottoclasse fornisca l'assegnazione alla voglia, in modo che imponga l'assegnazione nel costruttore della classe genitore.

Ho aggiunto il controllo per null solo per mostrare che si ottiene anche il vantaggio di poter controllare gli argomenti in un posto piuttosto che ogni cosntructor.