From 35cb084a481aa24750fd8ba0a2eefc617be748bb Mon Sep 17 00:00:00 2001 From: Sebastian Eidecker Date: Sun, 27 Oct 2019 21:16:27 +0100 Subject: [PATCH] Notizen aus Lernsessions --- .../oca8lernen/general/Overloading.java | 154 ++++++++++++++++++ .../general/PrivateConstructorExtends.java | 18 ++ .../oca8lernen/general/TernaryTest.java | 37 +++++ 3 files changed, 209 insertions(+) create mode 100644 src/org/eidecker/oca8lernen/general/Overloading.java create mode 100644 src/org/eidecker/oca8lernen/general/PrivateConstructorExtends.java create mode 100644 src/org/eidecker/oca8lernen/general/TernaryTest.java diff --git a/src/org/eidecker/oca8lernen/general/Overloading.java b/src/org/eidecker/oca8lernen/general/Overloading.java new file mode 100644 index 0000000..88a632d --- /dev/null +++ b/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)); + + + } + +} diff --git a/src/org/eidecker/oca8lernen/general/PrivateConstructorExtends.java b/src/org/eidecker/oca8lernen/general/PrivateConstructorExtends.java new file mode 100644 index 0000000..8f131dc --- /dev/null +++ b/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 { + +} diff --git a/src/org/eidecker/oca8lernen/general/TernaryTest.java b/src/org/eidecker/oca8lernen/general/TernaryTest.java new file mode 100644 index 0000000..d1cc7ed --- /dev/null +++ b/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"; + } + +}