Notizen aus Lernsessions

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

@@ -0,0 +1,154 @@
+package org.eidecker.oca8lernen.general;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+
+import static org.eidecker.oca8lernen.general.PrimitiveOverloading.*;
+import static org.eidecker.oca8lernen.general.Overloading.*;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class Overloading {
+
+	public final String overrideMe(List list) {
+		return list.toString();
+	}
+
+	public String overloadMe() {
+		return "1";
+	}
+
+	public void overloadMe(List list) {
+	}
+
+	public void overloadMe(ArrayList list) {
+	}
+
+	public String overloadMe(LinkedList list) {
+		return "1";
+	}
+
+	public List overloadList(List list) {
+		return null;
+	}
+
+	// Rückgabewert irrelevant bei Überladen
+	/*public ArrayList overloadList(List list) {
+		return null;
+	}*/
+
+}
+
+
+class SubOverloading extends Overloading {
+	public static final String VARIANTE_CHARACTER = "Variante Character";
+
+	/**
+	 * Nicht erlaubt, da aus Oberklasse überladen. Rückgabewert kann nicht
+	 * überladen werden.
+	 */
+	//public List overloadMe(List list) {
+	//}
+
+	/**
+	 * Neue Methode, nicht überschrieben. Daher Access-Modifier in Ordnung.
+	 */
+	private String overrideMe(String list) {
+		return "Geht";
+	}
+
+	/**
+	 * Nicht erlaubt, da Überschreiben verboten durch final.
+	 * Sichtbarkeit ändert nichts.
+	 */
+	/*private String overrideMe(List list) {
+		return "1";
+	}*/
+
+	/**
+	 * Auch neue Methode, nicht überschrieben. Daher Access-Modifier in Ordnung.
+	 */
+	private String overrideMe(ArrayList list) {
+		return "Subtyp geht nicht";
+	}
+}
+
+
+class PrimitiveOverloading {
+
+	public static final String VARIANTE_CHARACTER = "Variante Character";
+	public static final String VARIANTE_LONG_WRAPPER = "Variante Long";
+	public static final String VARIANTE_INT = "Variante int";
+	public static final String VARIANTE_LONG_PRIMITIVE = "Variante long";
+	public static final String VARIANTE_CHAR = "Variante char";
+	public static final String VARIANTE_INTEGER = "Variante Integer";
+	public static final String VARIANTE_BYTE = "Variante byte";
+
+	public String overloadMe(int i) {
+		System.out.println(VARIANTE_INT);
+		return VARIANTE_INT;
+	}
+
+	public String overloadMe(long l) {
+		System.out.println(VARIANTE_LONG_PRIMITIVE);
+		return VARIANTE_LONG_PRIMITIVE;
+	}
+
+	public String overloadMe(char c) {
+		System.out.println(VARIANTE_CHAR);
+		return VARIANTE_CHAR;
+	}
+
+	public String overloadMe(Integer integer) {
+		System.out.println(VARIANTE_INTEGER);
+		return VARIANTE_INTEGER;
+	}
+
+	public String overloadMe(Long l) {
+		System.out.println(VARIANTE_LONG_WRAPPER);
+		return VARIANTE_LONG_WRAPPER;
+	}
+
+	public String overloadMe(Character character) {
+		System.out.println(VARIANTE_CHARACTER);
+		return VARIANTE_CHARACTER;
+	}
+
+	public String overloadMe(byte b) {
+		System.out.println(VARIANTE_BYTE);
+		return VARIANTE_BYTE;
+	}
+
+}
+
+class PrimitiveOverloadingTester {
+
+	@Test
+	public void testOverloadPrimitives() {
+		PrimitiveOverloading primitiveOverloading = new PrimitiveOverloading();
+
+		// Wrapper
+		assertEquals(VARIANTE_LONG_WRAPPER, primitiveOverloading.overloadMe(new Long(1L)));
+		assertEquals(VARIANTE_INTEGER, primitiveOverloading.overloadMe(new Integer(1)));
+		assertEquals(VARIANTE_CHARACTER, primitiveOverloading.overloadMe(new Character('a')));
+
+		// Primitiv
+		assertEquals(VARIANTE_INT, primitiveOverloading.overloadMe(1));
+		assertEquals(VARIANTE_LONG_PRIMITIVE, primitiveOverloading.overloadMe(1L));
+		assertEquals(VARIANTE_CHAR, primitiveOverloading.overloadMe('a'));
+
+		// Wrapper, nicht vorhanden, aber primitv
+		assertEquals(VARIANTE_BYTE, primitiveOverloading.overloadMe(new Byte("1")));
+
+		// Wrapper, nicht vorhanden, primitiv nur mit autocast. Dann auf int
+		assertEquals(VARIANTE_INT, primitiveOverloading.overloadMe(new Short("1")));
+
+		// Primitiv, nicht vorhanden, auch kein Wrapper
+		assertEquals(VARIANTE_INT, primitiveOverloading.overloadMe((short) 1));
+
+
+	}
+
+}

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

@@ -0,0 +1,18 @@
+package org.eidecker.oca8lernen.general;
+
+public class PrivateConstructorExtends {
+
+	private PrivateConstructorExtends() {
+
+	}
+}
+
+
+class Subclass { // extends PrivateConstructorExtends { // Nicht möglich, da kein Konstruktor in der Oberklasse erreichbar
+
+}
+
+
+class PrivateConstrucctorExtendsTester {
+
+}

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

@@ -0,0 +1,37 @@
+package org.eidecker.oca8lernen.general;
+
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class TernaryTest {
+
+	@Test
+	public void testTernaryOperator() {
+
+		int i = 3;
+
+
+		String s = i == 2 ?
+				"1" :
+				i == 3 ?
+						"2" : "3";
+
+		assertEquals("2", s);
+
+		// Reine Seiteneffekte nicht erlaubt
+		// s = true ? System.out.println("Hallo") : System.out.println("Welt");
+
+		s = i == 2 ? "1" : mitSeitenEffekt();
+
+		s = i == 2 ? "1" : mitSeitenEffekt();
+
+	}
+
+	private String mitSeitenEffekt() {
+		System.out.println("Hallo");
+		return "1";
+	}
+
+}