public class Datentypen {

	public static void main(String[] args) {
		
		
		// Merkregelfür Basis-Datentypen:
		// Von weniger nach mehr bits: generell erlaubt
		// allerdings Ausnahme "char", da "unsigned" Datentyp
		// Von mehr nach weniger Bits:  verboten, außer
		// mit CAST (int) unter möglichem Verlust von
		// Genauigkeit oder Sinn.
		// GDI Folie 86 (SS 2018)
		
		double d;
		float f;
		long l;
		int i;
		short s;
		char c;
		byte b;
		
		b = 1; // Zahl 1 in 8 bit
		
		// Erlaubte Reihenfolge
		d = f = l = i = s = b;
		
		// Verboten, da b weniger Bits als d hat,
		// OBWOHL eigentlich in beiden Variablen eine ganz kleine
		// Zahl steht
		// b = d;
		
		// ERLAUBT, expliziter cast
		b = (byte) d;
		
		// Immer noch erlaubt, da cast nach byte die Nachkommastellen
		// verwirft
		
		b = (byte) 1.9999999999;
		
		// Was steht in b?
		
		System.out.println(b);
		
		// Erlaubt oder nicht?
		
		// i = 10 * l;
		
		i = 10 * (int)l;
		
		l = i * 10;
		
		
		// l ist jetzt 100, i ist 10
		// Was wird in d gespeichert?
		d = i / 100;
		System.out.println(d);
		d = i / 100.0;
		System.out.println(d);
		
		// Wie sieht es mit der Zuweisung von Objekten aus?
        A a = new B();
        System.out.println(a.a);
        // Hier passiert ein cast zwischen der tatsächlich
        // instanzierten Klasse B, und der Variable vom Typ a
        System.out.println( ( (B) a ) . b    );
        
        // Geht nicht, da B Attribute (b) enthält, die
        // in A nicht vorkommen und daher kein Speicher
        // reserviert wird.
        // B b = new A();
        a = new C();
        System.out.println( ( (C) a ) . c );
        
        // Geht das?
        Object o = new Object();
        
        // Geht nur SCHEINBAR (kein Syntax-Fehler)
        System.out.println(( (A) o ). a);
        // ... aber wirft eine Exception, da in einem
        // Object natürlich gar keine Variable a
        // existiert, die man ausgeben könnte.
        // Der CAST erzeugt keinen neuen Speicher
        // für zusätzliche Variablen, und ruft auch keinen
        // Konstruktor auf.
        // Klassen-Cast: "Nimm an, das gecastete Objekt
        // wäre von der gecasteten Klasse" ->
        // kann zur Laufzeit Fehler produzieren, wenn
        // es nicht stimmt!
		
	}

}

class A { int a = 1; }
class B extends A { int b = 1; }
class C extends B { int c = 1; }