[JAVA] Comportamento in Overloading + Overriding

[Print]

Ecco il codice incriminato:

public class SuperClass {
private int value;
public void method(SuperClass p){
this.value+=p.value;
System.out.println("Super method");
}
public void addValue(int v){
value+=v;
}
public int getValue(){
return value;
}
}

public class SubClass extends SuperClass {
public void method(SuperClass p){
this.addValue(10);
System.out.println("Sub method 2");
}
public void method (SubClass p){
super.method(p);
this.addValue(4);
System.out.println("Sub method");
}
public void method (SuperClass p){
super.method(p);
this.addValue(4);
System.out.println("Sub method");
}
}

public class Example {
public static void main(String [] args){
SuperClass o1, o2;
SubClass o3;
o1=new SuperClass();
o2=new SubClass();
o3=new SubClass();
o1.method(o2); System.out.println("1st result: "+o1.getValue());
o2.method(o2); System.out.println("2st result: "+o2.getValue());
o2.method(o1); System.out.println("3st result: "+o2.getValue());
o2.method(o3); System.out.println("4st result: "+o2.getValue());
o3.method(o1); System.out.println("5st result: "+o3.getValue());
o3.method(o3); System.out.println("6st result: "+o3.getValue());
o3.method(o2); System.out.println("7st result: "+o3.getValue());
}
}

Eseguendo ho il seguente output:

Super method
1st result: 0
Sub method 2
2st result: 10
Sub method 2
3st result: 20
Sub method 2
4st result: 30
Sub method 2
5st result: 10
Super method
Sub method
6st result: 24
Sub method 2
7st result: 34
--------------

La mia domanda è: Come mai quando da o2 chiamo method(), sia in overload sia in overriding,
viene eseguito sempre il metodo che al suo interno ha "Sub method 2"?
Come fa il compilatore a decidere quale metodo chiamare?
Ho già cercato della documentazione a riguardo ma nonho trovato nulla,
qualcuno sa dove posso trovare qualcosa che spieghi questo caso particolare?

Ringrazio chi saprà aiutarmi

[banryu79]

Usiamo il benedetto tag CODE per postare il codice (l'ho identato a mio piacere):

public class SuperClass
{
private int value;

public void method(SuperClass p)
{
this.value+=p.value;
System.out.println("Super method");
}

public void addValue(int v)
{
value+=v;
}

public int getValue()
{
return value;
}
}

public class SubClass extends SuperClass
{
public void method(SuperClass p)
{
this.addValue(10);
System.out.println("Sub method 2");
}

public void method (SubClass p)
{
super.method(p);
this.addValue(4);
System.out.println("Sub method");
}

public void method (SuperClass p)
{
super.method(p);
this.addValue(4);
System.out.println("Sub method");
}
}


public class Example
{
public static void main(String [] args)
{
SuperClass o1, o2;
SubClass o3;
o1=new SuperClass();
o2=new SubClass();
o3=new SubClass();
o1.method(o2); System.out.println("1st result: "+o1.getValue());
o2.method(o2); System.out.println("2st result: "+o2.getValue());
o2.method(o1); System.out.println("3st result: "+o2.getValue());
o2.method(o3); System.out.println("4st result: "+o2.getValue());
o3.method(o1); System.out.println("5st result: "+o3.getValue());
o3.method(o3); System.out.println("6st result: "+o3.getValue());
o3.method(o2); System.out.println("7st result: "+o3.getValue());
}
}

[Print]

tnx!

[WhiteWolf42]

public class SubClass extends SuperClass {
public void method(SuperClass p){
this.addValue(10);
System.out.println("Sub method 2");
}
public void method (SubClass p){
super.method(p);
this.addValue(4);
System.out.println("Sub method");
}
public void method (SuperClass p){
super.method(p);
this.addValue(4);
System.out.println("Sub method");
}
}


Il metodo void method(SuperClass p) è duplicato. Controlla e riformula.

[WhiteWolf42]

dopo un po' di tempo speso a pensarci non so trovare una risposta alla tua domanda, anche perché non riesco a trovare un senso a questo tipo di implementazione ... potresti per favore farmi un'esempio concreto di applicazione ?

[k0nt3]

si chiama polimorfismo. il metodo che viene chiamato dipende dal tipo che l'oggetto ha a runtime, non se ne occupa il compilatore quindi.
in questo caso il tipo della variabile a runtime è SubClass quindi viene chiamato il metodo di SubClass

[WhiteWolf42]

si chiama polimorfismo. il metodo che viene chiamato dipende dal tipo che l'oggetto ha a runtime, non se ne occupa il compilatore quindi.
in questo caso il tipo della variabile a runtime è SubClass quindi viene chiamato il metodo di SubClass

definisci "a runtime" per favore !

[k0nt3]

definisci "a runtime" per favore !
durante l'esecuzione :fagiano:

[WhiteWolf42]

durante l'esecuzione :fagiano:

fin qui ci arrivavo :muro: intendevo dire: con che discriminante prende la classe madre piuttosto che la figlia, dato che sono istanziate entrambe e vengono richiamate entrambe.

[k0nt3]

mi risulta che o2 viene istanziato una sola volta e nel modo seguente:

o2=new SubClass();

[k0nt3]

può anche darsi che non ho capito la domanda eh :D

[WhiteWolf42]

può anche darsi che non ho capito la domanda eh :D

o sn io che nn capisco un cazzo :fagiano: ..... un raduno di geni !!!:sofico:

[k0nt3]

comunque in java è abbastanza facile capire quale metodo viene chiamato in caso di override o overload. ci si riferisce sempre al tipo dinamico.
ad esempio se ho:
SuperClass a = new SubClass();

il tipo statico di "a" è SuperClass mentre il tipo dinamico è SubClass