Chiama un metodo di sottoclass in Java

Se ho una base di Base thing = null; di cui esiste una class Subclass extends Base sottoclass class Subclass extends Base e io l’istigado come thing = new Subclass come potrei chiamare un metodo che è specificamente in sottoclass, ma non in base? ex. Base ha solo method() Subclass ha method() e specialMethod() il metodo specialMethod() è quello che voglio chiamare.

Gli altri hanno già menzionato come lanciare oggetti per ottenere una risposta alla tua domanda, ma ponendo questa domanda in primo luogo indica un ansible problema di progettazione. Alcuni possibili motivi:

  • Il metodo è nel posto sbagliato.
  • Il codice che chiama il metodo è nel posto sbagliato.
  • La sottoclass non dovrebbe estendere l’altra class. È preferibile preferire la composizione all’eredità . E quando si eredita, il codice dovrebbe seguire il principio di sostituzione di Liskov .
  • Le classi non sono coese , hanno più di una responsabilità e dovrebbero essere suddivise in più classi.

Se sai che quella thing contiene una Subclass , puoi fare:

 ((Subclass) thing).specialMethod() 

Devi cast per poter invocare il metodo:

 Base thing = new SubClass(); ((SubClass) thing ).specialMethod(); 

Se affronti questa situazione, molto probabilmente non hai l’interfaccia giusta (il giusto insieme di metodi)

Prima di andare in profondità nella fase in cui inizi a convalidare tutto per sapere se puoi invocare un metodo o meno come in:

  public void x ( Base thing ) { if( thing.instanceof Subclass ) { ((SubClass)thing).specialMethod(); } } 

Considerare se non è necessario spostare il specialMethod nella gerarchia in modo che appartenga alla base.

Se sicuramente non ne hai bisogno nella base, ma ne hai bisogno nella sottoclass, almeno considera di usare il tipo corretto:

  SubClass thing = ... // no need to cast thing.specialMethod(); 

Ma come sempre, questo dipende da cosa stai cercando di fare.

Quando si tratta dell’ereditarietà / polimorfismo in Java ci sono fondamentalmente due tipi di calchi che vedi:

upcasting:

 Superclass x = new Subclass(); 

Questo è implicito e non ha bisogno di un cast duro perché Java sa che tutto ciò che la Superclass può fare, la Subclass può fare altrettanto.

downcasting

 Superclass x = new Subclass(); Subclass y = (Subclass) x; 

In questo caso è necessario eseguire un cast rigido poiché Java non è sicuro che funzioni o meno. Devi confortarlo dicendo che sai cosa stai facendo. La ragione di ciò è perché la sottoclass potrebbe avere alcuni metodi strani che la superclass non ha.

In generale, se vuoi istanziare una class per chiamare qualcosa nella sua sottoclass, dovresti probabilmente creare un’istanza della sottoclass per iniziare – o determinare se il metodo dovrebbe essere nella superclass.

Devi digitare o eseguire il cast della sottoclass. Così:

  Subclass thing = new Subclass(); 

o:

  ((Subclass) thing).specialMethod(); 

Un altro approccio potrebbe essere quello di fare quanto segue:

 public abstract class Base { //method() not implemented public abstract void specialMethod(); } public class Subclass extends Base { //method() not implemented @Override public void specialMethod() { //put your code here System.out.println("specialMethod from Subclass"); } } 

Quindi puoi fare:

 thing.specialMethod(); 

e ti darà: “specialMethod from Subclass”.