[JAVA] utilizzo delle interfacce e delle estensioni

[nargra]

Cari amici sono un novellino del java.

ho un piccolo problemino che voi risolverete in meno di un minuto.

ho diverse classi di java che si basano su degli stessi metodi.
Tutto sembra semplice se creo una classe base che presenta questi metodi e faccio dalle classi che ho creato un estensione a questa classe base.

Il problema si presenta quando queste classi provengono già da una sottoclasse per esempio:

class Pippo extends JFrame {}

come faccio a estendere Pippo anche da ClasseBase? visto che in Java è possibile fare una sola estensione?

molti dicono che si devono utilizzare le interfacce...

ma come si fa?

grazie...

[Pablob]

Non credo che implementare una interfaccia sia una soluzione al tuo problema.

Infatti, le interfacce definiscono comportamenti che un oggetto può assumere, e possono essere comuni a più oggetti. Per esempio, il poter ricevere un input dal mouse, quindi "ascoltare" il mouse, è una interfaccia perché è un comportamento che può essere assunto dalla classe che ti pare, quando ti serve che risponda a un input del mouse. Ora, le interfacce contengono solamente metodi public abstract e variabili static final. Infatti, implementando una interfaccia, si DEVE obbligatoriamente fare l'overriding dei metodi.

Quindi, forse ti conviene, più che crearti un'interfaccia, fare in modo che una classe invece di estendere un'altra, la usi.
Per esempio, invece che

class Pippo extends JFrame{
//codice
}

potresti fare:

class Pippo extends QuelloCheTiPare{

    Pippo(){
         JFrame pippoFrame = new JFrame();
    }
}

in questo modo bypassi il problema.

Poi, se lo stai facendo per esercizio, è una buona occasione per prendere confidenza con le interfacce, ma quello è un altro discorso...

[battlehorse]

Le interfacce sono costruite per fare quello che dice il loro nome, forniscono un'interfaccia con cui una classe esterna puo' agire su tutte le classi che implementano l'interfaccia. Ok, mi spiego meglio :

se le classi A,B e C implementano l'interfaccia PIPPO che definisce i metodi PLUTO e PAPERINO, la classe D, che ha bisogno di PLUTO e PAPERINO, non ha bisogno di sapere quali sono le implementazioni specifiche di A,B e C per usare quei metodi, ma può farlo nello stesso modo per tutte e tre le classi usando un riferimento di interfaccia. Esempio :

... all'interno della classe A ...

A a = new A();
B b = new B();
C c = new C();
PIPPO rif_a_pippo; // creiamo un riferimento all'interfaccia

rif_a_pippo = a;
rif_a_pippo.PLUTO(); // *

rif_a_pippo = b;
rif_a_pippo.PLUTO();

rif_a_pippo = c;
rif_a_pippo.PLUTO();

Come puoi vedere, usando lo stesso modo e cioè la riga con l'asterisco, abbiamo chiamato il metodo PLUTO in tutte e tre le classi A,B e C seppure queste siano diverse tra loro.

Questo risolverebbe il tuo problema ( molte classi diverse che usano gli stessi metodi ) se non fosse che nelle interfacce puoi solo definire la firma dei metodi e non il codice che li compone. Es :

public interface PIPPO {
public String PLUTO(String argomento_uno,String argomento_due);
public String PAPERINO();
}

Come vedi, l'interfaccia definisce solo quali argomenti deve accettare e restituire un metodo, ma non qual e' il suo codice. Ciò significa che nel tuo caso dovresti comunque ripetere il codice in tutte le classi che usano gli stessi metodi.

Una soluzione puo' essere quella di creare una catena di estensioni. Ad esempio :

class PIPPO extends JFrame {
// codice che contiene i metodi che saranno usati in comune
// da molte classi
}

class A extends PIPPO {
// codice
}

class B extends PIPPO {
// codice
}

In questo modo sia A che B dispongono dei metodi di JFrame che dei metodi in comune, contenuti in PIPPO.

Ok ?

[lucke]

Scusate se m’intrometto nelle vostre disquisizioni ma ho notato che si sta ignorando completamente il vero problema cioè che nel paradigma degli oggetti l’ereditarietà va applicata in quei casi in cui si stia cercando di specificare (rendere più specifico) un determinato Oggetto e non va secondo me utilizzata assolutamente per utilizzare i metodi di diverse classi, talaltro possibilissimo creando un’istanza delle stesse. Probabilmente nel Java è stata tolta la possibilità dell’ereditarietà multipla (presente nel C++) per ovviare all’errore concettuale di creare Oggetti amorfi derivanti dall’unione di entità molto differenti fra loro.
Per quanto riguarda il tuo caso specifico utilizzare un’interfaccia per poi ridefinire ogni volta tutti i metodi mi sembra superfluo anche perché queste in genere sono utilizzate come nel caso mostrato nella risposta di “battlehorse” o più in generale per creare degli standard di implementazione da dover far rispettare a chi utilizza determinate librerie.
Mi scuso nuovamente dell’intrusione amerei sapere la vostra opinione sulla mia visione delle cose e se avete delle obiezioni o delle specificazioni da fare.

[battlehorse]

Sono d'accordo sul fatto che l'estensione di un oggetto dovrebbe essere effettuata per rendere l'oggetto più specifico, tuttavia in alcuni casi risulta difficile creare oggetti non amorfi.
Specialmente quando si ha a che fare con le interfacce grafiche, per molti aspetti e' più comodo estendere un oggetto Frame e similari, piuttosto che istanziarne uno all'interno delle proprie classi. Se poi i nostri oggetti sono già figli di qualcun altro per motivi loro, diventa quasi naturale arrivare ad avere oggetti "amorfi" e una sorta di ereditarietà a cascata in cui qualche classe della catena non c'entra molto con le altre.

Mi rendo conto che un discorso del genere è un po' vago. In effetti penso che molto dipenda dal caso di programmazione in cui ti vieni a trovare : a volte c'è un'alternativa elegante che rispetta il paradigma Java, altre volte c'è ma adottarla implica incasinare il tutto...

[nargra]

grazie a voi ho risolto parzialmente il problema.

La tecnica che ho adottato è quello di creare una classe ClasseBase che estende JFrame e poi tutte le classi future estendono questa nuova classe.

Però è presente una classe che di per se estende JDialog

io voglio che anche questa classe estende ClasseBase ma ClasseBase estende JFrame e non JDialog.

Come devo fare a comprendere il tutto?


grazie

[battlehorse]

Forse il problema si sta allargando un po' troppo. Se la tua classe ClasseBase, che contiene tutti i metodi che avranno in comune i vari eredi, e' applicabile sia al caso di una JFrame che di una JDialog, probabilmente rappresenta un oggetto che e' indipendente dal contesto grafico.

Forse si può implementare come oggetto separato, in modo da avere un codice più pulito. Spiegaci meglio cosa dovrebbe fare questa classe.

[nargra]

Ricapitoliamo:

ci sono dei metodi importanti per molte classi, che voglio conglobare tutti in un unica classe: ClasseBase.

Queste classi poi dovrebbero estendere poi ClasseBase.

Queste classi però gia estendono un altra classe:

per esempio una estende JDialog e una estende JFrame

come devo fare?

[lucke]

Probabilmente non ho afferrato il motivo per cui per utilizzare dei metodi di una classe tu la debba per forza ereditare e non semplicemente instanziare che nel caso dell'utilizzo dei metodi di ClasseBase dalle altre due sembra la soluzione migliore.

[hanoi]

Ciao a tutti!
potresti sempre dotare Classe_base di una variabile istanza che sia una JDialog; in questo modo avresti una classe con un oggetto "inglobato" che può svolgere le funzioni specifiche per cui è pensato. Certo, se ci spiegassi che cosa vuoi realizzare più nel dettaglio...