/**
 * Klasse zum Üben von Verschattung von Variablen, Überschreiben und Überladen 
 * von Methoden (und Konstruktoren), Polymorphie, Sichtbarkeiten, Vererbung.
 * 
 * @author Stefan
 */
class A { // implizit Unterklasse von Object
    // Membervariablen:
    public final static int finale = 42;  // Klassenvariable, konstant (ändert Wert nicht mehr)
    private int ego = 0; // Objektvariable, nur innerhalb von A zugreifbar
    public int offen = 0; // Objektvariable, überall/für alle zugreifbar
    
    // Konstruktor 1, nur innerhalb von A und allen Unterklassen zugreifbar
    protected A() {
        ego = 1; // weist ego 1 zu
        offen = finale; // weist offen den Wert von finale zu
    }
    
    // Konstruktor 2 (damit ist der Konstruktor von A überladen)
    public A(int ego) {  // -> Verschattung von Objektvariable durch Parameter
        this();  // ruft den Konstruktor A() auf.
        this.ego = ego;  // Zuweisung an Objektvariable, zugriff mittels this.
    }
    
    // Getter
    public int ego() { return ego; }
    public int offen() { return offen; }

    // Methode, öffentlich zugreifbar/sichtbar
    public int method() {
        offen += 1; // addiert 1 zu offen
        return ego; // Objektvariable zurückgeben (this. nicht nötig, da implizit)
    }
    
    // überlädt
    public A method(A a) {
        return new A(112);
    }
    
    // überlädt
    public A method(B b) {
        return new B();
    }
}

class B extends A { // Unterklasse von A (erbt von A), damit indirekt Unterklasse von Object
    private int ego = 0; // Objektvariable, nur innerhalb von B zugreifbar
    private int offen = 0; // Objektvariable, nur in B zugreifbar, verschattet offen aus A
    
    public B() {
        // Hier wird implizit super(), also A() aufgerufen. Ginge nicht,
        // falls der Konstruktor A() nicht existieren würde.
        ego = finale; // Zugriff auf Klassenvariable aus A, Zuweisung an ego in B
                      // finale == A.finale == super.finale
    }
    
    // überlädt den Konstruktor von B
    private B(int ego) {
        super(ego);
    }
    
    // Getter
    @Override public int ego() { return ego; }
    @Override public int offen() { return offen; }
    public int superego() { return super.ego(); }
    public int superoffen() { return super.offen; }
    
    // überschreibt die geerbte Methode, da Name + Parametertypen gleich.
    // -> Sichtbarkeit (public) und Rückgabetyp (int) müssen in diesem Fall gleich sein!
    public int method() {
        offen += 1;
        super.offen += 3;
        return ego;
    }
    
    // überlädt die Methode method, da Name gleich, Parameter aber unterschiedlich.
    // Rückgabetyp spielt keine Rolle.
    public A method(int ego) {
        if (ego == 17) return new A(offen); 
        return new B(ego); // ruft den Konstruktor von B auf und erzeugt somit
                           // ein neues Objekt der Klasse B, welches von diesem
                           // Objekt (bzw. dieser Methode) zurückgegeben wird
    }
    
    // überschreibt
    public A method(A a) {
        return new B(-33);
    }
}

public class ExampleTwo {

    public static void main(String[] args) {
        A a0 = new A(1);
        System.out.println("a0.ego() == " + a0.ego());
        System.out.println("a0.method() == " + a0.method());
        System.out.println("a0.offen() == " + a0.offen());
        System.out.println("a0.finale == " + a0.finale);
        System.out.println("A.finale == " + A.finale);
        
        waitToContinue(); // Warten bis Nutzer Enter drückt
        
        B b0 = new B();
        System.out.println("b0.ego() == " + b0.ego());
        System.out.println("b0.method() == " + b0.method());
        System.out.println("b0.offen() == " + b0.offen());
        System.out.println("b0.superego() == " + b0.superego());
        System.out.println("b0.superoffen() == " + b0.superoffen());
        System.out.println("b0.finale == " + b0.finale);
        System.out.println("B.finale == " + B.finale);
        
        waitToContinue(); // Warten bis Nutzer Enter drückt
        
        A a1 = a0.method(a0);
        System.out.println("a1.method() == " + a1.method());
        System.out.println("a1.ego() == " + a1.ego());
        System.out.println("a1.offen() == " + a1.offen());
        
        waitToContinue(); // Warten bis Nutzer Enter drückt
        
        A a2 = a0.method(b0);
        System.out.println("a2.method() == " + a2.method());
        System.out.println("a2.ego() == " + a2.ego());
        System.out.println("a2.offen() == " + a2.offen());
        
        waitToContinue(); // Warten bis Nutzer Enter drückt
        
        B b1 = (B) a2;
        System.out.println("b1.ego() == " + b1.ego());
        System.out.println("b1.offen() == " + b1.offen());
        System.out.println("b1.superego() == " + b1.superego());
        System.out.println("b1.superoffen() == " + b1.superoffen());
        
        waitToContinue(); // Warten bis Nutzer Enter drückt
        
        A a3 = b0.method(a0);
        System.out.println("a3.method() == " + a3.method());
        System.out.println("a3.ego() == " + a3.ego());
        System.out.println("a3.offen() == " + a3.offen());
        
        waitToContinue(); // Warten bis Nutzer Enter drückt
        
        A a4 = a3.method(a3);
        System.out.println("a4.offen() == " + a4.offen());
        System.out.println("a4.method() == " + a4.method());
        System.out.println("a4.offen() == " + a4.offen());
        
        waitToContinue(); // Warten bis Nutzer Enter drückt
        
        A a5 = (A) b0;
        System.out.println("a5.ego() == " + a5.ego());
        System.out.println("a5.offen() == " + a5.offen());
        System.out.println("a5.method() == " + a5.method());
        System.out.println("a5.offen() == " + a5.offen());
        
        waitToContinue(); // Warten bis Nutzer Enter drückt
        
        // Nichts neues erzeugen - wir beziehen uns auf das b0 von oben
        System.out.println("b0.ego() == " + b0.ego());
        System.out.println("b0.offen() == " + b0.offen());
        System.out.println("b0.superego() == " + b0.superego());
        System.out.println("b0.superoffen() == " + b0.superoffen());
        
        waitToContinue(); // Warten bis Nutzer Enter drückt
        
        A a6 = b1.method(new B());
        System.out.println("a6.ego() == " + a6.ego());
        System.out.println("a6.offen() == " + a6.offen());
        System.out.println("a6.method() == " + a6.method());
        System.out.println("a6.ego() == " + a6.ego());
        System.out.println("a6.offen() == " + a6.offen());
        
        waitToContinue(); // Warten bis Nutzer Enter drückt
        
        A a7 = b1.method(new A());
        System.out.println("a7.ego() == " + a7.ego());
        System.out.println("a7.offen() == " + a7.offen());
        System.out.println("a7.method() == " + a7.method());
        System.out.println("a7.ego() == " + a7.ego());
        System.out.println("a7.offen() == " + a7.offen());
        
        waitToContinue(); // Warten bis Nutzer Enter drückt
        
        B b2 = (B) a6;
        System.out.println("b2.ego() == " + b2.ego());
        System.out.println("b2.offen() == " + b2.offen());
        System.out.println("b2.superego() == " + b2.superego());
        System.out.println("b2.superoffen() == " + b2.superoffen());
        System.out.println("b2.method() == " + b2.method());
        
        waitToContinue(); // Warten bis Nutzer Enter drückt
        
        B b3 = (B) a7;
        System.out.println("b3.ego() == " + b3.ego());
        System.out.println("b3.offen() == " + b3.offen());
        System.out.println("b3.superego() == " + b3.superego());
        System.out.println("b3.superoffen() == " + b3.superoffen());
        System.out.println("b3.method() == " + b3.method());
        
        waitToContinue(); // Warten bis Nutzer Enter drückt
        
        // Nichts neues erzeugen - wir beziehen uns auf a6 und a7
        System.out.println("a6.ego() == " + a6.ego());
        System.out.println("a6.offen() == " + a6.offen());
        System.out.println("a7.ego() == " + a7.ego());
        System.out.println("a7.offen() == " + a7.offen());
        
        waitToContinue(); // Warten bis Nutzer Enter drückt
        
        // Nichts neues erzeugen - wir beziehen uns auf a6 und a7, b2 und b3
        System.out.println("a6.method() == " + a6.method());
        System.out.println("a7.method() == " + a7.method());
        System.out.println("b2.method() == " + b2.method());
        System.out.println("b3.method() == " + b3.method());
        
        System.out.println("b2.offen() == " + b2.offen());
        System.out.println("b3.offen() == " + b3.offen());
        System.out.println("b2.superoffen() == " + b2.superoffen());
        System.out.println("b3.superoffen() == " + b3.superoffen());
        System.out.println("a6.offen() == " + a6.offen());
        System.out.println("a7.offen() == " + a7.offen());
        
        // Hier weitere Möglichkeiten einfügen. Experimentieren...
    }
    
    /**
     * Wartet auf eine Eingabe. Mehr geschieht hier nicht.
     */
    public static void waitToContinue() {
        System.out.println("\nPress Enter to continue...");
        try {
            System.in.read();
        } catch (java.io.IOException e) {
            
        }
    }

}