public class Operators {
	
	public void SetInteger (int value){}
	public void SetString (String value){}
	public void SetBool (Boolean value){}
	public void SetReal (double value){}
	
	public int GetInteger(){return 5;}
	public String GetString(){ return "Text";}
	public boolean GetBoolean(){ return true; }
	public double GetReal(){ return 5; }
	
	public void Demo ()
	{
		int IntA; 			// Ganzzahl A
		int IntB; 			// Ganzzahl B
		
		String StringA; 	// Zeichenkette A
		String StringB; 	// Zeichenkette B
		
		boolean BoolA;		// Wahrheitswert A
		boolean BoolB;		// Wahrheitswert B
		
		double RealA;		// Reele Zahl A
		double RealB;		// Reele Zahl B
				
		// ------------------------------------------------------------------------------------------------------------
		// Zuweisungsoperatoren
		
		IntA = 5; 							// Weist der Variablen IntA den Wert 5 zu
		IntB = IntA;						// Weist der Variablen IntB den Wert aus IntA zu (hier 5);
		IntA = GetInteger(); 				// Weist der Variablen IntA den Rückgabewert der Methode GetInteger zu.
		
		StringA = "Text mit Leerzeichen";	// Weist der Variablen StringA einen Text zu.
		StringB = StringA;					// Weist der Variablen StringB den Inhalt von StringA zu.
		StringA = GetString();				// Weist der Variablen StringA den Rückgabewert der Methode GetString zu.

		BoolA = true;						// Weist der Variablen BoolA den Wert 'wahr' resp. 'true' zu
		BoolB = false;						// Weist der Variablen BoolB den Wert 'falsch' resp. 'false' zu
		BoolB = BoolA;						// Weist der Variablen BoolB den Inhalt von BoolA zu (hier true).
		BoolA = GetBoolean();				// Weist der Variablen BoolA den Rückgabewert der Methode GetBoolean zu.
				
		RealA = 1.2343;						// Weist der Variablen RealA den Wert 1,2343 zu.
		RealB = 3.76448E4;					// Weist der Variablen RealB den Wert 37644,8 zu.
		RealA = RealB;						// Weist der Variablen RealA den Wert aus RealB zu.
		RealA = GetReal();					// Weist der Variablen RealA den Rückgabewert der Methode GetReal zu.
		
		// ------------------------------------------------------------------------------------------------------------
		// Logische Operatoren, das Ergebnis ist immer ein Wahrheitswert
		
		BoolA = !BoolB;						// logisches NICHT, BoolA wird das Gegenteil von BoolB zugewiesen.

		BoolA = (IntA == IntB);				// Gleichheit, NICHT für Zeichenketten!
		BoolA = (IntA == 5);			
		BoolA = (BoolA == BoolB);
		BoolA = (BoolB == true);
		BoolA = (RealA == RealB);
		BoolA = (RealB == 1.23);
		BoolA = (RealB == IntA);
		if (IntA == 5){}					// Schleifen und Verzweigungen brauchen logische Operatoren
		
		BoolA = (IntA != IntB);				// Ungleichheit, analog zu Gleichheit
		BoolA = (IntA != 5);
		
		BoolA = (BoolA & BoolB);			// logisches UND, es wird immer der ganze Ausdruck ausgewertet.
		BoolA = (BoolB & (IntA == 5));
		BoolB = false;
		BoolA = (BoolB & GetBoolean());		// GetBoolean wird aufgerufen.
		
		BoolB = false;
		BoolA = (BoolA && BoolB);			// bedingtes UND, es wird von links nach rechts ausgewertet.
		BoolA = (BoolB && GetBoolean());	// GetBoolean wird NICHT aufgerufen.
		
		BoolA = (!BoolB && (IntA == 5) && (IntB != 5));
		
		BoolA = BoolA ^ BoolB;				// Logisches exklusives ODER (XOR)
		BoolA = BoolB ^ GetBoolean();
		
		BoolA = BoolA | BoolB;				// Logisches ODER, es wird immer der ganze Ausdruck ausgewertet.
		BoolA = BoolB | GetBoolean();
		
		BoolB = true;
		BoolA = (BoolA || BoolB);			// bedingtes ODER, es wird von links nach rechts ausgewertet.
		BoolA = (BoolB || GetBoolean());	// GetBoolean wird NICHT aufgerufen.
		
		BoolA = (BoolB && (IntA == 5) || GetBoolean());
		
		
		// ------------------------------------------------------------------------------------------------------------
		// Logische Operatoren, Vergleichsoperatoren für Zahlen
		
		BoolA = (IntA == IntB);				// Gleichheit, siehe oben
		BoolA = (IntA != IntB);				// Ungleichheit, siehe oben
		
		BoolA = (IntA < IntB); 				// kleiner als
		BoolA = (IntA < 5);
		
		BoolA = (RealA < RealB);			
		BoolA = (RealA < 5);
		
		BoolA = (IntA < RealA);
		BoolA = (RealA < IntA);
		
		BoolA = (IntA <=	5); 			// kleiner oder gleich
		BoolA = (IntA <= RealA);
		BoolA = (RealA <= RealB);
		
		BoolA = (IntA > 5);					// größer als
		BoolA = (IntA > RealA);
		BoolA = (RealA > RealB);
		
		BoolA = (IntA >= 5);				// größer oder gleich
		BoolA = (IntA >= RealA);
		BoolA = (RealA >= RealB);
			
		// ------------------------------------------------------------------------------------------------------------
		// Vergleich von Zeichenketten (Exkurs: Vergleich von Objekten)
		
		BoolA = StringA.equals(StringB);	// Gleichheit
		IntA = StringA.compareTo(StringB);	// IntA > 0  --> StringA > StringB
											// IntA == 0 --> StringA == StringB
											// IntA < 0  --> StringA < StringB
		BoolA = (StringA.compareTo(StringB) > 0);	// StringA > StringB
		BoolA = (StringA.compareTo(StringB) == 0);	// StringA == StringB
		BoolA = (StringA.compareTo(StringB) < 0);	// StringA < StringB
		
		
		// ------------------------------------------------------------------------------------------------------------
		// Rechenoperationen für Zahlen
		
		IntA = IntA + 5;					// Addition
		IntA = 5 + 3;
		IntA = IntA + IntB;
		
		RealA = RealA + RealB;
		RealA = IntA + RealB;
		
		IntA = IntA - 5;					// Subtraktion
		IntA = 5- 3;
		IntA = IntA - IntB;
		
		RealA = RealA - RealB;
		RealA = IntA - RealB;
		
		IntA = 5 * IntB;					// Multiplikation
		RealA = 5 * RealB;					
		IntA = IntA * IntB;
		RealA = IntA * RealA;
		
		RealA = IntA / 5;					// Division
		RealA = RealB / RealA;
		
		IntA = IntA % 5;					// Divsionsrest
		IntA = IntA % IntB;
		
		IntA += IntB;						// Abkürzung für IntA = IntA + IntB;
		IntA -= IntB;						// Abkürzung für IntA = IntA - IntB;
		IntA *= IntB;						// Abkürzung für IntA = IntA * IntB;
		IntA /= IntB;						// Abkürzung für IntA = IntA / IntB;
		

		RealA += RealB;						// Abkürzung für RealA = RealA + RealB;
		RealA -= RealB;						// Abkürzung für RealA = RealA - RealB;
		RealA *= RealB;						// Abkürzung für RealA = RealA * RealB;
		RealA /= RealB;						// Abkürzung für RealA = RealA / RealB;

		IntA++;								// Inkrement: Abkürzung für IntA = IntA + 1;
		IntA--;								// Dekrement: Abkürzung für IntA = IntA - 1;				
		
		// ------------------------------------------------------------------------------------------------------------
		// Verknüpfungsoperationen für Zeichenketten
		
		StringA = StringB + "Text";			// Verknüpfung
		StringA = StringB + IntA;
		StringA = StringB + RealA;
		StringA = StringB + StringA;
		
	}
	
	public static void main (String[] args)
	{
		Operators App = new Operators();
		App.Demo();
	}
}