diff --git a/src/org/eidecker/oca8lernen/chapter01/EnumOne.java b/src/org/eidecker/oca8lernen/chapter01/EnumOne.java index cc2a170..e9671a4 100644 --- a/src/org/eidecker/oca8lernen/chapter01/EnumOne.java +++ b/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; diff --git a/src/org/eidecker/oca8lernen/general/CastExceptions.java b/src/org/eidecker/oca8lernen/general/CastExceptions.java index f491790..5526949 100644 --- a/src/org/eidecker/oca8lernen/general/CastExceptions.java +++ b/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,37 @@ 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{ + + } + } class UnterCast extends OberCast { + @Override + public void method() { + System.out.println("method in Untercast"); + } } class Außerhalb { } + +class MyCheckedException extends Exception { + +} diff --git a/src/org/eidecker/oca8lernen/general/ConditionalInitialisation.java b/src/org/eidecker/oca8lernen/general/ConditionalInitialisation.java new file mode 100644 index 0000000..6de0dec --- /dev/null +++ b/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); + + } + +} diff --git a/src/org/eidecker/oca8lernen/general/DoubleImplementsClash.java b/src/org/eidecker/oca8lernen/general/DoubleImplementsClash.java index a95704c..935599e 100644 --- a/src/org/eidecker/oca8lernen/general/DoubleImplementsClash.java +++ b/src/org/eidecker/oca8lernen/general/DoubleImplementsClash.java @@ -2,6 +2,8 @@ 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; /** @@ -11,28 +13,123 @@ 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 WorkingClass extends AbstractClass implements AnInterface { +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 method1() throws AccessDeniedException { + public void bothAbstract() { } + + public void bothDefault() { + SuperInterface1.super.bothDefault(); + + + } + + public void oneStaticOneAbstract() { + + } + + } - -abstract class AbstractClass implements AnInterface { +class AnotherImplementer implements SuperInterface1 { @Override - public abstract void method1() throws AccessDeniedException; -} + public void bothAbstract() { -interface AnInterface { - default void method1() throws IOException { + } + + @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(); + } +} diff --git a/src/org/eidecker/oca8lernen/general/FunWithArrays.java b/src/org/eidecker/oca8lernen/general/FunWithArrays.java new file mode 100644 index 0000000..e289d1d --- /dev/null +++ b/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(); + + } +} diff --git a/src/org/eidecker/oca8lernen/general/Loop.java b/src/org/eidecker/oca8lernen/general/Loop.java new file mode 100644 index 0000000..597c40e --- /dev/null +++ b/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); + } + +} diff --git a/src/org/eidecker/oca8lernen/general/Primitive.java b/src/org/eidecker/oca8lernen/general/Primitive.java new file mode 100644 index 0000000..7c9afaf --- /dev/null +++ b/src/org/eidecker/oca8lernen/general/Primitive.java @@ -0,0 +1,125 @@ +package org.eidecker.oca8lernen.general; + +import org.junit.jupiter.api.Test; + +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; + +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; + + 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); + + + } + + @Test + public void testExplicitCast() { + + } + + + + +} diff --git a/src/org/eidecker/oca8lernen/general/Spielen.java b/src/org/eidecker/oca8lernen/general/Spielen.java new file mode 100644 index 0000000..53af0b9 --- /dev/null +++ b/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); + } +} diff --git a/src/org/eidecker/oca8lernen/general/SwitchSyntax.java b/src/org/eidecker/oca8lernen/general/SwitchSyntax.java index 87fd1ac..560cf46 100644 --- a/src/org/eidecker/oca8lernen/general/SwitchSyntax.java +++ b/src/org/eidecker/oca8lernen/general/SwitchSyntax.java @@ -4,6 +4,11 @@ import org.junit.jupiter.api.Test; public class SwitchSyntax { + final int k = 0; + + public SwitchSyntax() { + } + @Test public void switchSyntax() { @@ -66,6 +71,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); } diff --git a/src/org/eidecker/oca8lernen/lastminute/AlternativeMain.java b/src/org/eidecker/oca8lernen/lastminute/AlternativeMain.java new file mode 100644 index 0000000..4a4d0d8 --- /dev/null +++ b/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); + } + } + + + + +} diff --git a/src/org/eidecker/oca8lernen/lastminute/ArrayThings.java b/src/org/eidecker/oca8lernen/lastminute/ArrayThings.java new file mode 100644 index 0000000..7d83a03 --- /dev/null +++ b/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); + } + +} diff --git a/src/org/eidecker/oca8lernen/lastminute/Aufgabe10.java b/src/org/eidecker/oca8lernen/lastminute/Aufgabe10.java new file mode 100644 index 0000000..d00662d --- /dev/null +++ b/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; + } +}*/ diff --git a/src/org/eidecker/oca8lernen/lastminute/EnumTesting.java b/src/org/eidecker/oca8lernen/lastminute/EnumTesting.java new file mode 100644 index 0000000..f64d1c5 --- /dev/null +++ b/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); + } + +} diff --git a/src/org/eidecker/oca8lernen/lastminute/Kleinigkeiten.java b/src/org/eidecker/oca8lernen/lastminute/Kleinigkeiten.java new file mode 100644 index 0000000..3b26733 --- /dev/null +++ b/src/org/eidecker/oca8lernen/lastminute/Kleinigkeiten.java @@ -0,0 +1,117 @@ +package org.eidecker.oca8lernen.lastminute; + +import org.eidecker.oca8lernen.lastminute.hilfspackage.KlasseInEinemAnderenPackage; +import org.junit.jupiter.api.Test; + +import java.io.Serializable; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.concurrent.ThreadFactory; + +public class Kleinigkeiten { + + // Methoden dürfen private final sein (final sinnlos) + private final String methode() { + return "Sinnlos"; + } + + @Test + public void testIfElseDerHoelle() { + if (false) + if (false) System.out.println("0"); + else System.out.println("1"); + // else System.out.println("2"); + } + + @Test + public void testPackagePolymorphie() { + List 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() { + + } +} + +interface MyOtherSuperInterface { + default void m1() { + + } +} diff --git a/src/org/eidecker/oca8lernen/lastminute/Oberklasse.java b/src/org/eidecker/oca8lernen/lastminute/Oberklasse.java new file mode 100644 index 0000000..ead82fb --- /dev/null +++ b/src/org/eidecker/oca8lernen/lastminute/Oberklasse.java @@ -0,0 +1,17 @@ +package org.eidecker.oca8lernen.lastminute; + +public class Oberklasse { + + public final void publicMethode() { + + } + + private final void privateMethode() { + + } + + final void packageMethode() { + System.out.println("packageMethode in Oberklasse"); + } + +} diff --git a/src/org/eidecker/oca8lernen/lastminute/StaticSichtbarkeit.java b/src/org/eidecker/oca8lernen/lastminute/StaticSichtbarkeit.java new file mode 100644 index 0000000..c7fe912 --- /dev/null +++ b/src/org/eidecker/oca8lernen/lastminute/StaticSichtbarkeit.java @@ -0,0 +1,50 @@ +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!) + + Unter.methode2(ober); + } + +} + + +class Ober { + + private final void geheimeMethode() { + + } + + static void methode2(Ober ober) { + System.out.println("Ober"); + } + + +} + +class Unter extends Ober { + + 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"); + } + + + +} + diff --git a/src/org/eidecker/oca8lernen/lastminute/castbaeume/Baum.java b/src/org/eidecker/oca8lernen/lastminute/castbaeume/Baum.java new file mode 100644 index 0000000..0fe2deb --- /dev/null +++ b/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 {} \ No newline at end of file diff --git a/src/org/eidecker/oca8lernen/lastminute/castbaeume/Graph.java b/src/org/eidecker/oca8lernen/lastminute/castbaeume/Graph.java new file mode 100644 index 0000000..628c51f --- /dev/null +++ b/src/org/eidecker/oca8lernen/lastminute/castbaeume/Graph.java @@ -0,0 +1,25 @@ +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; + } + +} + +/* + D + |----- + | | + E F + */ + +class D {} +class E extends D {} +class F extends D {} \ No newline at end of file diff --git a/src/org/eidecker/oca8lernen/lastminute/hilfspackage/KlasseInEinemAnderenPackage.java b/src/org/eidecker/oca8lernen/lastminute/hilfspackage/KlasseInEinemAnderenPackage.java new file mode 100644 index 0000000..799c4f0 --- /dev/null +++ b/src/org/eidecker/oca8lernen/lastminute/hilfspackage/KlasseInEinemAnderenPackage.java @@ -0,0 +1,19 @@ +package org.eidecker.oca8lernen.lastminute.hilfspackage; + +import org.eidecker.oca8lernen.lastminute.Oberklasse; + +public class KlasseInEinemAnderenPackage extends Oberklasse { + + void privateMethode() { + + } + + /*void publicMethode() { + + }*/ + + void packageMethode() { + System.out.println("packageMethode in KlasseInEinemAnderenPackage"); + } + +}