From 1d09da4811363c6889b2340e6220346afd8293cd Mon Sep 17 00:00:00 2001
From: stedS <sven.steddin@reutlingen-university.de>
Date: Thu, 5 Dec 2019 02:09:42 +0100
Subject: [PATCH] Uebertragung Beispiele fuer VL04.04
---
VL04_04/CallByRef-C/.classpath | 6 ++
VL04_04/CallByRef-C/.project | 17 +++++
.../.settings/org.eclipse.jdt.core.prefs | 11 ++++
VL04_04/CallByRef-C/src/CallByRef.java | 36 +++++++++++
VL04_04/CallByRefArray-C/.classpath | 6 ++
VL04_04/CallByRefArray-C/.project | 17 +++++
.../.settings/org.eclipse.jdt.core.prefs | 11 ++++
VL04_04/CallByRefArray-C/bin/.gitignore | 1 +
.../src/inf3/CallByRefArray.java | 51 +++++++++++++++
VL04_04/CallByRef_Part2-C/.classpath | 6 ++
VL04_04/CallByRef_Part2-C/.project | 17 +++++
.../.settings/org.eclipse.jdt.core.prefs | 11 ++++
VL04_04/CallByRef_Part2-C/bin/.gitignore | 1 +
.../src/inf3/CallByRef_Part2.java | 64 +++++++++++++++++++
.../CallByRef_Part2-C/src/inf3/RefClass.java | 15 +++++
VL04_04/CallByVal-C/.classpath | 6 ++
VL04_04/CallByVal-C/.project | 17 +++++
.../.settings/org.eclipse.jdt.core.prefs | 11 ++++
VL04_04/CallByVal-C/src/CallByVal.java | 32 ++++++++++
VL04_04/Doublefehler-C/.classpath | 6 ++
VL04_04/Doublefehler-C/.project | 17 +++++
.../.settings/org.eclipse.jdt.core.prefs | 11 ++++
VL04_04/Doublefehler-C/src/Doublefehler.java | 27 ++++++++
VL04_04/DownCast_PosToNeg-C/.classpath | 6 ++
VL04_04/DownCast_PosToNeg-C/.project | 17 +++++
.../.settings/org.eclipse.jdt.core.prefs | 11 ++++
.../src/DownCast_Demo.java | 22 +++++++
VL04_04/EqualsDemo-C/.classpath | 6 ++
VL04_04/EqualsDemo-C/.project | 17 +++++
.../.settings/org.eclipse.jdt.core.prefs | 11 ++++
VL04_04/EqualsDemo-C/src/EqualsDemo.java | 41 ++++++++++++
VL04_04/ForEachDemo-C/.classpath | 6 ++
VL04_04/ForEachDemo-C/.project | 17 +++++
.../.settings/org.eclipse.jdt.core.prefs | 11 ++++
VL04_04/ForEachDemo-C/bin/.gitignore | 1 +
.../ForEachDemo-C/src/inf3/ForEachDemo.java | 28 ++++++++
VL04_04/ImmutableWrapper-C/.classpath | 6 ++
VL04_04/ImmutableWrapper-C/.project | 17 +++++
.../.settings/org.eclipse.jdt.core.prefs | 11 ++++
VL04_04/ImmutableWrapper-C/bin/.gitignore | 1 +
.../src/inf3/ImmutableWrapper.java | 45 +++++++++++++
VL04_04/InitArray-C/.classpath | 10 +++
VL04_04/InitArray-C/.gitignore | 1 +
VL04_04/InitArray-C/.project | 17 +++++
.../.settings/org.eclipse.jdt.core.prefs | 14 ++++
VL04_04/InitArray-C/src/inf3/InitArray.java | 26 ++++++++
VL04_04/InitDemo1-C/.classpath | 6 ++
VL04_04/InitDemo1-C/.project | 17 +++++
VL04_04/InitDemo1-C/src/InitDemo1.java | 44 +++++++++++++
.../InitDemo1-C/src/InitDemo1_Loesung.java | 52 +++++++++++++++
VL04_04/ReferenzielleIdent-C/.classpath | 6 ++
VL04_04/ReferenzielleIdent-C/.project | 17 +++++
.../.settings/org.eclipse.jdt.core.prefs | 11 ++++
.../ReferenzielleIdent.java | 33 ++++++++++
VL04_04/StringBufPerformance-C/.classpath | 6 ++
VL04_04/StringBufPerformance-C/.project | 17 +++++
.../.settings/org.eclipse.jdt.core.prefs | 11 ++++
VL04_04/StringBufPerformance-C/bin/.gitignore | 1 +
.../src/inf/StringBufPerformance.java | 40 ++++++++++++
VL04_04/StringGen1-C/.classpath | 6 ++
VL04_04/StringGen1-C/.project | 17 +++++
.../org.eclipse.core.resources.prefs | 2 +
.../.settings/org.eclipse.jdt.core.prefs | 11 ++++
VL04_04/StringGen1-C/src/StringGen1.java | 49 ++++++++++++++
VL04_04/StringMethoden-C/.classpath | 6 ++
VL04_04/StringMethoden-C/.project | 17 +++++
.../.settings/org.eclipse.jdt.core.prefs | 11 ++++
VL04_04/StringMethoden-C/bin/.gitignore | 1 +
.../src/inf3/StringMethoden.java | 23 +++++++
VL04_04/TreeSetDemo-C/.classpath | 6 ++
VL04_04/TreeSetDemo-C/.project | 17 +++++
.../.settings/org.eclipse.jdt.core.prefs | 11 ++++
VL04_04/TreeSetDemo-C/bin/.gitignore | 1 +
.../TreeSetDemo-C/src/inf3/TreeSetDemo.java | 32 ++++++++++
74 files changed, 1210 insertions(+)
create mode 100644 VL04_04/CallByRef-C/.classpath
create mode 100644 VL04_04/CallByRef-C/.project
create mode 100644 VL04_04/CallByRef-C/.settings/org.eclipse.jdt.core.prefs
create mode 100644 VL04_04/CallByRef-C/src/CallByRef.java
create mode 100644 VL04_04/CallByRefArray-C/.classpath
create mode 100644 VL04_04/CallByRefArray-C/.project
create mode 100644 VL04_04/CallByRefArray-C/.settings/org.eclipse.jdt.core.prefs
create mode 100644 VL04_04/CallByRefArray-C/bin/.gitignore
create mode 100644 VL04_04/CallByRefArray-C/src/inf3/CallByRefArray.java
create mode 100644 VL04_04/CallByRef_Part2-C/.classpath
create mode 100644 VL04_04/CallByRef_Part2-C/.project
create mode 100644 VL04_04/CallByRef_Part2-C/.settings/org.eclipse.jdt.core.prefs
create mode 100644 VL04_04/CallByRef_Part2-C/bin/.gitignore
create mode 100644 VL04_04/CallByRef_Part2-C/src/inf3/CallByRef_Part2.java
create mode 100644 VL04_04/CallByRef_Part2-C/src/inf3/RefClass.java
create mode 100644 VL04_04/CallByVal-C/.classpath
create mode 100644 VL04_04/CallByVal-C/.project
create mode 100644 VL04_04/CallByVal-C/.settings/org.eclipse.jdt.core.prefs
create mode 100644 VL04_04/CallByVal-C/src/CallByVal.java
create mode 100644 VL04_04/Doublefehler-C/.classpath
create mode 100644 VL04_04/Doublefehler-C/.project
create mode 100644 VL04_04/Doublefehler-C/.settings/org.eclipse.jdt.core.prefs
create mode 100644 VL04_04/Doublefehler-C/src/Doublefehler.java
create mode 100644 VL04_04/DownCast_PosToNeg-C/.classpath
create mode 100644 VL04_04/DownCast_PosToNeg-C/.project
create mode 100644 VL04_04/DownCast_PosToNeg-C/.settings/org.eclipse.jdt.core.prefs
create mode 100644 VL04_04/DownCast_PosToNeg-C/src/DownCast_Demo.java
create mode 100644 VL04_04/EqualsDemo-C/.classpath
create mode 100644 VL04_04/EqualsDemo-C/.project
create mode 100644 VL04_04/EqualsDemo-C/.settings/org.eclipse.jdt.core.prefs
create mode 100644 VL04_04/EqualsDemo-C/src/EqualsDemo.java
create mode 100644 VL04_04/ForEachDemo-C/.classpath
create mode 100644 VL04_04/ForEachDemo-C/.project
create mode 100644 VL04_04/ForEachDemo-C/.settings/org.eclipse.jdt.core.prefs
create mode 100644 VL04_04/ForEachDemo-C/bin/.gitignore
create mode 100644 VL04_04/ForEachDemo-C/src/inf3/ForEachDemo.java
create mode 100644 VL04_04/ImmutableWrapper-C/.classpath
create mode 100644 VL04_04/ImmutableWrapper-C/.project
create mode 100644 VL04_04/ImmutableWrapper-C/.settings/org.eclipse.jdt.core.prefs
create mode 100644 VL04_04/ImmutableWrapper-C/bin/.gitignore
create mode 100644 VL04_04/ImmutableWrapper-C/src/inf3/ImmutableWrapper.java
create mode 100644 VL04_04/InitArray-C/.classpath
create mode 100644 VL04_04/InitArray-C/.gitignore
create mode 100644 VL04_04/InitArray-C/.project
create mode 100644 VL04_04/InitArray-C/.settings/org.eclipse.jdt.core.prefs
create mode 100644 VL04_04/InitArray-C/src/inf3/InitArray.java
create mode 100644 VL04_04/InitDemo1-C/.classpath
create mode 100644 VL04_04/InitDemo1-C/.project
create mode 100644 VL04_04/InitDemo1-C/src/InitDemo1.java
create mode 100644 VL04_04/InitDemo1-C/src/InitDemo1_Loesung.java
create mode 100644 VL04_04/ReferenzielleIdent-C/.classpath
create mode 100644 VL04_04/ReferenzielleIdent-C/.project
create mode 100644 VL04_04/ReferenzielleIdent-C/.settings/org.eclipse.jdt.core.prefs
create mode 100644 VL04_04/ReferenzielleIdent-C/ReferenzielleIdent.java
create mode 100644 VL04_04/StringBufPerformance-C/.classpath
create mode 100644 VL04_04/StringBufPerformance-C/.project
create mode 100644 VL04_04/StringBufPerformance-C/.settings/org.eclipse.jdt.core.prefs
create mode 100644 VL04_04/StringBufPerformance-C/bin/.gitignore
create mode 100644 VL04_04/StringBufPerformance-C/src/inf/StringBufPerformance.java
create mode 100644 VL04_04/StringGen1-C/.classpath
create mode 100644 VL04_04/StringGen1-C/.project
create mode 100644 VL04_04/StringGen1-C/.settings/org.eclipse.core.resources.prefs
create mode 100644 VL04_04/StringGen1-C/.settings/org.eclipse.jdt.core.prefs
create mode 100644 VL04_04/StringGen1-C/src/StringGen1.java
create mode 100644 VL04_04/StringMethoden-C/.classpath
create mode 100644 VL04_04/StringMethoden-C/.project
create mode 100644 VL04_04/StringMethoden-C/.settings/org.eclipse.jdt.core.prefs
create mode 100644 VL04_04/StringMethoden-C/bin/.gitignore
create mode 100644 VL04_04/StringMethoden-C/src/inf3/StringMethoden.java
create mode 100644 VL04_04/TreeSetDemo-C/.classpath
create mode 100644 VL04_04/TreeSetDemo-C/.project
create mode 100644 VL04_04/TreeSetDemo-C/.settings/org.eclipse.jdt.core.prefs
create mode 100644 VL04_04/TreeSetDemo-C/bin/.gitignore
create mode 100644 VL04_04/TreeSetDemo-C/src/inf3/TreeSetDemo.java
diff --git a/VL04_04/CallByRef-C/.classpath b/VL04_04/CallByRef-C/.classpath
new file mode 100644
index 0000000..63b7e89
--- /dev/null
+++ b/VL04_04/CallByRef-C/.classpath
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+ <classpathentry kind="src" path="src"/>
+ <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
+ <classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/VL04_04/CallByRef-C/.project b/VL04_04/CallByRef-C/.project
new file mode 100644
index 0000000..92b9a1a
--- /dev/null
+++ b/VL04_04/CallByRef-C/.project
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+ <name>CallByRef-C</name>
+ <comment></comment>
+ <projects>
+ </projects>
+ <buildSpec>
+ <buildCommand>
+ <name>org.eclipse.jdt.core.javabuilder</name>
+ <arguments>
+ </arguments>
+ </buildCommand>
+ </buildSpec>
+ <natures>
+ <nature>org.eclipse.jdt.core.javanature</nature>
+ </natures>
+</projectDescription>
diff --git a/VL04_04/CallByRef-C/.settings/org.eclipse.jdt.core.prefs b/VL04_04/CallByRef-C/.settings/org.eclipse.jdt.core.prefs
new file mode 100644
index 0000000..bb35fa0
--- /dev/null
+++ b/VL04_04/CallByRef-C/.settings/org.eclipse.jdt.core.prefs
@@ -0,0 +1,11 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
+org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
+org.eclipse.jdt.core.compiler.compliance=1.8
+org.eclipse.jdt.core.compiler.debug.lineNumber=generate
+org.eclipse.jdt.core.compiler.debug.localVariable=generate
+org.eclipse.jdt.core.compiler.debug.sourceFile=generate
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.source=1.8
diff --git a/VL04_04/CallByRef-C/src/CallByRef.java b/VL04_04/CallByRef-C/src/CallByRef.java
new file mode 100644
index 0000000..126d1b2
--- /dev/null
+++ b/VL04_04/CallByRef-C/src/CallByRef.java
@@ -0,0 +1,36 @@
+/**
+* CallByRef.java
+*
+* Das Programm verdeutlicht, dass die Übergabe eines Referenzdatentyps
+* als Parameter nicht automatisch bedeutet, dass die Änderungen am
+* übergebenen Parameter nicht unbedingt bedeuten, dass diese Änderungen
+* auch in der aufrufenden Methode sichtbar sind. Der Grund hierfür liegt
+* darin, dass beim unboxing und autoboxing ggf. neue Instanzen des ursprünglichen
+* Referenzdatentyps erzeugt werden. Die aufrufende Methode wird hierüber nicht
+* informiert. Es ist daher immer ratsam, eine Referenz auf das geänderte Objekt als
+* return-Wert zurückzugeben.
+*
+* @author Steddin
+* @version 1.00, 2017-11-20
+*/
+
+public class CallByRef {
+
+ static public Integer power_callByRef(Integer val) {
+ val = val * val;
+ return val;
+ }
+
+ public static void main(String[] args) {
+
+ Integer z, zReturn;
+ z = 2; //Wrapper Klasse wird über Autoboxing erzeugt
+
+ zReturn = power_callByRef(z);
+ System.out.println("Referenz: "+ z + "^2 = " + z);
+ System.out.println("Rueckgabe: "+ z + "^2 = " + zReturn);
+ }
+}
+
+
+
diff --git a/VL04_04/CallByRefArray-C/.classpath b/VL04_04/CallByRefArray-C/.classpath
new file mode 100644
index 0000000..63b7e89
--- /dev/null
+++ b/VL04_04/CallByRefArray-C/.classpath
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+ <classpathentry kind="src" path="src"/>
+ <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
+ <classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/VL04_04/CallByRefArray-C/.project b/VL04_04/CallByRefArray-C/.project
new file mode 100644
index 0000000..82ef554
--- /dev/null
+++ b/VL04_04/CallByRefArray-C/.project
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+ <name>CallByRefArray-C</name>
+ <comment></comment>
+ <projects>
+ </projects>
+ <buildSpec>
+ <buildCommand>
+ <name>org.eclipse.jdt.core.javabuilder</name>
+ <arguments>
+ </arguments>
+ </buildCommand>
+ </buildSpec>
+ <natures>
+ <nature>org.eclipse.jdt.core.javanature</nature>
+ </natures>
+</projectDescription>
diff --git a/VL04_04/CallByRefArray-C/.settings/org.eclipse.jdt.core.prefs b/VL04_04/CallByRefArray-C/.settings/org.eclipse.jdt.core.prefs
new file mode 100644
index 0000000..bb35fa0
--- /dev/null
+++ b/VL04_04/CallByRefArray-C/.settings/org.eclipse.jdt.core.prefs
@@ -0,0 +1,11 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
+org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
+org.eclipse.jdt.core.compiler.compliance=1.8
+org.eclipse.jdt.core.compiler.debug.lineNumber=generate
+org.eclipse.jdt.core.compiler.debug.localVariable=generate
+org.eclipse.jdt.core.compiler.debug.sourceFile=generate
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.source=1.8
diff --git a/VL04_04/CallByRefArray-C/bin/.gitignore b/VL04_04/CallByRefArray-C/bin/.gitignore
new file mode 100644
index 0000000..e7d460a
--- /dev/null
+++ b/VL04_04/CallByRefArray-C/bin/.gitignore
@@ -0,0 +1 @@
+/inf3/
diff --git a/VL04_04/CallByRefArray-C/src/inf3/CallByRefArray.java b/VL04_04/CallByRefArray-C/src/inf3/CallByRefArray.java
new file mode 100644
index 0000000..6e5eeef
--- /dev/null
+++ b/VL04_04/CallByRefArray-C/src/inf3/CallByRefArray.java
@@ -0,0 +1,51 @@
+/**
+* CallByRefArray.java
+*
+* Das Programm zeigt, dass bei der Übergabe eines Arrays an eine
+* Methode bei Änderung des Inhaltes des Arrays kein neues Array Objekt erzeugt
+* wird und somit die in der aufgerufenen Methode durchgeführten Änderungen am
+* Array anschließend auch im aufrufenden Programmteil sichtbar sind (Verhalten
+* wie bei call by reference).
+*
+* Hierbei spielt es keine Rolle, ob im Array Wrappertypen (z.B. Integer) oder Wertetypen
+* (z.B. int) enthalten sind.
+*
+* @author Steddin
+* @version 1.00, 2016-11-23
+*/
+package inf3;
+
+public class CallByRefArray {
+
+ static void Call_intArray(int ia[]) {
+ for (int ii=0; ii< ia.length; ii++) {
+ ia[ii] = 9;
+ }
+ }
+ static void Call_IntArray(Integer ia[]) {
+ for (int ii=0; ii< ia.length; ii++) {
+ ia[ii] = 9;
+ }
+ }
+
+ public static void main(String[] args) {
+ int arr_int[] = {1,2,3,4,5};
+ Integer arr_Int[] = {1,2,3,4,5};
+
+ Call_intArray(arr_int);
+ System.out.print("int-Array nach Methodenaufruf: ");
+ for (int ii=0; ii< arr_int.length; ii++) {
+ System.out.print(arr_int[ii] + ", ");
+ }
+ System.out.println();
+
+ Call_IntArray(arr_Int);
+ System.out.print("Integer-Array nach Methodenaufruf: ");
+ for (int ii=0; ii< arr_Int.length; ii++) {
+ System.out.print(arr_int[ii] + ", ");
+ }
+ System.out.println();
+ }
+}
+
+
diff --git a/VL04_04/CallByRef_Part2-C/.classpath b/VL04_04/CallByRef_Part2-C/.classpath
new file mode 100644
index 0000000..63b7e89
--- /dev/null
+++ b/VL04_04/CallByRef_Part2-C/.classpath
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+ <classpathentry kind="src" path="src"/>
+ <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
+ <classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/VL04_04/CallByRef_Part2-C/.project b/VL04_04/CallByRef_Part2-C/.project
new file mode 100644
index 0000000..a609504
--- /dev/null
+++ b/VL04_04/CallByRef_Part2-C/.project
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+ <name>CallByRef_Part2-C</name>
+ <comment></comment>
+ <projects>
+ </projects>
+ <buildSpec>
+ <buildCommand>
+ <name>org.eclipse.jdt.core.javabuilder</name>
+ <arguments>
+ </arguments>
+ </buildCommand>
+ </buildSpec>
+ <natures>
+ <nature>org.eclipse.jdt.core.javanature</nature>
+ </natures>
+</projectDescription>
diff --git a/VL04_04/CallByRef_Part2-C/.settings/org.eclipse.jdt.core.prefs b/VL04_04/CallByRef_Part2-C/.settings/org.eclipse.jdt.core.prefs
new file mode 100644
index 0000000..bb35fa0
--- /dev/null
+++ b/VL04_04/CallByRef_Part2-C/.settings/org.eclipse.jdt.core.prefs
@@ -0,0 +1,11 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
+org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
+org.eclipse.jdt.core.compiler.compliance=1.8
+org.eclipse.jdt.core.compiler.debug.lineNumber=generate
+org.eclipse.jdt.core.compiler.debug.localVariable=generate
+org.eclipse.jdt.core.compiler.debug.sourceFile=generate
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.source=1.8
diff --git a/VL04_04/CallByRef_Part2-C/bin/.gitignore b/VL04_04/CallByRef_Part2-C/bin/.gitignore
new file mode 100644
index 0000000..e7d460a
--- /dev/null
+++ b/VL04_04/CallByRef_Part2-C/bin/.gitignore
@@ -0,0 +1 @@
+/inf3/
diff --git a/VL04_04/CallByRef_Part2-C/src/inf3/CallByRef_Part2.java b/VL04_04/CallByRef_Part2-C/src/inf3/CallByRef_Part2.java
new file mode 100644
index 0000000..d1580ea
--- /dev/null
+++ b/VL04_04/CallByRef_Part2-C/src/inf3/CallByRef_Part2.java
@@ -0,0 +1,64 @@
+/** VL04-04_CallByRef_Part2.java
+*
+* Das Programm zeigt, dass Wrapper-Typen, die als Parameter an eine Funktion übergeben werden,
+* anders behandelt werden als Objekte eines anderen Referenzdatentyps: <p>
+* Während eine Änderung des Wertes einer als Parameter übergebenen Wrapper-Klasse zur Generierung
+* eines neuen Wrapper-Objektes führt und somit die Änderung nicht an dem übergebenen Wrapper-Parameter
+* durchgeführt wird (also kein call by reference), findet bei der Übergabe eines nicht-Wrapper-Objekts
+* tatsächlich ein call by reference statt. <p>
+*
+* Somit gilt: Bei Wrapper-Typen, die als Parameter an eine Methode übergeben werden gibt es kein call by
+* reference sondern nur ein call by value. Eine in der Methode mit dem übergebenen Wrapper-Objekt durchgeführte
+* Änderung wird immer an einer Kopie des Parameters durchgeführt. Die Änderung muss daher in Form eines
+* Return-Wertes zurückgereicht werden. <p>
+*
+* Der Grund hierfür ist, dass alle Wrapper-Typen "immutable" sind: <p>
+* Wird diesen Typen ein Wert zugewiesen, so lässt sich dieser nicht mehr ändern; stattdessen muss bei einer
+* Änderung ein neues Objekt angelegt werden. Dieses Verhalten findet sich auch beim Typ String.
+*
+*
+* @author Steddin
+* @version 1.00, 2016-11-21
+*/
+package inf3;
+
+public class CallByRef_Part2 {
+
+ static RefClass ChangeValue(RefClass rC) {
+ rC.myPublicValue++;
+ rC.ChangeMyPrivateValue();
+ return rC;
+ }
+
+ static Integer ChangeIntValue(Integer rI) {
+ rI = rI + 1;
+ //rI++; //gleiches Ergebnis, wenn Inkrement aufgerufen wird
+ return rI;
+ }
+
+
+ public static void main(String[] args) {
+ RefClass rC = new RefClass();
+ RefClass new_rC;
+ new_rC = ChangeValue(rC);
+ System.out.println("Per return zurückgegebene Klasse: " + new_rC.myPublicValue + " "+new_rC.getPrivVal());
+ System.out.println("Per Referenz übergebene Klasse: " + rC.getPrivVal() + " " + rC.getPrivVal());
+ if (new_rC == rC)
+ System.out.println("Die als Return Wert zurückgegenene Klasse ist mit der als Parameter übergebenen Klasse identisch");
+ else
+ System.out.println("Die als Return Wert zurückgegenene Klasse ist mit der als Parameter übergebenen Klasse nicht identisch");
+
+ Integer refWrapperClass = 0;
+ Integer new_refWrapperClass;
+
+ new_refWrapperClass = ChangeIntValue(refWrapperClass);
+ System.out.println("Per return zurückgegebene Klasse: " + new_refWrapperClass);
+ System.out.println("Per Referenz übergebene Klasse: " + refWrapperClass);
+ if (new_refWrapperClass == refWrapperClass)
+ System.out.println("Die als Return Wert zurückgegenene Klasse ist mit der als Parameter übergebenen Klasse identisch");
+ else
+ System.out.println("Die als Return Wert zurückgegenene Klasse ist mit der als Parameter übergebenen Klasse nicht identisch");
+
+ }
+
+}
diff --git a/VL04_04/CallByRef_Part2-C/src/inf3/RefClass.java b/VL04_04/CallByRef_Part2-C/src/inf3/RefClass.java
new file mode 100644
index 0000000..609dffb
--- /dev/null
+++ b/VL04_04/CallByRef_Part2-C/src/inf3/RefClass.java
@@ -0,0 +1,15 @@
+package inf3;
+
+public class RefClass {
+ private int myPrivateValue = 0;
+ public int myPublicValue = 0;
+
+ void ChangeMyPrivateValue() {
+ myPrivateValue++;
+ }
+
+ int getPrivVal() {
+ return myPrivateValue;
+ }
+
+}
diff --git a/VL04_04/CallByVal-C/.classpath b/VL04_04/CallByVal-C/.classpath
new file mode 100644
index 0000000..63b7e89
--- /dev/null
+++ b/VL04_04/CallByVal-C/.classpath
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+ <classpathentry kind="src" path="src"/>
+ <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
+ <classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/VL04_04/CallByVal-C/.project b/VL04_04/CallByVal-C/.project
new file mode 100644
index 0000000..80e87ec
--- /dev/null
+++ b/VL04_04/CallByVal-C/.project
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+ <name>CallByVal-C</name>
+ <comment></comment>
+ <projects>
+ </projects>
+ <buildSpec>
+ <buildCommand>
+ <name>org.eclipse.jdt.core.javabuilder</name>
+ <arguments>
+ </arguments>
+ </buildCommand>
+ </buildSpec>
+ <natures>
+ <nature>org.eclipse.jdt.core.javanature</nature>
+ </natures>
+</projectDescription>
diff --git a/VL04_04/CallByVal-C/.settings/org.eclipse.jdt.core.prefs b/VL04_04/CallByVal-C/.settings/org.eclipse.jdt.core.prefs
new file mode 100644
index 0000000..bb35fa0
--- /dev/null
+++ b/VL04_04/CallByVal-C/.settings/org.eclipse.jdt.core.prefs
@@ -0,0 +1,11 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
+org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
+org.eclipse.jdt.core.compiler.compliance=1.8
+org.eclipse.jdt.core.compiler.debug.lineNumber=generate
+org.eclipse.jdt.core.compiler.debug.localVariable=generate
+org.eclipse.jdt.core.compiler.debug.sourceFile=generate
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.source=1.8
diff --git a/VL04_04/CallByVal-C/src/CallByVal.java b/VL04_04/CallByVal-C/src/CallByVal.java
new file mode 100644
index 0000000..cf2d3fd
--- /dev/null
+++ b/VL04_04/CallByVal-C/src/CallByVal.java
@@ -0,0 +1,32 @@
+/**
+* CallByVal.java
+*
+* Primitive Typen werden beim Aufruf einer MEthode
+* immer als Kopie übergeben. D.h. Änderungen an der
+* Kopie innerhalb der aufgerufenen Methode haben keine
+* Auswirkung auf die aufrufende Methode. Sollen die
+* Änderungen an den Aufrufer zurückgegeben werden, so
+* muss dies immer über einen Return value erfolgen.
+*
+* @author Steddin
+* @version 1.00, 2017-11-20
+*/
+public class CallByVal {
+
+ static public int power_callByValue(int val) {
+ val = val * val;
+ return val;
+ }
+
+ public static void main(String[] args) {
+
+ int z = 2;
+ int result;
+
+ result = power_callByValue(z);
+ System.out.println(z + "^2 = " + result);
+ }
+}
+
+
+
diff --git a/VL04_04/Doublefehler-C/.classpath b/VL04_04/Doublefehler-C/.classpath
new file mode 100644
index 0000000..63b7e89
--- /dev/null
+++ b/VL04_04/Doublefehler-C/.classpath
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+ <classpathentry kind="src" path="src"/>
+ <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
+ <classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/VL04_04/Doublefehler-C/.project b/VL04_04/Doublefehler-C/.project
new file mode 100644
index 0000000..2883eee
--- /dev/null
+++ b/VL04_04/Doublefehler-C/.project
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+ <name>Doublefehler-C</name>
+ <comment></comment>
+ <projects>
+ </projects>
+ <buildSpec>
+ <buildCommand>
+ <name>org.eclipse.jdt.core.javabuilder</name>
+ <arguments>
+ </arguments>
+ </buildCommand>
+ </buildSpec>
+ <natures>
+ <nature>org.eclipse.jdt.core.javanature</nature>
+ </natures>
+</projectDescription>
diff --git a/VL04_04/Doublefehler-C/.settings/org.eclipse.jdt.core.prefs b/VL04_04/Doublefehler-C/.settings/org.eclipse.jdt.core.prefs
new file mode 100644
index 0000000..bb35fa0
--- /dev/null
+++ b/VL04_04/Doublefehler-C/.settings/org.eclipse.jdt.core.prefs
@@ -0,0 +1,11 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
+org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
+org.eclipse.jdt.core.compiler.compliance=1.8
+org.eclipse.jdt.core.compiler.debug.lineNumber=generate
+org.eclipse.jdt.core.compiler.debug.localVariable=generate
+org.eclipse.jdt.core.compiler.debug.sourceFile=generate
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.source=1.8
diff --git a/VL04_04/Doublefehler-C/src/Doublefehler.java b/VL04_04/Doublefehler-C/src/Doublefehler.java
new file mode 100644
index 0000000..b1acadf
--- /dev/null
+++ b/VL04_04/Doublefehler-C/src/Doublefehler.java
@@ -0,0 +1,27 @@
+/**
+* Doublefehler.java
+*
+* Das Programm zeigt, dass bei der Berechnung von Double-Werten
+* Ergebnisse auftreten können, die nicht erwartet werden. Ursache hierfür
+* sind die bei der Berechnung von Double-Werten auftretenden Rundungsfehler.
+*
+* @author Steddin
+* @version 1.00, 2016-11-22
+*/
+
+public class Doublefehler {
+
+ public static void main(String[] args) {
+
+ double a1 = 3.01;
+ double a2 = 2.01;
+ double a3 = 1.99;
+ double b = 0.01;
+
+ System.out.println("3.01 - 0.01 = " + (a1 - b));
+ System.out.println("2.01 - 0.01 = " + (a2 - b));
+ System.out.println("2.01 - 0.01 - 2.0 = " + (a2 - b - 2.0));
+ System.out.println("Vergleich (1.99 + 0.01) == (2.01 - 0.01) ergibt: " + ((a3+b) == (a2-b)));
+ }
+}
+
diff --git a/VL04_04/DownCast_PosToNeg-C/.classpath b/VL04_04/DownCast_PosToNeg-C/.classpath
new file mode 100644
index 0000000..63b7e89
--- /dev/null
+++ b/VL04_04/DownCast_PosToNeg-C/.classpath
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+ <classpathentry kind="src" path="src"/>
+ <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
+ <classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/VL04_04/DownCast_PosToNeg-C/.project b/VL04_04/DownCast_PosToNeg-C/.project
new file mode 100644
index 0000000..5d0f7c1
--- /dev/null
+++ b/VL04_04/DownCast_PosToNeg-C/.project
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+ <name>DownCast_PosToNeg-C</name>
+ <comment></comment>
+ <projects>
+ </projects>
+ <buildSpec>
+ <buildCommand>
+ <name>org.eclipse.jdt.core.javabuilder</name>
+ <arguments>
+ </arguments>
+ </buildCommand>
+ </buildSpec>
+ <natures>
+ <nature>org.eclipse.jdt.core.javanature</nature>
+ </natures>
+</projectDescription>
diff --git a/VL04_04/DownCast_PosToNeg-C/.settings/org.eclipse.jdt.core.prefs b/VL04_04/DownCast_PosToNeg-C/.settings/org.eclipse.jdt.core.prefs
new file mode 100644
index 0000000..bb35fa0
--- /dev/null
+++ b/VL04_04/DownCast_PosToNeg-C/.settings/org.eclipse.jdt.core.prefs
@@ -0,0 +1,11 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
+org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
+org.eclipse.jdt.core.compiler.compliance=1.8
+org.eclipse.jdt.core.compiler.debug.lineNumber=generate
+org.eclipse.jdt.core.compiler.debug.localVariable=generate
+org.eclipse.jdt.core.compiler.debug.sourceFile=generate
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.source=1.8
diff --git a/VL04_04/DownCast_PosToNeg-C/src/DownCast_Demo.java b/VL04_04/DownCast_PosToNeg-C/src/DownCast_Demo.java
new file mode 100644
index 0000000..d8be07b
--- /dev/null
+++ b/VL04_04/DownCast_PosToNeg-C/src/DownCast_Demo.java
@@ -0,0 +1,22 @@
+/**
+ * DownCast_Demo.java
+ *
+ * Programm zeigt, dass der downcast einer Zahl zu einem unerwarteten
+ * Ergebnis führen kann. Lösung des Problems: Verwendung von ...
+ *
+ * @author stedS
+ * @version 1.0.0
+ */
+public class DownCast_Demo {
+
+ public static void main(String[] args) {
+ int integerZahl = 0x000001FF; //entspricht +511
+ byte byteZahl = (byte)integerZahl;
+ System.out.println("integerZahl = "+integerZahl);
+ System.out.println("byteZahl = "+byteZahl);
+ }
+}
+
+
+
+
diff --git a/VL04_04/EqualsDemo-C/.classpath b/VL04_04/EqualsDemo-C/.classpath
new file mode 100644
index 0000000..63b7e89
--- /dev/null
+++ b/VL04_04/EqualsDemo-C/.classpath
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+ <classpathentry kind="src" path="src"/>
+ <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
+ <classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/VL04_04/EqualsDemo-C/.project b/VL04_04/EqualsDemo-C/.project
new file mode 100644
index 0000000..451c693
--- /dev/null
+++ b/VL04_04/EqualsDemo-C/.project
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+ <name>EqualsDemo-C</name>
+ <comment></comment>
+ <projects>
+ </projects>
+ <buildSpec>
+ <buildCommand>
+ <name>org.eclipse.jdt.core.javabuilder</name>
+ <arguments>
+ </arguments>
+ </buildCommand>
+ </buildSpec>
+ <natures>
+ <nature>org.eclipse.jdt.core.javanature</nature>
+ </natures>
+</projectDescription>
diff --git a/VL04_04/EqualsDemo-C/.settings/org.eclipse.jdt.core.prefs b/VL04_04/EqualsDemo-C/.settings/org.eclipse.jdt.core.prefs
new file mode 100644
index 0000000..bb35fa0
--- /dev/null
+++ b/VL04_04/EqualsDemo-C/.settings/org.eclipse.jdt.core.prefs
@@ -0,0 +1,11 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
+org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
+org.eclipse.jdt.core.compiler.compliance=1.8
+org.eclipse.jdt.core.compiler.debug.lineNumber=generate
+org.eclipse.jdt.core.compiler.debug.localVariable=generate
+org.eclipse.jdt.core.compiler.debug.sourceFile=generate
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.source=1.8
diff --git a/VL04_04/EqualsDemo-C/src/EqualsDemo.java b/VL04_04/EqualsDemo-C/src/EqualsDemo.java
new file mode 100644
index 0000000..999cf41
--- /dev/null
+++ b/VL04_04/EqualsDemo-C/src/EqualsDemo.java
@@ -0,0 +1,41 @@
+/** EqualsDemo.java
+*
+* Das Programm verdeutlicht den Unterschied zwischen der referenziellen
+* Identität (Vergleich der Zugriffsadresse) und der inhaltlichen
+* (Vergleich der Datenfelder der Instanzvariablen) Identität.
+*
+* @author Steddin
+* @version 1.00, 2017-11-20
+*/
+public class EqualsDemo {
+
+ public static void main(String[] args) {
+ Person hans = new Person();
+ Person hugo = new Person();
+ if (hugo == hans)
+ System.out.println("Hans und Hugo sind identisch");
+ else
+ System.out.println("Hans und Hugo sind nicht identisch");
+
+ if (hans.equals(hugo))
+ System.out.println("Hans und Hugo haben identische Daten");
+ }
+
+}
+
+class Person {
+ int geburtsjahr = 2010;
+ int geburtsmonat = 10;
+ int geburtstag = 31;
+ boolean equals(Person anderePerson) {
+ if ((this.geburtsjahr == anderePerson.geburtsjahr) &&
+ (this.geburtsmonat == anderePerson.geburtsmonat) &&
+ (this.geburtstag == anderePerson.geburtstag))
+ return true;
+ else
+ return false;
+ }
+}
+
+
+
diff --git a/VL04_04/ForEachDemo-C/.classpath b/VL04_04/ForEachDemo-C/.classpath
new file mode 100644
index 0000000..63b7e89
--- /dev/null
+++ b/VL04_04/ForEachDemo-C/.classpath
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+ <classpathentry kind="src" path="src"/>
+ <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
+ <classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/VL04_04/ForEachDemo-C/.project b/VL04_04/ForEachDemo-C/.project
new file mode 100644
index 0000000..3b1a2a6
--- /dev/null
+++ b/VL04_04/ForEachDemo-C/.project
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+ <name>ForEachDemo-C</name>
+ <comment></comment>
+ <projects>
+ </projects>
+ <buildSpec>
+ <buildCommand>
+ <name>org.eclipse.jdt.core.javabuilder</name>
+ <arguments>
+ </arguments>
+ </buildCommand>
+ </buildSpec>
+ <natures>
+ <nature>org.eclipse.jdt.core.javanature</nature>
+ </natures>
+</projectDescription>
diff --git a/VL04_04/ForEachDemo-C/.settings/org.eclipse.jdt.core.prefs b/VL04_04/ForEachDemo-C/.settings/org.eclipse.jdt.core.prefs
new file mode 100644
index 0000000..bb35fa0
--- /dev/null
+++ b/VL04_04/ForEachDemo-C/.settings/org.eclipse.jdt.core.prefs
@@ -0,0 +1,11 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
+org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
+org.eclipse.jdt.core.compiler.compliance=1.8
+org.eclipse.jdt.core.compiler.debug.lineNumber=generate
+org.eclipse.jdt.core.compiler.debug.localVariable=generate
+org.eclipse.jdt.core.compiler.debug.sourceFile=generate
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.source=1.8
diff --git a/VL04_04/ForEachDemo-C/bin/.gitignore b/VL04_04/ForEachDemo-C/bin/.gitignore
new file mode 100644
index 0000000..e7d460a
--- /dev/null
+++ b/VL04_04/ForEachDemo-C/bin/.gitignore
@@ -0,0 +1 @@
+/inf3/
diff --git a/VL04_04/ForEachDemo-C/src/inf3/ForEachDemo.java b/VL04_04/ForEachDemo-C/src/inf3/ForEachDemo.java
new file mode 100644
index 0000000..ef07f5a
--- /dev/null
+++ b/VL04_04/ForEachDemo-C/src/inf3/ForEachDemo.java
@@ -0,0 +1,28 @@
+/** ForEachDemo.java
+*
+* Das Programm zeigt, dass Änderungen eines Array-Elementes innerhalb einer for-each-Schleife
+* das Array nicht verändern
+*
+* @author Steddin
+* @version 1.00, 2017-11-28
+*/
+package inf3;
+public class ForEachDemo {
+
+ public static void main(String[] args) {
+ Integer myArray[] = {0,1,2,3};
+ int ii = 0;
+ for (Integer v: myArray) {
+ v += 10;
+ System.out.println("v["+ ii++ +"] = " + v);
+ }
+ myArray[2] = myArray[2] + 10;
+
+ ii = 0;
+ for (Integer v: myArray) {
+ System.out.println("v["+ ii++ +"] = " + v);
+ }
+ }
+}
+
+
diff --git a/VL04_04/ImmutableWrapper-C/.classpath b/VL04_04/ImmutableWrapper-C/.classpath
new file mode 100644
index 0000000..63b7e89
--- /dev/null
+++ b/VL04_04/ImmutableWrapper-C/.classpath
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+ <classpathentry kind="src" path="src"/>
+ <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
+ <classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/VL04_04/ImmutableWrapper-C/.project b/VL04_04/ImmutableWrapper-C/.project
new file mode 100644
index 0000000..053046a
--- /dev/null
+++ b/VL04_04/ImmutableWrapper-C/.project
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+ <name>ImmutableWrapper-C</name>
+ <comment></comment>
+ <projects>
+ </projects>
+ <buildSpec>
+ <buildCommand>
+ <name>org.eclipse.jdt.core.javabuilder</name>
+ <arguments>
+ </arguments>
+ </buildCommand>
+ </buildSpec>
+ <natures>
+ <nature>org.eclipse.jdt.core.javanature</nature>
+ </natures>
+</projectDescription>
diff --git a/VL04_04/ImmutableWrapper-C/.settings/org.eclipse.jdt.core.prefs b/VL04_04/ImmutableWrapper-C/.settings/org.eclipse.jdt.core.prefs
new file mode 100644
index 0000000..bb35fa0
--- /dev/null
+++ b/VL04_04/ImmutableWrapper-C/.settings/org.eclipse.jdt.core.prefs
@@ -0,0 +1,11 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
+org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
+org.eclipse.jdt.core.compiler.compliance=1.8
+org.eclipse.jdt.core.compiler.debug.lineNumber=generate
+org.eclipse.jdt.core.compiler.debug.localVariable=generate
+org.eclipse.jdt.core.compiler.debug.sourceFile=generate
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.source=1.8
diff --git a/VL04_04/ImmutableWrapper-C/bin/.gitignore b/VL04_04/ImmutableWrapper-C/bin/.gitignore
new file mode 100644
index 0000000..e7d460a
--- /dev/null
+++ b/VL04_04/ImmutableWrapper-C/bin/.gitignore
@@ -0,0 +1 @@
+/inf3/
diff --git a/VL04_04/ImmutableWrapper-C/src/inf3/ImmutableWrapper.java b/VL04_04/ImmutableWrapper-C/src/inf3/ImmutableWrapper.java
new file mode 100644
index 0000000..ef2a21b
--- /dev/null
+++ b/VL04_04/ImmutableWrapper-C/src/inf3/ImmutableWrapper.java
@@ -0,0 +1,45 @@
+/**
+* ImmutableWrapper.java
+*
+* Das Programm zeigt, dass bei kleinen Integer-Werten die Speicherung
+* ähnlich wie beim Java String-Pool erfolgt: für wertgleiche Objekte
+* werden nicht getrennte Objekte angelegt, stattdessen wird hierfür
+* ein gemeinsames Objekt angelegt. <p>
+* Hieran lässt sich erkennen, warum Integer und String immutable sind:
+* wird dem Objekt ein neuer Wert zugewiesen, so würden alle andere Referenzen
+* auf dieses Objekt ebenfalls von der Wertänderung betroffen sein. Aus diesem
+* Grunde muss also bei jeder Änderung ein neues Objekt angelegt werden. <p>
+*
+* Java implementiert dieses Verhalten, um die Performance zu optimieren. <p>
+* Siehe auch: http://www.itcsolutions.eu/2011/02/12/tutorial-java-scjp-12-immutable-string-and-integer/
+* (Zugriff 2016-11-21)
+*
+* @author Steddin
+* @version 1.00, 2016-11-21
+*/package inf3;
+
+public class ImmutableWrapper {
+
+ public static void main(String[] args) {
+ Integer i1 =100; //use constant values
+ Integer i2 =100; //use small values
+
+ System.out.println("Integer i1 = i2 = 100 (-128 < i < 127");
+
+ if(i1 == i2) //compare the references
+ System.out.println("i1 und i2 zeigen auf ein identisches Objekt");
+ else
+ System.out.println("i1 und i2 zeigen auf unterschiedliche Objekte");
+
+ i1 = 300; //use bigger values
+ i2 = 300;
+
+ System.out.println("Integer i1 = i2 = 300 (-128 >= i || ii > 127");
+
+ if(i1 == i2) //compare the references
+ System.out.println("i1 und i2 zeigen auf ein identisches Objekt");
+ else
+ System.out.println("i1 und i2 zeigen auf unterschiedliche Objekte");
+ }
+
+}
diff --git a/VL04_04/InitArray-C/.classpath b/VL04_04/InitArray-C/.classpath
new file mode 100644
index 0000000..d986294
--- /dev/null
+++ b/VL04_04/InitArray-C/.classpath
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+ <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/jdk-13">
+ <attributes>
+ <attribute name="module" value="true"/>
+ </attributes>
+ </classpathentry>
+ <classpathentry kind="src" path="src"/>
+ <classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/VL04_04/InitArray-C/.gitignore b/VL04_04/InitArray-C/.gitignore
new file mode 100644
index 0000000..ae3c172
--- /dev/null
+++ b/VL04_04/InitArray-C/.gitignore
@@ -0,0 +1 @@
+/bin/
diff --git a/VL04_04/InitArray-C/.project b/VL04_04/InitArray-C/.project
new file mode 100644
index 0000000..42fca58
--- /dev/null
+++ b/VL04_04/InitArray-C/.project
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+ <name>InitArray-C</name>
+ <comment></comment>
+ <projects>
+ </projects>
+ <buildSpec>
+ <buildCommand>
+ <name>org.eclipse.jdt.core.javabuilder</name>
+ <arguments>
+ </arguments>
+ </buildCommand>
+ </buildSpec>
+ <natures>
+ <nature>org.eclipse.jdt.core.javanature</nature>
+ </natures>
+</projectDescription>
diff --git a/VL04_04/InitArray-C/.settings/org.eclipse.jdt.core.prefs b/VL04_04/InitArray-C/.settings/org.eclipse.jdt.core.prefs
new file mode 100644
index 0000000..2b084d8
--- /dev/null
+++ b/VL04_04/InitArray-C/.settings/org.eclipse.jdt.core.prefs
@@ -0,0 +1,14 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=12
+org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
+org.eclipse.jdt.core.compiler.compliance=12
+org.eclipse.jdt.core.compiler.debug.lineNumber=generate
+org.eclipse.jdt.core.compiler.debug.localVariable=generate
+org.eclipse.jdt.core.compiler.debug.sourceFile=generate
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enablePreviewFeatures=disabled
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.problem.reportPreviewFeatures=warning
+org.eclipse.jdt.core.compiler.release=enabled
+org.eclipse.jdt.core.compiler.source=12
diff --git a/VL04_04/InitArray-C/src/inf3/InitArray.java b/VL04_04/InitArray-C/src/inf3/InitArray.java
new file mode 100644
index 0000000..1bd3e2e
--- /dev/null
+++ b/VL04_04/InitArray-C/src/inf3/InitArray.java
@@ -0,0 +1,26 @@
+package inf3;
+public class InitArray {
+ public static void main(String[] args) {
+ MyArrayClass myAC = new MyArrayClass();
+ myAC.initArrays();
+ System.out.print("\nInstanzvariable instance_intArr: ");
+ for (int ii: myAC.instance_intArr) System.out.print(ii + "; ");
+ System.out.print("\nInstanzvariable instance_IntegerArr: ");
+ for (Integer ii: myAC.instance_IntegerArr) System.out.print(ii + "; ");
+ }
+}
+class MyArrayClass {
+ int instance_intArr[];
+ Integer instance_IntegerArr[];
+
+ void initArrays() {
+ int local_intArray[] = new int[3];
+ Integer local_IntegerArray[] = new Integer[3];
+ instance_intArr = new int[3];
+ instance_IntegerArr = new Integer[3];
+ System.out.print("\nlocal_intArr: ");
+ for (int ii: local_intArray) System.out.print(ii + "; ");
+ System.out.print("\nlocal_IntegerArr: ");
+ for (Integer ii: local_IntegerArray) System.out.print(ii + "; ");
+ }
+}
diff --git a/VL04_04/InitDemo1-C/.classpath b/VL04_04/InitDemo1-C/.classpath
new file mode 100644
index 0000000..42f2e9f
--- /dev/null
+++ b/VL04_04/InitDemo1-C/.classpath
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+ <classpathentry excluding="*Loesung.java" kind="src" path="src"/>
+ <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
+ <classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/VL04_04/InitDemo1-C/.project b/VL04_04/InitDemo1-C/.project
new file mode 100644
index 0000000..5483ae0
--- /dev/null
+++ b/VL04_04/InitDemo1-C/.project
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+ <name>InitDemo1-C</name>
+ <comment></comment>
+ <projects>
+ </projects>
+ <buildSpec>
+ <buildCommand>
+ <name>org.eclipse.jdt.core.javabuilder</name>
+ <arguments>
+ </arguments>
+ </buildCommand>
+ </buildSpec>
+ <natures>
+ <nature>org.eclipse.jdt.core.javanature</nature>
+ </natures>
+</projectDescription>
diff --git a/VL04_04/InitDemo1-C/src/InitDemo1.java b/VL04_04/InitDemo1-C/src/InitDemo1.java
new file mode 100644
index 0000000..462ae3a
--- /dev/null
+++ b/VL04_04/InitDemo1-C/src/InitDemo1.java
@@ -0,0 +1,44 @@
+/** InitDemo1.java
+*
+* Demonstration der Behandlung von initialisierten und nicht initialisierten Variablen.
+* Das Programm beinhaltet Fehler. Wo sind die Fehler und wie kommen diese zustande?
+*
+* @author Steddin
+* @version 1.00, 2016-11-18
+*/
+
+public class InitDemo1 {
+ static int anzAchsen = 2;
+ public static void main(String[] args) {
+ System.out.println("Anzahl Lenkräder: " + Kfz.anzLenkrad);
+ Kfz ente;
+ System.out.println("Anzahl Hupen: " + ente.anzHupen);
+ ente = new Kfz();
+ System.out.println("Anzahl Räder vor Initialisierung: " + ente.GetAnzahlRaeder());
+ ente.SetAnzahlRaeder(4);
+ System.out.println("Anzahl Räder nach Initialisierung: " + ente.GetAnzahlRaeder());
+ System.out.println("Anzahl Sitze: " + ente.GetAnzahlSitze());
+ }
+}
+
+class Kfz {
+ static int anzLenkrad; //wenn nicht als public deklariert, dann nur im package sichtbar
+ private int anzahlRaeder; //Instanzvariable
+ public int anzHupen;
+
+ void SetAnzahlRaeder(int anz) {
+ static final int anzRaederProAchse = 2;
+ anzahlRaeder = anzRaederProAchse * anzAchsen;
+ }
+
+ int GetAnzahlRaeder() {
+ return anzahlRaeder;
+ }
+
+ int GetAnzahlSitze() {
+ public int anzSitze; // lokale Variable
+ return anzSitze;
+ }
+}
+
+
diff --git a/VL04_04/InitDemo1-C/src/InitDemo1_Loesung.java b/VL04_04/InitDemo1-C/src/InitDemo1_Loesung.java
new file mode 100644
index 0000000..c624a26
--- /dev/null
+++ b/VL04_04/InitDemo1-C/src/InitDemo1_Loesung.java
@@ -0,0 +1,52 @@
+/**
+* InitDemo1_Loesung.java
+*
+* Demonstration der Behandlung von initialisierten und nicht initialisierten Variablen.
+* Das Programm beinhaltet Fehler. Wo sind die Fehler und wie kommen diese zustande?
+*
+* @author Steddin
+* @version 1.00, 2016-11-18
+*/
+
+public class InitDemo1_Loesung {
+ final static int anzAchsen=2; // ist als Klassenvariable im ganzen Package sichtbar
+ public static void main(String[] args) {
+ System.out.println("Anzahl Lenkräder: " + Kfz.anzLenkrad);
+ Kfz ente;
+ ente = new Kfz();
+ //auf eine Instanzvariable kann erst nach der Initialisierung zugeriffen werden:
+ System.out.println("Anzahl Hupen: " + ente.anzHupen);
+ System.out.println("Anzahl Räder vor Initialisierung: " + ente.GetAnzahlRaeder());
+ ente.SetAnzahlRaeder(4);
+ System.out.println("Anzahl Räder nach Initialisierung: " + ente.GetAnzahlRaeder());
+ System.out.println("Anzahl Sitze: " + ente.GetAnzahlSitze());
+ }
+}
+
+class Kfz {
+ static int anzLenkrad; //wenn nicht als public deklariert, dann nur im package sichtbar
+ private int anzahlRaeder; //Instanzvariable
+ public int anzHupen = 2;
+
+ void SetAnzahlRaeder(int anz) {
+ final int anzRaederProAchse = 2;
+ anzahlRaeder = anzRaederProAchse * InitDemo1_Loesung.anzAchsen;
+ //Klassenvariable muss über Klassenname referenziert werden
+ //vorher: anzahlRaeder = anzRaederProAchse * anzAchsen;
+ }
+
+ int GetAnzahlRaeder() {
+ return anzahlRaeder;
+ }
+
+ int GetAnzahlSitze() {
+ // lokale Variable kann nicht als public deklariert werden
+ // lokale Variable muss vor dem ersten Zugriff initialisiert werden.
+ int anzSitze;
+ //vorher: public int anzSitze;
+ // Ohne Initialisierung wird das Programm nicht übersetzt!
+ anzSitze = 4;
+ return anzSitze;
+ }
+}
+
diff --git a/VL04_04/ReferenzielleIdent-C/.classpath b/VL04_04/ReferenzielleIdent-C/.classpath
new file mode 100644
index 0000000..b82a42f
--- /dev/null
+++ b/VL04_04/ReferenzielleIdent-C/.classpath
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+ <classpathentry kind="src" path=""/>
+ <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
+ <classpathentry kind="output" path=""/>
+</classpath>
diff --git a/VL04_04/ReferenzielleIdent-C/.project b/VL04_04/ReferenzielleIdent-C/.project
new file mode 100644
index 0000000..514f44b
--- /dev/null
+++ b/VL04_04/ReferenzielleIdent-C/.project
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+ <name>ReferenzielleIdent-C</name>
+ <comment></comment>
+ <projects>
+ </projects>
+ <buildSpec>
+ <buildCommand>
+ <name>org.eclipse.jdt.core.javabuilder</name>
+ <arguments>
+ </arguments>
+ </buildCommand>
+ </buildSpec>
+ <natures>
+ <nature>org.eclipse.jdt.core.javanature</nature>
+ </natures>
+</projectDescription>
diff --git a/VL04_04/ReferenzielleIdent-C/.settings/org.eclipse.jdt.core.prefs b/VL04_04/ReferenzielleIdent-C/.settings/org.eclipse.jdt.core.prefs
new file mode 100644
index 0000000..bb35fa0
--- /dev/null
+++ b/VL04_04/ReferenzielleIdent-C/.settings/org.eclipse.jdt.core.prefs
@@ -0,0 +1,11 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
+org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
+org.eclipse.jdt.core.compiler.compliance=1.8
+org.eclipse.jdt.core.compiler.debug.lineNumber=generate
+org.eclipse.jdt.core.compiler.debug.localVariable=generate
+org.eclipse.jdt.core.compiler.debug.sourceFile=generate
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.source=1.8
diff --git a/VL04_04/ReferenzielleIdent-C/ReferenzielleIdent.java b/VL04_04/ReferenzielleIdent-C/ReferenzielleIdent.java
new file mode 100644
index 0000000..e534b4c
--- /dev/null
+++ b/VL04_04/ReferenzielleIdent-C/ReferenzielleIdent.java
@@ -0,0 +1,33 @@
+/**
+* ReferenzielleIdent.java
+*
+* Das Programm zeigt, dass bei der bei der Zuweisung von Objekt ws2016
+* an ws2017 nicht der Inhalt von ws2016 übertragen sondern stattdessen
+* die Referenz (Adresse) von ws2016 auf ws 2017 übertragen wird.
+*
+* Das ursprüngliche Objekt ws2017 verwaist auf diese Weise: Es gibt keine
+* Referenzvariable mehr, die auf dieses Objekt verweist. Demzufolge ist das
+* Objekt im Programm nicht mehr zugänglich.
+*
+* @author Steddin
+* @version 1.00, 2017-11-20
+*/
+public class ReferenzielleIdent {
+
+ public static void main(String[] args) {
+ MetiJahrgang ws2017 = new MetiJahrgang();
+ MetiJahrgang ws2016 = new MetiJahrgang();
+ ws2016.anzStud = 49;
+ ws2017 = ws2016;
+ ws2017.anzStud = 51;
+ System.out.println("Anz. Stud. WS2017: "+ws2017.anzStud);
+ System.out.println("Anz. Stud. WS2016: "+ws2016.anzStud);
+ }
+}
+
+class MetiJahrgang {
+ public int anzStud =0;
+}
+
+
+
diff --git a/VL04_04/StringBufPerformance-C/.classpath b/VL04_04/StringBufPerformance-C/.classpath
new file mode 100644
index 0000000..63b7e89
--- /dev/null
+++ b/VL04_04/StringBufPerformance-C/.classpath
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+ <classpathentry kind="src" path="src"/>
+ <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
+ <classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/VL04_04/StringBufPerformance-C/.project b/VL04_04/StringBufPerformance-C/.project
new file mode 100644
index 0000000..b9ce41d
--- /dev/null
+++ b/VL04_04/StringBufPerformance-C/.project
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+ <name>StringBufPerformance-C</name>
+ <comment></comment>
+ <projects>
+ </projects>
+ <buildSpec>
+ <buildCommand>
+ <name>org.eclipse.jdt.core.javabuilder</name>
+ <arguments>
+ </arguments>
+ </buildCommand>
+ </buildSpec>
+ <natures>
+ <nature>org.eclipse.jdt.core.javanature</nature>
+ </natures>
+</projectDescription>
diff --git a/VL04_04/StringBufPerformance-C/.settings/org.eclipse.jdt.core.prefs b/VL04_04/StringBufPerformance-C/.settings/org.eclipse.jdt.core.prefs
new file mode 100644
index 0000000..bb35fa0
--- /dev/null
+++ b/VL04_04/StringBufPerformance-C/.settings/org.eclipse.jdt.core.prefs
@@ -0,0 +1,11 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
+org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
+org.eclipse.jdt.core.compiler.compliance=1.8
+org.eclipse.jdt.core.compiler.debug.lineNumber=generate
+org.eclipse.jdt.core.compiler.debug.localVariable=generate
+org.eclipse.jdt.core.compiler.debug.sourceFile=generate
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.source=1.8
diff --git a/VL04_04/StringBufPerformance-C/bin/.gitignore b/VL04_04/StringBufPerformance-C/bin/.gitignore
new file mode 100644
index 0000000..f09bbfd
--- /dev/null
+++ b/VL04_04/StringBufPerformance-C/bin/.gitignore
@@ -0,0 +1 @@
+/inf/
diff --git a/VL04_04/StringBufPerformance-C/src/inf/StringBufPerformance.java b/VL04_04/StringBufPerformance-C/src/inf/StringBufPerformance.java
new file mode 100644
index 0000000..acdec1f
--- /dev/null
+++ b/VL04_04/StringBufPerformance-C/src/inf/StringBufPerformance.java
@@ -0,0 +1,40 @@
+/** StringBufPerformance.java
+*
+* Das Programm zeigt, dass die Verwendung der Klasse
+* StringBuffer im Vergleich zu String einen eindeutigen
+* Vorteil bringt, wenn die Länge des Strings häufig verändert
+* wird.
+*
+* @author Steddin
+* @version 1.00, 2016-11-22
+*/
+package inf;
+import java.time.*;
+
+public class StringBufPerformance {
+
+ public static void main(String[] args) {
+ Instant startTime, stopTime;
+
+ String testString = "blabla\n";
+ startTime = Instant.now();
+ for (int ii=0; ii< 10_000; ii++) {
+ testString += "blabla\n";
+ }
+ stopTime = Instant.now();
+ System.out.println("Dauer für String-Operation: "
+ + Duration.between(startTime, stopTime).toMillis()*1000 + "µs");
+
+ StringBuffer testSB = new StringBuffer("blabla\n");
+ // zu schnell ... StringBuffer testSB = new StringBuffer("blabla\n".length()*1000);
+ startTime = Instant.now();
+ for (int ii=0; ii< 1_000_000; ii++) {
+ testSB.append("blabla\n");
+ }
+ stopTime = Instant.now();
+ System.out.println("Dauer für StringBuffer-Operation: "
+ + (Duration.between(startTime, stopTime).toMillis()*10) + "µs");
+ //Multiplikation statt mit 1000 nur mir 10: Dies entspricht dann der Zeit von 10000 Durchläufen
+ }
+}
+
diff --git a/VL04_04/StringGen1-C/.classpath b/VL04_04/StringGen1-C/.classpath
new file mode 100644
index 0000000..63b7e89
--- /dev/null
+++ b/VL04_04/StringGen1-C/.classpath
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+ <classpathentry kind="src" path="src"/>
+ <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
+ <classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/VL04_04/StringGen1-C/.project b/VL04_04/StringGen1-C/.project
new file mode 100644
index 0000000..3f6c71f
--- /dev/null
+++ b/VL04_04/StringGen1-C/.project
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+ <name>StringGen1-C</name>
+ <comment></comment>
+ <projects>
+ </projects>
+ <buildSpec>
+ <buildCommand>
+ <name>org.eclipse.jdt.core.javabuilder</name>
+ <arguments>
+ </arguments>
+ </buildCommand>
+ </buildSpec>
+ <natures>
+ <nature>org.eclipse.jdt.core.javanature</nature>
+ </natures>
+</projectDescription>
diff --git a/VL04_04/StringGen1-C/.settings/org.eclipse.core.resources.prefs b/VL04_04/StringGen1-C/.settings/org.eclipse.core.resources.prefs
new file mode 100644
index 0000000..27491e9
--- /dev/null
+++ b/VL04_04/StringGen1-C/.settings/org.eclipse.core.resources.prefs
@@ -0,0 +1,2 @@
+eclipse.preferences.version=1
+encoding//src/StringGen1.java=UTF-8
diff --git a/VL04_04/StringGen1-C/.settings/org.eclipse.jdt.core.prefs b/VL04_04/StringGen1-C/.settings/org.eclipse.jdt.core.prefs
new file mode 100644
index 0000000..bb35fa0
--- /dev/null
+++ b/VL04_04/StringGen1-C/.settings/org.eclipse.jdt.core.prefs
@@ -0,0 +1,11 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
+org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
+org.eclipse.jdt.core.compiler.compliance=1.8
+org.eclipse.jdt.core.compiler.debug.lineNumber=generate
+org.eclipse.jdt.core.compiler.debug.localVariable=generate
+org.eclipse.jdt.core.compiler.debug.sourceFile=generate
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.source=1.8
diff --git a/VL04_04/StringGen1-C/src/StringGen1.java b/VL04_04/StringGen1-C/src/StringGen1.java
new file mode 100644
index 0000000..f092f22
--- /dev/null
+++ b/VL04_04/StringGen1-C/src/StringGen1.java
@@ -0,0 +1,49 @@
+/** StringGen1.java
+*
+* Programm demonstriert, bei welchen Initialisierungen bzw.
+* Zuweisungen mit referenzieller Identität oder mit Werteidentität
+* zu rechnen ist. Es werden außerdem noch einzelnen Methoden
+* demonstriert, welche von der Klasse String zur Verfügung gestellt werden.
+*
+* Die gesamte Übersicht zu den zur Verfügung stehenden String-Methoden
+* findet sich in der Dokumentation von Oracle zu Klasse String.
+*
+* @author Steddin
+* @version 2.00, 2017-12-05
+*/
+public class StringGen1 {
+
+ public static void main(String[] args) {
+
+ char[] cArr1 = {'M','e','t','i'};
+ char cArr2[] = {'M','e','t','i'};
+ char[] cArr3 = cArr1;
+
+ String s1 = new String();
+ s1 = "Meti";
+ String s2 = "Meti"; //Besonderheit: Instanz ohne new (wie bei Wrapper-Typ)
+ String s3 = new String (cArr1);
+ String s4 = new String (cArr2);
+
+ if(cArr1 == cArr2) System.out.println("Vergleich1: cArr1 und cArr2 sind gleich");
+ if(cArr1 == cArr3) System.out.println("Vergleich2: cArr1 und cArr3 sind gleich");
+ if(s3 == s4) System.out.println("Vergleich3: cArr1 und cArr2 sind gleich");
+ if(s3.equals(s4)) System.out.println("Vergleich4: cArr1 und cArr2 sind inhaltlich gleich");
+
+ s4 = s4.replace('M', 'Y');
+ System.out.println(s4 + " und " + s3 + " sind nicht das Gleiche");
+ String s2Copy = s2;
+ s2 += s4;
+ if (s2!= s2Copy) {
+ System.out.println("s2 wurde neu angelegt");
+ } else {
+ System.out.println("s2 ist unverändert");
+ }
+ System.out.println(s2);
+ s4 = s1.concat(s4);
+ System.out.println(s4);
+ }
+}
+
+
+
diff --git a/VL04_04/StringMethoden-C/.classpath b/VL04_04/StringMethoden-C/.classpath
new file mode 100644
index 0000000..63b7e89
--- /dev/null
+++ b/VL04_04/StringMethoden-C/.classpath
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+ <classpathentry kind="src" path="src"/>
+ <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
+ <classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/VL04_04/StringMethoden-C/.project b/VL04_04/StringMethoden-C/.project
new file mode 100644
index 0000000..45b671c
--- /dev/null
+++ b/VL04_04/StringMethoden-C/.project
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+ <name>StringMethoden-C</name>
+ <comment></comment>
+ <projects>
+ </projects>
+ <buildSpec>
+ <buildCommand>
+ <name>org.eclipse.jdt.core.javabuilder</name>
+ <arguments>
+ </arguments>
+ </buildCommand>
+ </buildSpec>
+ <natures>
+ <nature>org.eclipse.jdt.core.javanature</nature>
+ </natures>
+</projectDescription>
diff --git a/VL04_04/StringMethoden-C/.settings/org.eclipse.jdt.core.prefs b/VL04_04/StringMethoden-C/.settings/org.eclipse.jdt.core.prefs
new file mode 100644
index 0000000..bb35fa0
--- /dev/null
+++ b/VL04_04/StringMethoden-C/.settings/org.eclipse.jdt.core.prefs
@@ -0,0 +1,11 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
+org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
+org.eclipse.jdt.core.compiler.compliance=1.8
+org.eclipse.jdt.core.compiler.debug.lineNumber=generate
+org.eclipse.jdt.core.compiler.debug.localVariable=generate
+org.eclipse.jdt.core.compiler.debug.sourceFile=generate
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.source=1.8
diff --git a/VL04_04/StringMethoden-C/bin/.gitignore b/VL04_04/StringMethoden-C/bin/.gitignore
new file mode 100644
index 0000000..e7d460a
--- /dev/null
+++ b/VL04_04/StringMethoden-C/bin/.gitignore
@@ -0,0 +1 @@
+/inf3/
diff --git a/VL04_04/StringMethoden-C/src/inf3/StringMethoden.java b/VL04_04/StringMethoden-C/src/inf3/StringMethoden.java
new file mode 100644
index 0000000..9aa1c11
--- /dev/null
+++ b/VL04_04/StringMethoden-C/src/inf3/StringMethoden.java
@@ -0,0 +1,23 @@
+/** StringMethoden.java
+*
+* Das Programm demonstriert den Einsatz einiger Methoden,
+* die von der Klasse String zur Bearbeitung von Strings
+* bereitgestellt wird.
+*
+* @author Steddin
+* @version 1.00, 2016-11-22
+*/
+package inf3;
+
+public class StringMethoden {
+ public static void main(String[] args) {
+ char euroZeichen = '\u20ac';
+ String preis = String.valueOf(10.0);
+ int cent = 0;
+ System.out.println(preis+cent+euroZeichen);
+ String bananenPreis = "Wucher-Bananen (kg) :\t"+preis+cent+euroZeichen+"\n\r";
+ System.out.print(bananenPreis.substring(bananenPreis.indexOf("-")+1));
+ }
+}
+
+
diff --git a/VL04_04/TreeSetDemo-C/.classpath b/VL04_04/TreeSetDemo-C/.classpath
new file mode 100644
index 0000000..63b7e89
--- /dev/null
+++ b/VL04_04/TreeSetDemo-C/.classpath
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+ <classpathentry kind="src" path="src"/>
+ <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
+ <classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/VL04_04/TreeSetDemo-C/.project b/VL04_04/TreeSetDemo-C/.project
new file mode 100644
index 0000000..f954350
--- /dev/null
+++ b/VL04_04/TreeSetDemo-C/.project
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+ <name>TreeSetDemo-C</name>
+ <comment></comment>
+ <projects>
+ </projects>
+ <buildSpec>
+ <buildCommand>
+ <name>org.eclipse.jdt.core.javabuilder</name>
+ <arguments>
+ </arguments>
+ </buildCommand>
+ </buildSpec>
+ <natures>
+ <nature>org.eclipse.jdt.core.javanature</nature>
+ </natures>
+</projectDescription>
diff --git a/VL04_04/TreeSetDemo-C/.settings/org.eclipse.jdt.core.prefs b/VL04_04/TreeSetDemo-C/.settings/org.eclipse.jdt.core.prefs
new file mode 100644
index 0000000..bb35fa0
--- /dev/null
+++ b/VL04_04/TreeSetDemo-C/.settings/org.eclipse.jdt.core.prefs
@@ -0,0 +1,11 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
+org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
+org.eclipse.jdt.core.compiler.compliance=1.8
+org.eclipse.jdt.core.compiler.debug.lineNumber=generate
+org.eclipse.jdt.core.compiler.debug.localVariable=generate
+org.eclipse.jdt.core.compiler.debug.sourceFile=generate
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.source=1.8
diff --git a/VL04_04/TreeSetDemo-C/bin/.gitignore b/VL04_04/TreeSetDemo-C/bin/.gitignore
new file mode 100644
index 0000000..e7d460a
--- /dev/null
+++ b/VL04_04/TreeSetDemo-C/bin/.gitignore
@@ -0,0 +1 @@
+/inf3/
diff --git a/VL04_04/TreeSetDemo-C/src/inf3/TreeSetDemo.java b/VL04_04/TreeSetDemo-C/src/inf3/TreeSetDemo.java
new file mode 100644
index 0000000..0434368
--- /dev/null
+++ b/VL04_04/TreeSetDemo-C/src/inf3/TreeSetDemo.java
@@ -0,0 +1,32 @@
+/** TreeSetDemo.java
+*
+* Das Programm demonstriert die Eigenschaften eines TreeSets:
+* - Ein Element kann nicht doppelt enthalten sein
+* - Die Elemente werden ihrer Ordnung entsprechend einsortiert
+* Quelle: Dirk Louis, Peter Müller: Java-Tutorium (Hanser 2016)
+* @author -
+* @version 1.00, 2017-11-28
+*/package inf3;
+
+import java.util.Random;
+import java.util.TreeSet;
+
+public class TreeSetDemo {
+
+ public static void main(String[] args) {
+ TreeSet<Integer> gezogen = new TreeSet<Integer>();
+ Random zufall = new Random();
+ while (gezogen.size() != 6) {
+ int z = zufall.nextInt(50);
+ if (z == 0)
+ continue;
+ // zahl speichern
+ boolean status = gezogen.add(z);
+ }
+ System.out.println("Die Lottozahlen:");
+ for (Integer i : gezogen)
+ System.out.print(i + " ");
+ }
+}
+
+
--
GitLab