Merge remote-tracking branch 'origin/master'

src/org/eidecker/oca8lernen/chapter01/EnumOne.java

@@ -2,6 +2,12 @@ package org.eidecker.oca8lernen.chapter01;
 
 import org.junit.jupiter.api.Test;
 
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+
 /**
  * @author seidecke.
  */
@@ -21,9 +27,14 @@ class TestClass {
 		for (B item : B.values()) {
 			System.out.println(item);
 		}
+
+		int i = 1;
+
+
 	}
 
 
+
 	private enum Two {
 
 		EINS, ZWEI;

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

@@ -0,0 +1,35 @@
+package org.eidecker.oca8lernen.general;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import org.junit.jupiter.api.Test;
+
+/**
+ * @author seidecke.
+ */
+public class ArrayFun {
+
+	char index;
+
+	@Test
+	public void testArrayInit() {
+		String[] strings = {"Hallo", "Welt"};
+		assertEquals(0, index);
+		assertEquals("Hallo", strings[index]);
+
+		assertEquals("Hallo", strings[(byte) 1]);
+		assertEquals("Hallo", strings[(short) 1]);
+		assertEquals("Hallo", strings[(char) 1]);
+
+		// assertEquals("Hallo", strings[(float) 1]); // Compilerfehler, muss Ganzzahl sein
+		// assertEquals("Hallo", strings[(long) 1]); // Compilerfehler, muss int oder kleiner sein
+
+		// Arrayklammern vor und nach Variablenname erlaubt
+		String [] twodim [];
+
+		String[][] twoDimStrings = {strings};
+
+
+	}
+
+}

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

@@ -4,6 +4,11 @@ import static org.junit.jupiter.api.Assertions.assertThrows;
 
 import org.junit.jupiter.api.Test;
 
+import java.io.IOException;
+import java.nio.file.AccessDeniedException;
+import java.util.List;
+import java.util.zip.DataFormatException;
+
 /**
  * @author seidecke.
  */
@@ -30,17 +35,43 @@ public class CastExceptions {
 		// Compilefehler, da Versuch des Casts außerhalb der Typenhierarchie
 		// UnterCast unter2 = (UnterCast) außerhalb;
 
+		try {
+			UnterCast unterCast = new UnterCast();
+			unter.method();
+		} catch (RuntimeException e) {
+
+		}
+
+
 	}
 }
 
 class OberCast {
 
+	public void method() throws IOException{
+		Integer i;
+
+		long l2 = (int)12;
+
+		int i2 = 2;
+
+		i = (int)i2;
+	}
+
 }
 
 class UnterCast extends OberCast {
 
+	@Override
+	public void method() {
+		System.out.println("method in Untercast");
+	}
 }
 
 class Außerhalb {
 
 }
+
+class MyCheckedException extends Exception {
+
+}

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

@@ -0,0 +1,72 @@
+package org.eidecker.oca8lernen.general;
+
+import org.junit.jupiter.api.Test;
+
+public class ConditionalInitialisation {
+
+	final String s2;
+	final String s3;
+	// final String s4;
+
+	public ConditionalInitialisation() {
+		boolean b = true;
+		if (b) {
+			s2 = "Hallo";
+		} else {
+			s2 = "Welt";
+		}
+
+		// Keine doppelte Zuweisung, da Compiler auflösen kann
+		if (true) s3= "Hallo";
+		if (false) s3 = "Welt";
+
+		String s6;
+		final boolean c = false;
+		if (c) s6 = "Hallo";
+		if (!c) s6 = "Welt";
+		System.out.println(s6);
+
+		// Geht nicht, damit sowohl Verletzung final-Zuweisung als auch Nicht-Initialisierung
+		// if (b) s4 = "Hallo";
+		// if (!b) s4 = "Welt";
+
+		try {
+			// s4 = fillMe();
+		} catch (Exception e) {
+			// s4 = fillMeSilently();
+		}
+
+		String s5;
+		try {
+			s5 = fillMe();
+		} catch (Exception e) {
+			s5 = fillMeSilently();
+		}
+
+	}
+
+	private String fillMe() throws Exception {
+		return "Hallo";
+	}
+
+	private String fillMeSilently() throws RuntimeException {
+		return "Welt";
+	}
+
+	@Test
+	public void testConditionalInitialisation() {
+
+		boolean b = true;
+
+		final String s;
+		if (b) {
+			s = "Hallo";
+		} else {
+			s = "Welt";
+		}
+
+		System.out.println(s);
+
+	}
+
+}

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

@@ -0,0 +1,135 @@
+package org.eidecker.oca8lernen.general;
+
+import java.io.IOException;
+import java.nio.file.AccessDeniedException;
+import java.util.zip.DataFormatException;
+
+import org.junit.jupiter.api.Test;
+
+/**
+ * @author seidecke.
+ */
+public class DoubleImplementsClash {
+
+	@Test
+	public void testSomeTHings() {
+		InterfaceImplementer implementer = new InterfaceImplementer();
+		// implementer.bothStatic() // Nicht vorhanden, nur im Interface
+		implementer.bothDefault();
+		implementer.singleDefault();
+		implementer.abstractClassAndInterfaceDefault();
+	}
+
+}
+
+class InterfaceImplementer extends AbstractClass implements SuperInterface1, SuperInterface2{
+
+
+	public void methode (int ...name ) {
+		// methode2(1,3,4); // Geht nicht, muss Array sein
+		methode2(name);
+	}
+
+	public void methode2 (int[] name) {
+		methode(1, 2, 3);
+		int [] ints = {1,2,3};
+		methode(ints);
+
+		System.out.println(new StringBuilder("Hallo").toString());
+	}
+
+	@Test
+	public void testSomething() {
+		SuperInterface1.bothStatic();
+		this.bothAbstract();
+		SuperInterface1.super.singleDefault();
+		this.singleDefault();
+	}
+
+	@Override
+	public void bothAbstract() {
+
+	}
+
+	public void bothDefault() {
+		SuperInterface1.super.bothDefault();
+
+
+	}
+
+	public void oneStaticOneAbstract() {
+
+	}
+
+
+}
+
+class AnotherImplementer implements SuperInterface1 {
+
+	@Override
+	public void bothAbstract() {
+
+	}
+
+	@Override
+	public void oneStaticOneAbstract() {
+
+	}
+}
+
+interface SuperInterface1 {
+	static void bothStatic() {
+	}
+
+	default void bothDefault() {
+	}
+
+	default void singleDefault() {
+
+	}
+
+	void bothAbstract();
+
+	void oneStaticOneAbstract();
+}
+
+interface SuperInterface2 {
+
+	static void bothStatic() {
+	}
+
+	default void bothDefault() {
+	}
+
+	void bothAbstract();
+
+	static void oneStaticOneAbstract() {
+
+	}
+
+	default void abstractClassAndInterfaceDefault() {
+		System.out.println("SuperInterface2 abstractClassAndInterfaceDefault");
+		"Halli".length();
+	}
+}
+
+abstract class AbstractClass {
+
+
+	public void abstractClassAndInterfaceDefault() {
+		System.out.println("AbstractClass abstractClassAndInterfaceDefault");
+	}
+
+	public void throwsException() throws IOException {
+
+	}
+
+}
+
+class ErbendeKlasse extends AbstractClass {
+
+	@Override
+	public void throwsException() throws AccessDeniedException {
+		new ErbendeKlasse();
+	}
+}

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

@@ -0,0 +1,39 @@
+package org.eidecker.oca8lernen.general;
+
+import java.util.concurrent.ExecutionException;
+import org.junit.jupiter.api.Test;
+
+/**
+ * Final deklarierte Felder müssen im Konstruktor oder einem Initialisierungsblock gesetzt werden.
+ * Die Standardwerte genügen nicht.
+ */
+public class Final {
+
+	{
+		String s = "s";
+		finalString = "Hallo";
+		if (false) throw new RuntimeException();
+		testIfBloecke();
+	}
+
+	{
+		String s = "s";
+	}
+
+	final String finalString;
+
+
+	public Final() {
+
+	}
+
+	@Test
+	public void testIfBloecke() {
+		if (true)
+			System.out.println("Eins");
+		if (false)
+			System.out.println("Zwei");
+		else
+			System.out.printf("Drei");
+	}
+}

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

@@ -0,0 +1,24 @@
+package org.eidecker.oca8lernen.general;
+
+import java.util.List;
+import org.junit.jupiter.api.Test;
+
+/**
+ * @author seidecke.
+ */
+public class ForEach {
+
+	@Test
+	public void testLaufvariable() {
+
+		int[] ints = new int[5];
+
+		for (int i: ints)
+			System.out.println(i);
+
+
+		List<String> sList;
+
+
+	}
+}

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

@@ -0,0 +1,35 @@
+package org.eidecker.oca8lernen.general;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+
+public class FunWithArrays {
+
+	@Test
+	public void testArrays() {
+
+		int[] ints = new int[] {1, 3, 4, 6, 7};
+
+		List[] lists = {new ArrayList(), new ArrayList()};
+
+		ArrayList[] arrayLists = {new ArrayList(), new ArrayList()};
+
+		int [] one = {1,2,4};
+		int [][] tow = {one};
+
+		int[][][][] strings = new int[3][3][][];
+		strings[1][2] = new int[][]{{1},{2}};
+
+		System.out.println(strings[1][2].getClass().getName());
+
+		// lists = arrayLists;
+
+		// arrayLists = (ArrayList[]) lists;
+
+		arrayLists[0].size();
+
+	}
+}

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

@@ -1,9 +1,58 @@
 package org.eidecker.oca8lernen.general;
 
 import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import org.junit.jupiter.api.Test;
 
 /**
  * @author seidecke.
  */
 public class HeaderList extends ArrayList {
 }
+
+
+class Listtest {
+
+	@Test
+	public void testListInterface() {
+		anyList().add("Hallo");
+	}
+
+
+	@Test
+	public void testHashMapInterface() {
+
+		Map<String, List<String>> map = new HashMap<>();
+		List<String> l = new ArrayList<>();
+		l.add("1");
+		map.put("1", l);
+		map.get("1").add("2");
+
+		System.out.println(map.values());
+
+	}
+
+	private List<String> anyList() {
+		return Collections.emptyList();
+	}
+
+	@Test
+	public void longList() {
+		LinkedList linkedList = new LinkedList();
+
+		for (int i = 0; i <= Integer.MAX_VALUE; i++) {
+			linkedList.add(i);
+			if (i % 1_000_000 == 0) System.out.println(i / 1_000_000 + " Millionen, " + (((double)i / Integer.MAX_VALUE) * 100) + " Prozent");
+
+		}
+
+		linkedList.add(-1);
+	}
+
+
+
+}

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

@@ -0,0 +1,84 @@
+package org.eidecker.oca8lernen.general;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import java.lang.reflect.Array;
+import org.junit.jupiter.api.Test;
+
+public class InstanceOfUndCast {
+
+	@Test
+	public void testInstanceof() {
+		// Instanceof außerhalb Typhierarchie nicht möglich
+//		boolean b = "Hallo" instanceof InstanceOfUndCast;
+
+		assertEquals(false, null instanceof InstanceOfUndCast);
+
+		String s;
+		// Nicht möglich, da nicht initialisiert
+		// s instanceof String;
+
+		int[] array = {1, 3, 4};
+		assertEquals(true, array instanceof Object);
+
+
+		// Nicht möglich, null kein Typ
+//		"Hallo" instanceof null
+	}
+
+	@Test
+	public void testPrimitiveCast() {
+		byte a = 4;
+		a = (byte) (a + 3); // Expliziter Cast erforderlich
+
+		byte b = 2;
+		b += 3;
+	}
+
+	@Test
+	public void testCast() {
+		OberCast echterOber = new OberCast();
+		OberCast oberAberUnter = new UnterCast();
+
+		UnterCast echterUnterCast = new UnterCast();
+
+
+		String s = (String) null;
+
+		echterOber = (UnterCast) echterUnterCast;
+
+		echterOber = oberAberUnter;
+
+		echterUnterCast = (UnterCast) oberAberUnter;
+
+		assertThrows(ClassCastException.class, () -> {
+			UnterCast echterUnterCast2 = new UnterCast();
+			OberCast echterOber2 = new OberCast();
+			echterUnterCast2 = (UnterCast) echterOber2;
+		});
+
+		{int i, j;}
+
+		for (int i = 1; i< 3; i++) {
+
+		}
+
+
+	}
+
+	class OberCast {
+
+	}
+
+	class UnterCast extends OberCast {
+		void untercast() {
+			System.out.printf("untercast");
+		}
+	}
+
+	class AußerhalbCast {
+
+	}
+
+}

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

@@ -1,5 +1,7 @@
 package org.eidecker.oca8lernen.general;
 
+import org.junit.jupiter.api.Test;
+
 import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class InterfaceWithFields implements T1, T2 {
@@ -18,6 +20,8 @@ public class InterfaceWithFields implements T1, T2 {
 interface T1 {
 	int VALUE = 99;
 	int VALUE_T1 = 1;
+
+	default int getValue() {return VALUE;}
 }
 
 interface T2 {
@@ -31,11 +35,15 @@ interface T2 {
 
 class Tester {
 
+	@Test
 	public void interfaceTest() {
 		InterfaceWithFields interfaceWithFields = new InterfaceWithFields();
 		assertEquals(99, ((T1)interfaceWithFields).VALUE);
 		assertEquals(98, ((T2)interfaceWithFields).VALUE);
 
+		T1 t1 = new InterfaceWithFields();
+		System.out.println(t1.getValue());
+
 		assertEquals(1, interfaceWithFields.VALUE_T1);
 		assertEquals(2, interfaceWithFields.VALUE_T2);
 	}

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

@@ -14,7 +14,7 @@ class TestInterfaces {
 
 }
 
-public class Interfaces extends AbstractClass implements I1 {
+public class Interfaces extends SomeAbstractClass implements I1 {
 
 	public void method1() {
 
@@ -30,7 +30,7 @@ public class Interfaces extends AbstractClass implements I1 {
 }
 
 
-abstract class AbstractClass {
+abstract class SomeAbstractClass {
 
 	public abstract void method1() throws IOException;
 

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

@@ -2,7 +2,7 @@ package org.eidecker.oca8lernen.general;
 
 import org.junit.jupiter.api.Test;
 
-public class KLassenInitialisierung {
+public class KlassenInitialisierung {
 
 	@Test
 	public void testInitialisierung() {
@@ -26,6 +26,8 @@ public class KLassenInitialisierung {
 
 class Oberklasse {
 
+	private String s = initString();
+
 	static {
 		synchronized (Oberklasse.class) {
 			System.out.println("Oberklasse statischer Initialisierungsblock");
@@ -54,10 +56,17 @@ class Oberklasse {
 
 	}
 
+	private String initString() {
+		System.out.println("OberklasseString wurde initialisiert");
+		return "OberklasseString";
+	}
+
 }
 
 class Unterklasse extends Oberklasse {
 
+	private String s = initString();
+
 	static {
 		System.out.println("Unterklasse statischer Initialisierungsblock");
 	}
@@ -78,4 +87,9 @@ class Unterklasse extends Oberklasse {
 	public Unterklasse() {
 		System.out.println("Unterklasse Konstruktor");
 	}
+
+	private String initString() {
+		System.out.println("UnterklasseString wurde initialisiert");
+		return "UnterklasseString";
+	}
 }

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

@@ -0,0 +1,23 @@
+package org.eidecker.oca8lernen.general;
+
+import org.junit.jupiter.api.Test;
+
+public class Loop {
+
+	@Test
+	public void testLoops() {
+		int i = 1;
+
+		/*do
+			System.out.println("Hallo");
+		while(i == 1);
+		*/
+
+		System.out.println("Hallo");
+
+		do
+			System.out.println("Hallo");
+		while(true);
+	}
+
+}

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

@@ -202,6 +202,11 @@ class PrimitiveOverloading {
 		return VARIANTE_BYTE;
 	}
 
+	public String neuerVersuch(byte l) {
+		System.out.println("long");
+		return "long";
+	}
+
 }
 
 class PrimitiveOverloadingTester {
@@ -229,7 +234,30 @@ class PrimitiveOverloadingTester {
 		// Primitiv, nicht vorhanden, auch kein Wrapper
 		assertEquals(VARIANTE_INT, primitiveOverloading.overloadMe((short) 1));
 
+		primitiveOverloading.neuerVersuch((char)12);
 
+		OverloadMe2 overloadMe2 = new OverloadMe2();
+		// overloadMe2.one(1, 1);
+
+		overloadMe2.two(new Integer(1));
+	}
+
+}
+
+class OverloadMe2 {
+
+	public int one(double d, int i) {
+		return 1;
+	}
+
+	public int one(int d, double i) {
+		return 1;
+	}
+
+
+
+	public int two(Long i) {
+		return 1;
 	}
 
 }

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

@@ -0,0 +1,137 @@
+package org.eidecker.oca8lernen.general;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import org.junit.jupiter.api.Test;
+
+public class Primitive {
+
+
+	@Test
+	public void testSomething() {
+
+		// Ein paar Zuweisungen
+
+
+
+
+		double d = 3.9;
+		int i = (int) d;
+
+		System.out.println(i);
+
+
+	}
+
+	@Test
+	public void testUnderscores() {
+		int iDec = 1_1__1;
+		assertEquals(111, iDec);
+
+		int iBinary = 0b10__0_0101_0000;
+		int iHex = 0xf2_d8;
+		int iOctal = 0111;
+
+		int iOctal2 = new Integer(011);
+		int iOctal3 = new Integer("011"); // Das wird wohl doch dezimal behandelt
+		int iOctal4 = new Integer("0b11");
+		assertFalse(iOctal2 == iOctal3);
+
+		assertFalse(new Integer("1").equals((long)1));
+		assertFalse(new Long(1).equals(1));
+
+
+		assertNotEquals(111, iOctal);
+	}
+
+	@Test
+	public void testZuweisungLiterale() {
+
+	}
+
+	@Test
+	public void testImplicitCast() {
+		float f3;
+		float f = 1.0f;
+		float f2 = 1L;
+
+		f3 = f + f2;
+
+		byte b1 = (byte)1f;
+
+		char c1 = (char) -1;
+		System.out.println("c1: " + c1);
+
+		short s1 = Short.MAX_VALUE;
+		short s2 = (short) (s1 + 1);
+		System.out.println(s2);
+
+		short s3 = (short)189898989898989898l;
+		System.out.println("s3: " + s3);
+
+		long l1 = Long.MAX_VALUE;
+		System.out.println("L1: " + (l1 + 12));
+
+		char c = 1, d = 3;
+		System.out.println(c + d);
+
+		int i5 = 1212;
+		long l4;
+		l4 = i5;
+
+		char c5;
+		byte b9 = 2;
+
+		byte b2 = 'a';
+
+		float f9 = Long.MAX_VALUE;
+		System.out.println("f9: " + f9);
+
+		char c10 = (char)123.333d;
+		System.out.println("c10: " + c10);
+
+		Integer I1 = 0b0101;
+		// Float F1 = (int)12; Float, Double können keine Ganzzahl-Literale zugewiesen werden
+		Double D1 = (double)12;
+
+		// Float F12 = 11;
+		Float F11 = new Float(11L);
+		System.out.println("F11" + F11);
+
+		float f4 = 4.0f;
+		long l6 = 4L;
+		System.out.println("2323: " + (f4 == l6));
+
+		Short short1 = 127;
+		Short short2 = 127;
+		Short short3 = 128;
+		Short short4 = 128;
+
+		assertTrue(short1 == short2);
+		assertFalse(short3 == short4);
+
+
+		Short short5 = new Short((short)127);
+		Short short6 = new Short((short)127);
+		assertFalse(short5 == short6);
+
+	}
+
+	@Test
+	public void testExplicitCast() {
+
+	}
+
+
+
+
+}
+
+class AndereKlasse {
+	public static void main(String[] args) {
+		System.out.println("Geht auch aus nicht public-Klasse");
+	}
+}

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

@@ -12,16 +12,38 @@ public class PrimitiveUndWrapperTest {
 	@Test
 	public void zuweisungWertebereich() {
 
-		char c = (char) 1L;
+		byte e, f = 2, g = 4;
+
+
+		// Compilefehler, da + implizit int erzeugt
+		// e = f + g;
+
+		char r, s = 3, t = 4;
+		// Compilefehler, da + implizit int erzeugt
+		// r = s + t;
+
+
+		float f1, f2 = 0, f3 = 3;
+		f1 = f2 + f3;
+
+		char c = (char) -1L;
+
 
 		short sh = Short.MAX_VALUE;
-//		char s = sh;
+//		char ch = (byte)sh;
 
 		"Hallo".concat(" Welt");
 
 //		System.out.println(s);
 	}
 
+	@Test
+	public void literalUnderscore() {
+		// int i = 1_1_;
+
+		double d = 1_1.1_1;
+	}
+
 	@Test
 	public void wrapperEquals() {
 

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

@@ -0,0 +1,35 @@
+package org.eidecker.oca8lernen.general;
+
+import org.junit.jupiter.api.Test;
+
+public class Spielen {
+
+	public Spielen() {
+
+	}
+
+	public Spielen(int n) {
+		this();
+
+		int i = new Integer("2");
+	}
+
+
+	@Test
+	public void spielen() {
+		int i = 1;
+		printInt(i++ + i);
+		System.out.println(i);
+
+		int k = 1;
+		printInt(k + k++);
+
+		int j = 1;
+		printInt(j+= 3);
+	}
+
+
+	private void printInt(int i) {
+		System.out.println(i);
+	}
+}

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

@@ -57,10 +57,19 @@ public class StringIndex {
 
 		testStringBuilder = new StringBuilder("1234567890");
 		assertEquals("12345890", testStringBuilder.delete(5,7).toString());
+
+
+		testStringBuilder = new StringBuilder("1234567890");
+		assertEquals("1234567890", testStringBuilder.delete(5,5).toString());
+
+
 		testStringBuilder = new StringBuilder("1234567890");
 		assertEquals("71234567890", testStringBuilder.insert(0,7).toString());
 		testStringBuilder = new StringBuilder("1234567890");
 		assertEquals("1true234567890", testStringBuilder.insert(1,true).toString());
+
+		String s = null;
+		assertEquals("Hallonull", new StringBuilder("Hallo").append(s).toString());
 	}
 
 

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

@@ -4,6 +4,14 @@ import org.junit.jupiter.api.Test;
 
 public class SwitchSyntax {
 
+	final int k = 0;
+
+	public SwitchSyntax() {
+		switch(1) {
+
+		}
+	}
+
 	@Test
 	public void switchSyntax() {
 
@@ -16,13 +24,33 @@ public class SwitchSyntax {
 				break;
 				}
 			case 3:
-			default:
+			default: {
 				int j;
 				System.out.println("default");
+			}
+
 		}
 	}
 	// Todo SeEi
 
+	@Test
+	public void switchWithComputation() {
+
+		final int i = 3;
+
+		switch(getSwitchBEdingung()) {
+			case i:
+				System.out.println("i");
+				break;
+			case i-1:
+				System.out.println("i-1");
+			default:
+				System.out.println("Was anderes");
+		}
+
+
+	}
+
 	@Test
 	public void switchString() {
 		switch (getString()) {
@@ -48,6 +76,22 @@ public class SwitchSyntax {
 
 	}
 
+	@Test
+	public void testFinal() {
+
+		final int i = 1;
+		final int j;
+		j = 2;
+
+		switch(getSwitchBEdingung()) {
+			case i:
+				System.out.println("i");
+			case k:
+
+		}
+
+	}
+
 	private Integer getSwitchBEdingung() {
 		return new Integer(1);
 	}

src/org/eidecker/oca8lernen/lastminute/AlternativeMain.java

@@ -0,0 +1,15 @@
+package org.eidecker.oca8lernen.lastminute;
+
+public class AlternativeMain {
+
+	public static void main(String... args) {
+		System.out.println("Geht auch mit varargs");
+		for (String arg : args) {
+			System.out.println(arg);
+		}
+	}
+
+
+
+
+}

src/org/eidecker/oca8lernen/lastminute/ArrayThings.java

@@ -0,0 +1,35 @@
+package org.eidecker.oca8lernen.lastminute;
+
+import org.junit.jupiter.api.Test;
+
+public class ArrayThings {
+
+	@Test
+	public void funWithArrays() {
+		int [][] a = {{1,2}, {1}};
+		System.out.println("Hallo");
+
+		String [] strings;
+
+		long [][] b = {{1,2}, {1}};
+
+		int[] ints;
+		long [] longs;
+
+	/*	longs = (long[])ints;
+
+		a = (int[][])b;
+
+		if (a instanceof long[][])
+
+		if (strings instanceof String[])*/
+	}
+
+	@Test
+	public void someMoreFun() {
+		short[][][][] b2 = new short[2][3][2][2];
+		b2[1][1] = new short[4][4];
+		System.out.println(b2);
+	}
+
+}

src/org/eidecker/oca8lernen/lastminute/Aufgabe10.java

@@ -0,0 +1,29 @@
+package org.eidecker.oca8lernen.lastminute;
+
+public class Aufgabe10 {
+}
+
+class Ping extends Utils {
+	public static void main(String[] args) throws Exception {
+		Utils u = new Ping();
+		System.out.println(u.getInt(args[0]));
+	}
+
+	int getInt(String a) {
+		//return super.getInt(a);
+		return Integer.parseInt(a);
+	}
+}
+
+class Utils {
+	int getInt(String x) throws Exception {
+		return 7;
+	}
+}
+
+/*
+interface Integer {
+	static int parseInt(String s) throws Exception {
+		return 4;
+	}
+}*/

src/org/eidecker/oca8lernen/lastminute/EnumTesting.java

@@ -0,0 +1,29 @@
+package org.eidecker.oca8lernen.lastminute;
+
+import org.junit.jupiter.api.Test;
+import static org.eidecker.oca8lernen.lastminute.MILCH.VOLL;
+
+enum MILCH {
+	VOLL(1);
+
+	private final String getValue() {
+		return values().toString();
+	}
+
+
+	MILCH(int n) {
+
+	}
+
+}
+
+public class EnumTesting {
+
+	private enum MILCH {VOLL, FETTARM, HALBFETT}
+
+	@Test
+	public void test() {
+		System.out.println(VOLL);
+	}
+
+}

src/org/eidecker/oca8lernen/lastminute/InterfacesDefault.java

@@ -0,0 +1,52 @@
+package org.eidecker.oca8lernen.lastminute;
+
+import org.junit.jupiter.api.Test;
+
+public class InterfacesDefault implements I1, I2{
+
+
+	@Override
+	public void method() {
+		System.out.println("Aus InterfacesDefault");
+		//System.out.println(s2);
+		//I1.super.method();
+
+		//System.out.println(I1.s);
+	}
+}
+
+class Außerhalb {
+
+	@Test
+	public void someMethod() {
+		I1 i1 = new InterfacesDefault();
+		i1.method();
+		System.out.println(i1.s);
+		System.out.println(i1.s2);
+
+		InterfacesDefault i2 = new InterfacesDefault();
+		i2.method();
+		System.out.println(((I1) i2).s);
+		System.out.println(((I2) i2).s);
+		//System.out.println(i2.s);
+
+	}
+
+}
+
+interface I1 {
+
+	String s = "Hallo";
+	String s2 = "Noch einer";
+
+	default void method() {
+		System.out.println("Aus I2");
+	}
+}
+
+interface I2 {
+
+	String s = "Welt";
+
+	void method();
+}

src/org/eidecker/oca8lernen/lastminute/Kleinigkeiten.java

@@ -0,0 +1,142 @@
+package org.eidecker.oca8lernen.lastminute;
+
+import java.io.Serializable;
+import java.time.LocalDate;
+import java.time.LocalTime;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.ThreadFactory;
+import org.eidecker.oca8lernen.lastminute.hilfspackage.KlasseInEinemAnderenPackage;
+import org.junit.jupiter.api.Test;
+
+public class Kleinigkeiten {
+
+	// Methoden dürfen private final sein (final sinnlos)
+	private final String methode() {
+		LocalTime t1 = LocalTime.now();
+		LocalDate t2 = LocalDate.now();
+
+		// t1 instanceof t2;
+
+
+		return "Sinnlos";
+
+
+	}
+
+	@Test
+	public void testIfElseDerHoelle() {
+		if (false)
+			if (false) System.out.println("0");
+				else System.out.println("1");
+//				 else System.out.println("2");
+	}
+
+	public void variabennamen (int i) {
+		// for (int i = i; )
+		// char c = 1.0;
+	}
+
+	@Test
+	public void removeFromArrayList() {
+		List<Integer> iList = new ArrayList<>();
+		iList.add(1);
+		iList.add(1);
+		iList.add(2);
+		iList.remove(new Integer(1));
+	}
+
+	@Test
+	public void testPackagePolymorphie() {
+		List<Oberklasse> oberklassen = Arrays.asList(new Oberklasse(), new KlasseInEinemAnderenPackage());
+		for (Oberklasse ober : oberklassen) {
+			ober.packageMethode();
+			if (ober instanceof KlasseInEinemAnderenPackage) {
+				KlasseInEinemAnderenPackage k = (KlasseInEinemAnderenPackage) ober;
+				// k.packageMethode();
+			}
+		}
+	}
+
+	@Test
+	public void testCast() {
+		Oberklasse oberklasse;
+		KlasseInEinemAnderenPackage unterklasse = new KlasseInEinemAnderenPackage();
+
+		oberklasse = (KlasseInEinemAnderenPackage) unterklasse;
+
+	}
+
+	@Test
+	public void wrapperSindImmutable() {
+		Integer I1 = 42;
+		Integer I2 = I1;
+		System.out.println(I1 == I2);
+		I1 += 1;
+		System.out.println(I1 == I2);
+
+
+		System.out.println(I1);
+
+	}
+
+	@Test
+	public void laengen() {
+		int[] a = {};
+		int i = a.length;
+
+		"Hallo".length();
+		new StringBuilder("Hallo").length();
+
+		new ArrayList<>().size();
+	}
+
+	@Test
+	public void incrementInFor() {
+
+		int j = 0;
+		for (j = 0; j < 6; System.out.println("Anweisung in Schleife" + j++)) {
+			System.out.println(j);
+			if (j == 3) break;
+		}
+		System.out.println("Ende: " + j);
+
+	}
+
+	@Test
+	public void schleifenvariablenSichtbarkeit() {
+		int[] ints = {1,2,3,4,5,6};
+		for (int i = 0; i < 10; i++) {
+			for (int i2 : ints) {
+				System.out.println(i + ": " + i2);
+				for (;i2<2;) {
+					System.out.println("Ganz innen " + i2);
+					break;
+				}
+			}
+		}
+
+	}
+
+}
+
+
+abstract class AbstrakteKlasse {
+	// private abstract verboten (auch sinnlos)
+	/* private */ abstract void sinnloseDefinition();
+}
+
+interface MySuperInterface extends Serializable, ThreadFactory {
+	default void m1() {
+
+	}
+
+	public abstract void my();
+}
+
+interface MyOtherSuperInterface {
+	default void m1() {
+
+	}
+}

src/org/eidecker/oca8lernen/lastminute/Oberklasse.java

@@ -0,0 +1,29 @@
+package org.eidecker.oca8lernen.lastminute;
+
+import org.eidecker.oca8lernen.lastminute.hilfspackage.PublicClassInEinemAnderenPackage;
+import org.junit.jupiter.api.Test;
+
+public class Oberklasse {
+
+	static protected String feldInOberklasse;
+
+	public final void publicMethode() {
+		System.out.println("Public");
+	}
+
+	private final void privateMethode() {
+
+	}
+
+	@Test
+	public void test() {
+		PublicClassInEinemAnderenPackage publicClassInEinemAnderenPackage = new PublicClassInEinemAnderenPackage();
+		publicClassInEinemAnderenPackage.publicMethode();
+
+	}
+
+	final void packageMethode() {
+		System.out.println("packageMethode in Oberklasse");
+	}
+
+}

src/org/eidecker/oca8lernen/lastminute/StaticSichtbarkeit.java

@@ -0,0 +1,78 @@
+package org.eidecker.oca8lernen.lastminute;
+
+import org.junit.jupiter.api.Test;
+
+public class StaticSichtbarkeit {
+
+	@Test
+	public void testSichtbarkeit() {
+		Ober ober = new Unter();
+		ober.methode2(ober); // Ober, da zur Compilezeit ausgewählt (Bei Überladen würde nur die Signatur gewählt!)
+
+		System.out.println(ober.s);
+
+		String a = "";
+		a += "Welt";
+		// a -= "Welte";
+		String b = null;
+		System.out.println(b instanceof Object);
+
+
+
+
+	}
+
+}
+
+interface Interface {
+	static void methode2(Ober ober) {
+		System.out.println("Interface");
+	}
+
+	static void methode3(Ober ober) {
+		System.out.println("Interface");
+	}
+}
+
+
+class Ober implements Interface {
+
+	public static String s = "OberStatic";
+
+	private final void geheimeMethode() {
+
+	}
+
+	static void methode2(Ober ober) {
+		System.out.println("Ober");
+	}
+
+	void methode3(Ober ober) {
+
+	}
+
+
+}
+
+class Unter extends Ober {
+
+	public String s = "UnterNichtStatic";
+
+	public void geheimeMethode() {
+
+	}
+
+	static void methode2(Unter unter) {
+		System.out.println("Unter");
+	}
+
+	static void methode2(Ober ober) {
+		int €¥£ = 12;
+
+		System.out.println("Ober übergeben in Unter");
+	}
+
+
+
+}
+

src/org/eidecker/oca8lernen/lastminute/castbaeume/Baum.java

@@ -0,0 +1,31 @@
+package org.eidecker.oca8lernen.lastminute.castbaeume;
+
+import org.junit.jupiter.api.Test;
+
+public class Baum {
+
+	@Test
+	public void testGraphCast() {
+		I i = new C();
+		I i2 = (C)new A();
+		I2 i3 = (C)new A();
+		I2 i4 = (C)new B();
+	}
+}
+
+
+/*
+	A
+	|
+	B-I
+	|
+	C-I2
+ */
+interface I {}
+interface I2 {}
+
+class A {}
+
+class B extends A implements I {}
+
+class C extends B implements I2 {}

src/org/eidecker/oca8lernen/lastminute/castbaeume/Graph.java

@@ -0,0 +1,35 @@
+package org.eidecker.oca8lernen.lastminute.castbaeume;
+
+import org.junit.jupiter.api.Test;
+
+public class Graph {
+
+	@Test
+	public void testSomeCasts() {
+		D f = new F();
+		E e;
+		e = (E)f;
+	}
+
+	@Test
+	public void testArrayAssignment() {
+		D[] ds = {};
+		E[] es = {};
+
+		es = (E[])ds;
+
+		ds = (D[])es;
+	}
+
+}
+
+/*
+	D
+	|-----
+	|    |
+	E    F
+ */
+
+class D {}
+class E extends D {}
+class F extends D {}

src/org/eidecker/oca8lernen/lastminute/hilfspackage/KlasseInEinemAnderenPackage.java

@@ -0,0 +1,46 @@
+package org.eidecker.oca8lernen.lastminute.hilfspackage;
+
+import org.eidecker.oca8lernen.lastminute.Oberklasse;
+import org.junit.jupiter.api.Test;
+
+import java.io.IOException;
+
+public class KlasseInEinemAnderenPackage extends Oberklasse {
+
+	protected String feldInOberklasse;
+
+	void privateMethode() {
+		try {
+			// anotherOne();
+		} catch (Exception e) {
+
+		}
+	}
+
+	void anotherOne() throws IOException {
+
+	}
+
+	/*void publicMethode() {
+
+	}*/
+
+	void packageMethode() {
+		System.out.println("packageMethode in KlasseInEinemAnderenPackage");
+	}
+
+}
+
+class AuchInEinemAnderenPackage {
+
+	public void publicMethode() {
+		System.out.println("Public AuchInEinemAnderenPackage");
+	}
+
+	@Test
+	public void testMe() {
+		KlasseInEinemAnderenPackage klasseInEinemAnderenPackage = new KlasseInEinemAnderenPackage();
+		klasseInEinemAnderenPackage.publicMethode();
+	}
+
+}

src/org/eidecker/oca8lernen/lastminute/hilfspackage/PublicClassInEinemAnderenPackage.java

@@ -0,0 +1,30 @@
+package org.eidecker.oca8lernen.lastminute.hilfspackage;
+
+public class PublicClassInEinemAnderenPackage extends AuchInEinemAnderenPackage {
+
+	public static void main(String[] args) {
+		"Hallo".concat("Test");
+	}
+
+	public static String s;
+
+}
+
+class NochEineSub extends PublicClassInEinemAnderenPackage {
+	public String s = "nicht statisch";
+
+	public static void main(String[] args) {
+		PublicClassInEinemAnderenPackage n = new NochEineSub();
+		System.out.println(n.s);
+		int k;
+		int j=k=3;
+		System.out.println(k);
+		System.out.println(j);
+
+		 int i = Integer.MIN_VALUE;
+		 int i2 = -i;
+		System.out.println(i);
+		 System.out.println(i2);
+
+	}
+}