Merge branch 'master' of https://git.eidecker.info/sebastian/oca8-lernen

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/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 {
+
+}

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

@@ -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() {
+
+	}
+
+
 }
 
-
+class AnotherImplementer implements SuperInterface1 {
-abstract class AbstractClass implements AnInterface {
 
 	@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();
+	}
+}

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/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/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() {
+
+	}
+
+
+
+
+}

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/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);
 	}

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/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<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() {
+
+	}
+}
+
+interface MyOtherSuperInterface {
+	default void m1() {
+
+	}
+}

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");
+	}
+
+}

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");
+	}
+
+
+
+}
+

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,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 {}

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");
+	}
+
+}