Newsgroup: it.comp.java
Titolo: Interface ed ereditarieta' mulptipla...


Subject: Itinerario al Pesto
Content-Type: text/plain; charset=us-ascii
Content-Transfer-Encoding: 7bit
Ciao,
Ho cercato di inventarmi un percorso con un buon rapporto
tempo/godimento
        Sabato:
        Se arrivate al mattino, massimo, alle 10:00
                Funicolare sul Righi
        Se arrivate al mattino, alle 12:00
                Porto Antico, Carruggi/negozietti convenienti
                Mangiare Al Gran Ristoro (non credetevi chissa' cosa)
                Gelato a Boccadasse o Nervi, passeggiata, Parco.
                Visita a Bogliasco, Sori.
        Se sono le 17:00 Panorama del Tipico o in terrazza a
S.Appollinare,
notte dal Pirata.
        Altrimenti 2 aternative: vedi sotto.
        Domenica:
                Rapallo, Paraggi, Portofino con Paciugo, castello.
                Camogli, eventualmente via Zoagli.
                Spuntino e mare in prua fino a S.Fruttuoso, ritorno.
                Se state a cena 2 aternative: vedi sotto.               
Alternative:    
Recco: Passeggiata alla rovescia e focaccia al formaggio alle 4 Vele.
S.Levante: Tramonto UnforgettablE, seduti alla panca specialita' "alla
buona"
dalla Mattana.
Non ve ne dimenticherete....
Ciao
Andrea

 writes:
AR> Non riesco proprio.
AR> Le ho utilizzate ma non le ho capite.
Per  quel  che   ne  so  io,  demigod  Gosling   ha  voluto  escludere
l'ereditarietà multipla  per evitare che data  una classe A  da cui si
derivano una classe B ed una classe C che implementino in modo diverso
un metodo virtuale  pippo(), si abbiano problemi del  tipo "e ora cosa
uso ?" in situazione in cui una classe D, che eredita da B e da C, usi
D.pippo() senza averla implementata lei stessa.
Gosling parla  di "pura progettazione"  al contrario delle  classi che
sono "progettazione ed implementazione".
Un interfaccia è un contratto che una classe si impegna a rispettare.
class pippo extends pluto implements paperino
indica che faccio una subclasse di pluto che si impegna ad avere tutti
i metodi  definiti nell'interfaccia paperino (dalla  quale non eredita
alcuna implementazione).
AR> Ho cercato su Dejanews, prima di scrivere qui, ma risposte non ne ho
AR> trovate.
AR> Mi spiego:
AR> classe Motore
AR>    int candele
AR>    int pistoni
AR> classe Carrozzeria
AR>   int colore
AR>   int fari
AR> Di queste 2 ora farei una Vespa, un Auto e un Camion.
AR> Ma non posso derivare Carrozzeria da Motore, perche' la prima me la fa
AR> il carrozziere, la seconda il tabaccaio sotto casa (questa si che e'
AR> astrazione).
Credo che il metodo migliore sia :
abstract class veicolo 
	implements motore
	implements fari {
	...
}
abstract class camion extends veicolo{
	...
}
...
abstract class scooter extends veicolo{
...
	/* scooter generico */
}
class vespa extends scooter {
/* particolarizzo la vespa */
}
class lambretta extens scooter {
/* e la lambretta */
}
Alla fine hai qualcosa che assomiglia all'ereditarietà multipla ma non
lo è.
Perdonare gli errori, quanto sopra è "tanto al chilo, tanto al braccio..."
\begin{avviso}
 
Attenzione: rispondo ad ogni invio  di pubblicità non richiesta o spam
di qualsiasi  altro genere con  un messaggio al provider  di competen-
za.  Ai sensi  della  legge sulla  privacy  NON avete  il permesso  di
utilizzare i miei dati per questi scopi.
\end{avviso}
+----------------------------------------------------------------+
| Gian Uberto Lauri * "So, are you working on fixing that bug    |
| 
sa...@eng.it
      *  *now* or leaving it until later ?" - YES  |
+----------------------------------------------------------------+

Puoi fare
class Vespa extends Motore implements Carrozzeria
ed usare i metodi dell'interfaccia e della classe padre.
Alfredo

 Ha senso?
Ciao, purtroppo quello che scrivi non ha senso. Pero' non so se hai
semplicemente scritto una cosa sbagliata pensando a quella giusta, per
distrazione, o se veramente hai le idee piuttosto confuse.
Infatti nel codice ipotetico che tu scrivi metti:
Lambretta.fari(2);
che significa "invoco sull'oggetto Lambretta il metodo fari della classe
Vespa, passandogli come parametro 2". Dunque, nella classe Vespa
dovresti avere definito un *metodo* fari, per es. 
public void fari(int x) {
  luceFari=x;
}
Invece fari e' una variabile di classe, per come hai scritto tu le
classi, per cui per modificarne il valore dovresti scrivere:
Lambretta.fari=2;
posto che tu abbia definito la variabile public (che cmq in
programmazione a oggetti non si dovrebbe fare).
In conclusione, mi sembra che ancora tu abbia le idee un po' confuse.
Comunque, l'ereditarieta' multipla e' una tecnica con cui una classe
puo' ereditare da piu' sopraclassi, avendo cosi' le caratteristiche di
entrambe.
Il C++ la supporta, ma ci sono vari problemi: bisogna saperla usare o si
rischiano sfracelli.
Java, nella sua opera di semplificazione, ha eliminato alcune
caratteristiche dei linguaggi orientati ad oggetti, fra cui
l'ereditarieta' multipla.
In Java una classe puo' ereditare da una sola superclasse e da piu'
interfacce, le quali specificano solo che la classe deve implementare
alcuni metodi.
Pero' veramente non riesco a spiegarti la cosa in due balletti. Ti
consiglio di leggere un qualche libro dedicato piu' che a Java alla
programmazione a oggetti.
Uno che reputo molto valido e che mi ha aperto gli occhi e' Object
Oriented Programming in C++ and Java, di Cay S. Horstmann.
In verita' e' orientato soprattutto sul C++, pero' spiega piuttosto bene
la programmazione a oggetti.
-- 
Tommaso Paba
Togli ".no-spam." per rispondere (se c'e')
http://spazioweb.inwind.it/pabasoftware

// Ci sono.....Ci sono!!!
// Prima scrivo la classe Arance...
public class Arance {
   public void MetodoDiArance() {     System.out.println("Dentro ad
Arance");   }
}
// Poi scrivo la classe Cachi...
public class Cachi implements CondivC {
   // Aggiungendo "implements CondivC" Cachi vuole rendere condivisibili
i suoi metodi.
   public void MetodoDiCachi() {
        System.out.println("Dentro a  Cachi");
   }
}
// Poi scrivo l'interfaccia con tutti i metodi di Cachi...
public interface CondivC {   public void MetodoDiCachi(); }
// Poi scrivo la classe che incolla...
public class Banane extends Arance implements CondivC {
   CondivC riferimento;
   public Banane(CondivC riferimento) {
      this.riferimento=riferimento;
   }
   public void MetodoDiCachi() {
      riferimento.MetodoDiCachi();
   }
}
// A questo punto uso le Banane per i miei scopi...
public class Principale {
   public static void main(String arg[]) {
   Cachi ObjC = new Cachi();
   Banane ObjB = new Banane(ObjC);
// Questo e' il risultato della grande fatica
   ObjB.MetodoDiArance();
   ObjB.MetodoDiCachi();
// ------------------------------------------
   }
}
Risultato:
 Dentro ad Arance
 Dentro a  Cachi
Scusate la lunghezza.... Ma che ve ne pare? 


Scusate la lunghezza.... Ma che ve ne pare? 
Convoluto. :)
-- 
God is Real, unless declared Integer.
ObjectZone - 
http://space.tin.it/computer/csadun


Però erediti solo da Motors e devi riscrivere i metodi di Carozzeria,
che non è bello.
-- 
Dr. Ugo Gagliardelli, Modena, Italy
Spaccamaroni andate a cagare/Spammers not welcome

Non avevo mai visto la dichiarazione implements doppia nelle classi.
Finalmente un nuovo modo per evitare la cavolata ,.
Grazie.