[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]

Originariamente inviato da Print

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]

Originariamente inviato da 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

definisci "a runtime" per favore !

[k0nt3]

Originariamente inviato da WhiteWolf42

definisci "a runtime" per favore !

durante l'esecuzione

[WhiteWolf42]

Originariamente inviato da k0nt3

durante l'esecuzione

fin qui ci arrivavo 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

[WhiteWolf42]

Originariamente inviato da k0nt3

può anche darsi che non ho capito la domanda eh

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

[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