Java: Usando il metodo classe padre per accedere classe figlia variabile

Question

Ho il seguente scenario:

public class A { 

    private int x = 5; 

    public void print() 
    { 
     System.out.println(x); 
    } 
} 


public class B extends A { 

    private int x = 10; 

    /*public void print() 
    { 
     System.out.println(x);  
    }*/ 

    public static void main(String[] args) { 
     B b = new B(); 
     b.print(); 
    } 

} 

Sulla eseguire il codice, l'output è: 5.

Come accedere alla classe figlia (B del) variabile (x) tramite il metodo della classe genitore?

È possibile eseguire senza ignorando il metodo print() (cioè decommentandolo in B)?

[Questo è importante perché sulla sostituzione dovremo riscrivere l'intero codice per la stampa() il metodo di nuovo]

a cura

maggiori chiarimenti: -

• Il movente della domanda è di usare il valore di una variabile privata di classe figlio dal suo metodo di classe genitore. Ciò non richiede la modifica del valore della variabile privata della classe genitrice al fine di ottenere il risultato desiderato.
• Le risposte pubblicate qui, tuttavia, mi hanno portato alla mia risposta desiderata, che ho postato di seguito.

(Grazie a tutti per il vostro tempo e aiuto)

Answer 1

class A { 
    private int x = 5; 

    protected int getX() { 
     return x; 
    } 

    protected void setX(int x) { 
     this.x = x; 
    } 

    public void print() { 
     // getX() is used such that 
     // subclass overriding getX() can be reflected in print(); 
     System.out.println(getX()); 
    } 
} 

class B extends A { 
    public B() { 
     // setX(10); // perhaps set the X to 10 in constructor or in main 
    } 

    public static void main(String[] args) { 
     B b = new B(); 
     b.setX(10); 
     b.print(); 
    } 
} 

a cura

Qui di seguito è una risposta generale utilizzando classe astratta e il metodo per risolvere scenario simile:

abstract class SuperA { 
    protected abstract Object getObj(); 

    public void print() { 
     System.out.println(getObj()); 
    } 
} 

class A extends SuperA { 
    @Override 
    protected Object getObj() { 
     // Your implementation 
     return null; // return what you want 
    } 
} 

class B extends A { 
    @Override 
    protected Object getObj() { 
     // Your implementation 
     return null; // return what you want 
    } 

    public static void main(String[] args) { 
     B b = new B(); 
     b.print(); 
    } 
} 

Answer 2

Si dovrebbe esporre un getter per il valore che si desidera e ignorare che nella classe figlia.

Come così:

public class A { 

    private int x = 5; 

    public void print() 
    { 
     System.out.println(getX()); 
    } 

    protected void setX(int x) 
    { 
     this.x = x; 
    } 

    protected int getX() 
    { 
     return x; 
    } 

} 


public class B extends A { 

    /*public void print() 
    { 
     System.out.println(x);  
    }*/ 

    public B() 
    { 
     setX(10); 
    } 

    public static void main(String[] args) { 
     B b = new B(); 
     b.print(); 
    } 

} 

Answer 3

È sempre possibile aggiungerlo al costruttore:

public class B extends A { 

    //this line is unnecessary: private int x = 10; 

    /*public void print() 
    { 
     System.out.println(x);  
    }*/ 

    public B() 
    { 
     x=10; 
    } 


    public static void main(String[] args) { 
     B b = new B(); 
     b.print(); 
    } 

} 

Il motivo per cui non funzionerà come si prova è che i valori predefiniti solo vengono valutate una volta. Così, quando è di default 5 in A, rimane 5, anche se si è utilizzato di default 10 in B.

Answer 4

Dopo aver letto tutte le risposte pubblicate qui, ho ottenuto quello che stavo cercando. Quello che segue è quello che sento è la risposta migliore per la mia domanda:

public class A { 
    private int x = 5;  
    protected int getX(){ 
     return x; 
    }  
    public void print(){ 
     System.out.println(getX()); 
    } 
} 
public class B extends A { 
    private int x = 10; 
    protected int getX(){ 
     return x; 
    } 
    public static void main(String[] args) { 
     B b = new B(); 
     b.print(); 
    } 
} 

La creazione di un getter protetto e sovrascrivendo è meglio che l'override del metodo print() stessa, come ci potrebbe essere qualsiasi altro metodo enorme al posto del metodo di stampa che potrebbe aver bisogno di accedere al valore delle variabili di classe figlio.

Answer 5

Per risolvere la tua domanda devi definire i campi nella classe genitrice A come protetti (quindi sarà ereditato dalla classe figlio) e impostare il valore del campo x all'interno del costruttore nella classe figlio B. Il metodo di stampa è anche ereditato dalla classe A in modo da poterlo invocare direttamente dalla classe genitore.

Spero che questo possa aiutarti.

public class A 
{ 
    // fields declaration 
    protected int x = 5; 

    public void print() 
    { 
     System.out.println(x); 
    } 
} 



public class B extends A 
{ 

    public B() 
    { 
     // set child x value. The field have been defined in the parent class 
     x = 10; 
    } 

    public static void main(String[] args) 
    { 
     A a = new A(); 
     a.print(); // print 5 

     B b = new B(); 
     b.print(); // print 10 
    } 

}