Operatoren

src/org/eidecker/oca8lernen/general/CallByValueUndWrapper.java

@@ -0,0 +1,29 @@
+package org.eidecker.oca8lernen.general;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import org.junit.jupiter.api.Test;
+
+public class CallByValueUndWrapper {
+
+
+	@Test
+	public void testCallByValue() {
+		String s = "   Hallo   ";
+		trimString(s);
+		assertTrue(s.length() == 11);
+	}
+
+	public void callWithPrimitive(int i) {
+		i = i + 1;
+	}
+
+	public void callWithWrapper(Integer i) {
+	}
+
+	public void trimString(String s) {
+		s.trim();
+	}
+
+
+}

src/org/eidecker/oca8lernen/general/LabelContinueUndBreak.java

@@ -79,6 +79,7 @@ public class LabelContinueUndBreak {
 	public void testLabel() {
 		außen:
 		for (int i = 1; i <= 10; i++) {
+			labelInDerMitte: // Erlaubt, aber nicht ansprechbar
 			System.out.println("Outer oben " + i);
 			innen:
 			for (int j = 1; j <= 2; j++) {

src/org/eidecker/oca8lernen/general/OperatorVorrang.java

@@ -0,0 +1,80 @@
+package org.eidecker.oca8lernen.general;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import org.junit.jupiter.api.Test;
+
+public class OperatorVorrang {
+
+	private int intField;
+
+	@Test
+	public void shortCircuit() {
+
+
+		boolean t = true & true | true & false;
+		assertTrue(t);
+
+		boolean t2 = true & (true | true) & false;
+		assertFalse(t2);
+
+		boolean t3 = true & true || true & false;
+		assertTrue(t3);
+		// Damit ist die Rangfolge als boolescher Operator von &,| und &&,|| gleich! Und Und immer vor Oder, egal welcher Typ verwendet wird.
+
+
+		// | hat Vorrang vor || laut Liste, Ausdruck wird also ausgewertet
+//		assertThrows(RuntimeException.class, () -> {
+//			boolean b = true || false | throwSomething();
+//		});
+		// Edit: Stimmt doch nicht, komisch
+
+	}
+
+	private boolean throwSomething() {
+		throw new RuntimeException("Just for fun as a side effect");
+	}
+
+	@Test
+	public void assignmentOperators() {
+		int i = 2, j = 3;
+
+		int k = i *= j;
+
+		assertTrue(k == 6);
+	}
+
+	@Test
+	public void testReturnAssignment() {
+		int i = returnWithAssignment(2, 3);
+		assertTrue(i == 5);
+
+		int j = returnWithPlusPlus(3);
+		assertTrue(j == 3);
+
+	}
+
+	@Test
+	public void testReturnAssignmentField() {
+		intField = 1;
+		int before = intField;
+		int after = returnWithPlusPlusStatic();
+		assertTrue(after == before);
+		assertTrue(intField == before + 1);
+	}
+
+
+	private int returnWithAssignment(int i, int j) {
+		return i += j;
+	}
+
+	private int returnWithPlusPlus(int i) {
+		return i++;
+	}
+
+	private int returnWithPlusPlusStatic() {
+		return intField++;
+	}
+}

src/org/eidecker/oca8lernen/general/StringEquals.java

@@ -24,5 +24,37 @@ public class StringEquals {
 		assertFalse(s1 == s3);
 	}
 
+	@Test
+	public void testStringEqualsConstructedByMethod() {
+
+		String s1 = s1();
+		String s2 = s2();
+
+		assertTrue(s1 == s2);
+
+		String s3 = s3();
+		String s4 = s4();
+
+		assertFalse(s3 == s4);
+
+		assertFalse(s1 == s3);
+	}
+
+	private String s1() {
+		return "Hallo";
+	}
+
+	private String s2() {
+		return "Hallo";
+	}
+
+	private String s3() {
+		return new String("Hallo");
+	}
+
+	private String s4() {
+		return new String ("Hallo");
+	}
+
 
 }