Newsgroup: it.comp.java
Titolo: Interfacce ed ereditarietà

salve ho qualche problema con interfacce ed ereditarietà;
in pratica non riesco a capire come vengono chiamati i metodi;
potreste dirmi se è giusto?
per richiamare i metodi conta quello la classe corrente dell'oggetto a
cui faccio riferimento
per le variabili è il tipo dichiarato per il riferimento
se però io ho due classi del genere
class P	{
		int a;
		boolean bool(int a){
				return this.a > a;
		}
}
class F extends P{
			private int b;
			boolean bool(int a, int b){
					return this.a > (a+b);
			}
			void cal(){
			}
}
e faccio P p=new F();
non posso richiamare attraverso p(che è un oggetto F) i metodi che non
sono anche in P; cioè se richiamo
boolean b=p.bool(1, 2);  non va bene perchè lui vuole metodo della
classe madre
p.cal();  non va bene perchè questo non c'è nella superclasse
per le interfacce vale discorso analogo tipo
Ispezionabile i=new ClasseCheImplementa();
posso richiamare da i solo metodi definiti nell'interfaccia sempre a
meno di cast espliciti
CONTA IL TIPO O IL RIFERIMENTO?non ci capisco + niente illuminatemi
Grazie a tutti

 CONTA IL TIPO O IL RIFERIMENTO?non ci capisco + niente illuminatemi
Tutti e due ;)
Lasciamo perdere le interfacce perché tanto sono sempre delle classi
concrete quelle di cui crei le istanze e quindi è su questi oggetti che
invochi i metodi.
Il riferimento conta perché non puoi invocare su un riferimento di tipo P un
metodo che non è definito in P. Però se invochi su un riferimento di tipo P
(sto parlando sempre di un riferimento di tipo P ad un oggetto di tipo F
cioè: P p = new F() ) un metodo che è ridefinito in F viene invocato il
metodo di F.
Esempio:
public class Ciao {
        public String toString() {
                return "Ciao";
        }
}
Object o = new Ciao();
System.out.println(o);
Stampa "Ciao". Cioè non viene invocato il toString() di Object ma quello
ridefinito in Ciao.
System.out.println(o) //Ciao ;)
Matteo

Ti rispondo in base alla mia limitata esperienza: credo (presuntoso!) che
ciò che ti dirò sia più o meno vero, anche se i termini tecnici che userò
saranno completamente sbagliati
Quando tu scrivi:
P p=new F();
tu crei una variabile di tipo P e gli assegni il riferimento ad un oggetto
F: dato che F estende P (quindi è anche di tipo P), lui non si lamenta...
vuole un ogetto P e tu quello gli dai (il fatto che sia _anche_ F è
irrilevante).
Da ora in poi quando ti riferisci a p stai trattando con un oggetto di tipo
P, e solo tu sai che quell'oggetto è _anche_ di tipo F: quindi su p puoi
accedere solo a metodi e proprietà di P, e non di F.
Questo è vero a meno che tu non dica esplicitamente che p non solo è di tipo
P (come è logico dato che il suo riferimento è in una variabile di tipo P),
ma è anche di tipo F: per farlo fai un cast di p su F (cast che non ti darà
errore solo nel caso che p sia davvero di tipo F). In questo modo stai
dicendo al compilatore: "tu credi che p sia di tipo P perchè io te l'ho
dichiarato tale, ma adesso ti garantisco che è anche di tipo F: credici e
permettimi di invocare su di lui i metodi di F, oltre che quelli di P"...
Spero di aver risposto ai tuoi dubbi...
Ciao
Giacomo
P.S. Per le interfacce è lo stesso: in generale, se non fai cast espliciti,
puoi richiamare solo metodi e proprietà del tipo dichiarato ( e nond i
quello "effettivo" dell'oggetto).