Erweiterung der Beispielprogramme im Abschnitt VL04-09

VL04_09/ThreadDurchInterface_1/.classpath

+<?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>

VL04_09/ThreadDurchInterface_1/.project

+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>ThreadDurchInterface_1</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>

VL04_09/ThreadDurchInterface_1/.settings/org.eclipse.jdt.core.prefs

+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

VL04_09/ThreadDurchInterface_1/src/MyThreads/MyInputClass.java

+package MyThreads;
+import java.util.Scanner;
+/** Der Thread wartet auf eine Eingabe von der Tastatur. Der Thread bricht mit einer Exception ab,
+ * wenn Zeichen eingegeben werden, die keine Zahlen sind, so dass die Zahlenkonvertierung fehlschlägt.
+ * @author stedS
+ */
+public class MyInputClass extends Thread {
+
+	public void run() {
+		Scanner myScanner = new Scanner(System.in);
+		int ii = 0;
+		while (true) {
+			ii = myScanner.nextInt();
+			System.out.println("\nEingabe: " + ii);		
+}}}
+
+

VL04_09/ThreadDurchInterface_1/src/MyThreads/MyOutputClass.java

+package MyThreads;
+/** Der Thread gibt nach Ablauf einer Zhlschleife den Text aus, mit dem er
+ * initialisiert wurde.
+ * @author stedS
+ */
+public class MyOutputClass implements Runnable {
+	private String text;
+	private final int COUNT;
+	
+	MyOutputClass(String text, int count)
+	{
+		this.text = text;
+		COUNT = count;
+	}
+	
+	public void run() {
+		long kk = 0;
+		int ll = COUNT;
+		while (true) {
+			if (kk++ % 20_000_000 == 0) {
+				if (ll != 0) {					
+					System.out.print(text + ll + " ");
+					ll--;
+				} else {
+					System.out.println(text + ll + "newline ");
+					ll=COUNT;
+				}
+			}
+		}		
+	}
+}
+
+
+
+

VL04_09/ThreadDurchInterface_1/src/MyThreads/ThreadDurchInterface_1.java

+/** Programm zur Demonstration von Runnable. 
+ * 
+ * @author stedS
+ * @version 1.0 (2017-01-12) 
+ */
+package MyThreads;
+public class ThreadDurchInterface_1 {
+	/** Hauptprogramm legt 3 Threads an, von denen 2 Threads die run-Methode 
+	 * einer Klasse verwenden, welche das Interface Runnable implementiert.
+	 * @param args Es werden keine Runtimeparameter verwendet
+	 * @author stedS
+	 */
+	public static void main(String[] args) {
+		final int COUNT = 5;
+
+		//Objekte anlegen, die keine Unterklassen von Thread sind 
+		//dafr aber das Interface Runnable untersttzen: 
+		MyOutputClass myRunnable1 = 	new MyOutputClass("Hallo", COUNT);
+		MyOutputClass myRunnable2 = 	new MyOutputClass("Meti", COUNT);		
+		
+		//nun alle gewnschten Threads anlegen:
+		MyInputClass myThread1 	= new MyInputClass();
+		Thread myThread2 		= new Thread(myRunnable1);
+		Thread myThread3 		= new Thread(myRunnable2);
+		
+		//nun alle Thread-Objekte starten
+		myThread1.start();
+		myThread2.start();
+		myThread3.start();
+	}
+}
+
+

VL04_09/ThreadDurchInterface_2/.classpath

+<?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>

VL04_09/ThreadDurchInterface_2/.project

+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>ThreadDurchInterface_2</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>

VL04_09/ThreadDurchInterface_2/.settings/org.eclipse.jdt.core.prefs

+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

VL04_09/ThreadDurchInterface_2/src/MyThreads/MyInputClass.java

+package MyThreads;
+import java.util.Scanner;
+/** Der Thread wartet auf eine Eingabe von der Tastatur. Der Thread bricht mit einer Exception ab,
+ * wenn Zeichen eingegeben werden, die keine Zahlen sind, so dass die Zahlenkonvertierung fehlschlägt.
+ * @author stedS
+ */
+public class MyInputClass extends Thread {
+
+	public void run() {
+		Scanner myScanner = new Scanner(System.in);
+		int ii = 0;
+		while (true) {
+			ii = myScanner.nextInt();
+			System.out.println("\nEingabe: " + ii);		
+		}
+	}
+}
+
+

VL04_09/ThreadDurchInterface_2/src/MyThreads/MyOutputClass.java

+package MyThreads;
+/**
+ * Subklassen dieser Klasse erben die Implemtierung von Runnable.
+ * @author stedS
+ *
+ */
+public class MyOutputClass implements Runnable {
+	private String text;
+	int cnt = 0;
+	
+	MyOutputClass(String text)
+	{
+		this.text = text;
+	}
+	
+	protected void MachWas() 
+	{ /*kann in der Kindklasse modifiziert werden*/ };
+	
+	public void run() {
+		long kk = 0;
+		while (true) {
+			if (kk++ % 10_000_000 == 0) {
+				cnt++;
+				System.out.print(text + " ");
+				MachWas();
+}}}}
+
+

VL04_09/ThreadDurchInterface_2/src/MyThreads/MyOutputClassChild.java

+package MyThreads;
+/**
+ * Die Klasse zeigt, dass man die Inplementierung der Schnittstelle Runnable 
+ * von seiner Elternklasse erben kann.
+ * @author stedS
+ */
+public class MyOutputClassChild extends MyOutputClass {
+	
+	private int crlfCnt = 0;
+	
+	public MyOutputClassChild(String text, int cnt) {
+		super(text);
+		crlfCnt = cnt;
+	}
+
+	@Override
+	protected void MachWas() {
+		if (crlfCnt != 0) {
+			if (cnt % crlfCnt == 0) {
+				System.out.println("CRLF");
+}}}}
+
+

VL04_09/ThreadDurchInterface_2/src/MyThreads/ThreadDurchInterface_2.java

+/** Programm zur Demonstration des Einsatzes von Runnable: Die Klasse,
+ * welche an den Thread bergeben wird erbt die Methode run() und damit die
+ * Implementierung der Schnittstelle Runnable von seiner Elternklasse. 
+ * 
+ * @author stedS
+ * @version 1.0 (2017-01-12) 
+ */
+package MyThreads;
+public class ThreadDurchInterface_2 {
+	/** Hauptprogramm legt 3 Threads an, von denen 2 Threads die run-Methode 
+	 * einer Klasse verwenden, welche das Interface Runnable implementiert.
+	 * @param args Es werden keine Runtimeparameter verwendet
+	 * @author stedS
+	 */
+	public static void main(String[] args) {
+
+		//zuerst die Objekte anlegen, die von Thread nicht erben knnen
+		//aber dafr das Interface Runnable untersttzen: 
+		MyOutputClassChild myRunnable1 	= new MyOutputClassChild("Hallo",4);
+		MyOutputClass myRunnable2 		= new MyOutputClass("Meti");		
+		
+		//nun alle gewnschten Threads anlegen:
+		MyInputClass myThread1 	= new MyInputClass();
+		Thread myThread2 		= new Thread(myRunnable1);
+		Thread myThread3 		= new Thread(myRunnable2);
+		
+		//Thread-Objekte starten
+		myThread1.start();
+		myThread2.start();
+		myThread3.start();
+	}
+}
+
+

VL04_09/ThreadDurchInterface_3/.classpath

+<?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>

VL04_09/ThreadDurchInterface_3/.project

+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>ThreadDurchInterface_3</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>

VL04_09/ThreadDurchInterface_3/.settings/org.eclipse.jdt.core.prefs

+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

VL04_09/ThreadDurchInterface_3/src/MyThreads/MyInputClass.java

+package MyThreads;
+import java.util.Scanner;
+/** Der Thread wartet auf eine Eingabe von der Tastatur. Der Thread bricht mit einer Exception ab,
+ * wenn Zeichen eingegeben werden, die keine Zahlen sind, so dass die Zahlenkonvertierung fehlschlägt.
+ * @author stedS
+ */
+public class MyInputClass extends Thread {
+
+	public void run() {
+		Scanner myScanner = new Scanner(System.in);
+		int ii = 0;
+		while (true) {
+			ii = myScanner.nextInt();
+			System.out.println("\nEingabe: " + ii);	
+		}
+	}
+}
+
+

VL04_09/ThreadDurchInterface_3/src/MyThreads/MyOutputClass.java

+package MyThreads;
+/** Die Klasse definiert die Methode MachWas() als abstract. Sie muss von einer Kindklasse 
+ * berschrieben werden. Die Nachkommen dieser Klasse erben wiederum die Implementierung 
+ * der Schnittstelle Runnable.
+ * @author stedS
+ */
+public abstract class MyOutputClass {
+	private String text;
+	int cnt = 0;
+	
+	MyOutputClass(String text)
+	{
+		this.text = text;
+	}
+	
+	protected abstract void MachWas();
+	
+	public void run() {
+		long kk = 0;
+		while (true) {
+			if (kk++ % 1_000_000 == 0) {
+				cnt++;
+				System.out.print(text + " ");
+				MachWas();
+			}
+		}		
+	}
+}
+
+

VL04_09/ThreadDurchInterface_3/src/MyThreads/MyOutputClassChild.java

+package MyThreads;
+/**
+ * Die Klasse zeigt, dass man die Inplementierung der Schnittstelle Runnable 
+ * von seiner Elternklasse erben kann.
+ * @author stedS
+ */
+public class MyOutputClassChild extends MyOutputClass implements Runnable {
+	
+	private int crlfCnt = 0;
+	
+	public MyOutputClassChild(String text, int cnt) {
+		super(text);
+		crlfCnt = cnt;
+	}
+	
+	protected void MachWas() {
+		if (crlfCnt != 0) {
+			if (cnt % crlfCnt == 0) {
+				System.out.println("CRLF");
+}}}}
+
+

VL04_09/ThreadDurchInterface_3/src/MyThreads/ThreadDurchInterface_3.java

+/** Programm zur Demonstration des Einsatzes von Runnable: Die Klasse,
+ * welche an den Thread bergeben wird erbt die Methode run(), und damit die
+ * Implementierung der Schnittstelle Runnable, von seiner Elternklasse. 
+ * 
+ * @author stedS
+ * @version 1.0 (2017-01-12) 
+ */
+package MyThreads;
+public class ThreadDurchInterface_3 {
+
+	public static void main(String[] args) {
+
+		//zuerst die Objekte anlegen, die von Thread nicht erben knnen
+		//aber dafr das Interface Runnable untersttzen: 
+		MyOutputClassChild myRunnable1 = new MyOutputClassChild("Hallo",4);
+		MyOutputClassChild myRunnable2 = new MyOutputClassChild("Meti",0);		
+		
+		//nun alle gewnschten Threads anlegen:
+		MyInputClass myThread1 	= new MyInputClass();
+		Thread myThread2 		= new Thread(myRunnable1);
+		Thread myThread3 		= new Thread(myRunnable2);
+				
+		//Thread-Objekte starten
+		myThread1.start();
+		myThread2.start();
+		myThread3.start();
+	}
+}
+
+