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..7ac1f23 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,120 @@ 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 + } + + public void methode2 (int[] name) { + methode(1, 2, 3); + int [] ints = {1,2,3}; + methode(ints); + } + + @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/Primitive.java b/src/org/eidecker/oca8lernen/general/Primitive.java new file mode 100644 index 0000000..31b7b4a --- /dev/null +++ b/src/org/eidecker/oca8lernen/general/Primitive.java @@ -0,0 +1,108 @@ +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; + + } + + @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 c64e3e0..2d1e386 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() { @@ -48,6 +53,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); }