Kurseinheit 3 - größter gemeinsamer Teiler

/**
 * Die Klasse <b>Test</b> soll den Unterschied zwischen = und clone() verdeutlich.<hr />
 * Kurze Erklärung zu sachen die Überlesen werden sollten:<br />
 * <i>implements Cloneable</i>, ist nötig, damit man Objekte vom Typ Test clonen kann.<br />
 * <i>throws CloneNotSupportedException</i> bei manchen Methoden<br />
 * habe ich eingefügt um die Lesbarkeit zu erhöhen und keine try-catch- Blöcke einfügen muss.
 * @author Martin
 * @version 0.1
 *
 */
public class Test implements Cloneable{
    private String str;
    
    /**
     * Erzeugt ein Test Objekt mit einem bestimmten String.
     * @param str
     */
    public Test(String str) {
        this.str = str;
    }
    
    /**
     * Ändert den aktuellen String auf den String neu
     * @param neu
     */
    public void setStr(String neu) {
        this.str = neu;
    }
    
    /**
     * Main methode, kann ohne Objekt aufgerufen werden.
     * @param args
     * @throws CloneNotSupportedException
     */
    public static void main(String[] args) throws CloneNotSupportedException {
        Test t1 = new Test("a");    // Objekt von Test erzeugen.
        Test t2;                    // t2 initialisieren.
        
        // Gleichsetzen:
        t2 = t1;
        System.out.println(t1 + " " + t2);    // Ausgabe: a a
        
        // t1 wird geändert auf "b":
        t1.setStr("b");
        System.out.println(t1 + " " + t2);    // Ausgabe: b b
        
        // t2 wird geändert auf "c":
        t2.setStr("c");
        System.out.println(t1 + " " + t2);    // Ausgabe: c c
        
        // changeDirect aufruf (a=b):
        changeDirect(t1);
        System.out.println(t1 + " " + t2);    // Ausgabe: d d
        
        // changeIndirect aufruf (a=b):
        changeIndirect(t1);
        System.out.println(t1 + " " + t2);    // Ausgabe: e e
        
        // changeClone aufruf (a=b):
        changeClone(t1);
        System.out.println(t1 + " " + t2);    // Ausgabe: e e
                
        System.out.println();    // Leer Zeile
        
        
        t1 = new Test("a");        // t1 auf Ausgang zurücksetzen.
        t2 = null;                // t2 auf Ausgang zurücksetzen.
        
        // Clone():
        t2 = (Test) t1.clone();
        System.out.println(t1 + " " + t2);    // Ausgabe: a a
        
        // t1 wird geändert auf "b":
        t1.setStr("b");
        System.out.println(t1 + " " + t2);    // Ausgabe: b a
        
        // t2 wird geändert auf "c":
        t2.setStr("c");
        System.out.println(t1 + " " + t2);    // Ausgabe: b c
        
        // changeDirect aufruf (b = a.clone()):
        changeDirect(t1);
        System.out.println(t1 + " " + t2);    // Ausgabe: d c
        
        // changeIndirect aufruf (b = a.clone()):
        changeIndirect(t1);
        System.out.println(t1 + " " + t2);    // Ausgabe: e c
        
        // changeClone aufruf (b = a.clone()):
        changeClone(t1);
        System.out.println(t1 + " " + t2);    // Ausgabe: e c
    }
    
    /**
     * Ändert den String von t direkt.
     * @param t
     */
    public static void changeDirect(Test t) {
        t.setStr("d");
    }
    
    /**
     * Ändert den String von t indirekt über t3 (t3 = t).
     * @param t
     */
    public static void changeIndirect(Test t) {
        Test t3 = t;
        t3.setStr("e");
    }
    
    /**
     * Ändert den String von t an einem Clone t3 (t3 = t.clone())
     * @param t
     * @throws CloneNotSupportedException
     */
    public static void changeClone(Test t) throws CloneNotSupportedException {
        Test t3 = (Test)t.clone();
        t3.setStr("f");
    }
    
    @Override
    public String toString() {
        return str;
    }

}