LinkedList
obaya
parent
e6ee4839b2
commit
0f0b5d4ab0
|
|
@ -1,15 +0,0 @@
|
||||||
<?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/JavaSE-22">
|
|
||||||
<attributes>
|
|
||||||
<attribute name="module" value="true"/>
|
|
||||||
</attributes>
|
|
||||||
</classpathentry>
|
|
||||||
<classpathentry kind="con" path="org.eclipse.jdt.junit.JUNIT_CONTAINER/5">
|
|
||||||
<attributes>
|
|
||||||
<attribute name="module" value="true"/>
|
|
||||||
</attributes>
|
|
||||||
</classpathentry>
|
|
||||||
<classpathentry kind="src" path="src"/>
|
|
||||||
<classpathentry kind="output" path="bin"/>
|
|
||||||
</classpath>
|
|
||||||
|
|
@ -1 +0,0 @@
|
||||||
/bin/
|
|
||||||
|
|
@ -1,17 +0,0 @@
|
||||||
<?xml version="1.0" encoding="UTF-8"?>
|
|
||||||
<projectDescription>
|
|
||||||
<name>Programmierung2</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>
|
|
||||||
|
|
@ -1,2 +0,0 @@
|
||||||
eclipse.preferences.version=1
|
|
||||||
encoding/<project>=UTF-8
|
|
||||||
|
|
@ -1,14 +0,0 @@
|
||||||
eclipse.preferences.version=1
|
|
||||||
org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
|
|
||||||
org.eclipse.jdt.core.compiler.codegen.targetPlatform=22
|
|
||||||
org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
|
|
||||||
org.eclipse.jdt.core.compiler.compliance=22
|
|
||||||
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=22
|
|
||||||
|
|
@ -1,126 +0,0 @@
|
||||||
package Algorithmus;
|
|
||||||
|
|
||||||
public class Algorithmus {
|
|
||||||
|
|
||||||
public static void main(String[] args) {
|
|
||||||
|
|
||||||
int[] arr = { 4,34,2,6,8,12,21};
|
|
||||||
int[] sortedArray =insertionSort(arr) ;
|
|
||||||
|
|
||||||
for (int i : sortedArray)
|
|
||||||
System.out.print(i + " ");
|
|
||||||
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
public static int[] mergeSort(int[] arr) {
|
|
||||||
/*
|
|
||||||
* Big-O: O(n log n)
|
|
||||||
*/
|
|
||||||
return arr;
|
|
||||||
}
|
|
||||||
|
|
||||||
public static int[] insertionSort(int[] arr) {
|
|
||||||
/*
|
|
||||||
* Big-O: O(n²)
|
|
||||||
* indexes: 0 1 2 3 4 5 6
|
|
||||||
* Beispiel array = int[] arr = { 4,34,2,6,8,10,21};
|
|
||||||
*/
|
|
||||||
|
|
||||||
for (int i = 1; i < arr.length; i++) {
|
|
||||||
// speicher den Wert an i Index nehmen an dass i = 2;
|
|
||||||
// also z.b: Key = 2;
|
|
||||||
int key = arr[i];
|
|
||||||
// speicher das vorhägie Index
|
|
||||||
int j = i - 1;
|
|
||||||
/*
|
|
||||||
* Also die While Loop Konzept ist:
|
|
||||||
* - betrachtet wird die 2 an Index 2
|
|
||||||
* - j = 1 also >= 0
|
|
||||||
* - arr[i] ist in dem Fall = 34
|
|
||||||
* - ist die 34 > 2, weil key = 2;
|
|
||||||
* - ja
|
|
||||||
*/
|
|
||||||
while (j >= 0 && arr[j] > key) {
|
|
||||||
//also ersetzen 34 druch die 2
|
|
||||||
// aber die 2 wurde erst in var key abgespeichert
|
|
||||||
arr[j + 1] = arr[j];
|
|
||||||
// index j -1
|
|
||||||
j = j - 1;
|
|
||||||
}
|
|
||||||
// hier ersetzen wir die 34 durch die 2
|
|
||||||
arr[j + 1] = key;
|
|
||||||
}
|
|
||||||
|
|
||||||
return arr; // Rückgabe des sortierten Arrays
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
public static int[] selectionSort(int[] arr) {
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Big-O: O(n²)
|
|
||||||
* indexes: 0 1 2 3 4 5 6
|
|
||||||
* Beispiel array = int[] arr = { 4,34,2,6,8,10,21};
|
|
||||||
*
|
|
||||||
*/
|
|
||||||
//Äueßere Schleife beginnt bei Index(0) bis zu index (6)
|
|
||||||
// Beispiel wert
|
|
||||||
for (int i = 0; i < arr.length - 1; i++) { // i = index (4)
|
|
||||||
int minIndex = i;// minIndex = index (4)
|
|
||||||
|
|
||||||
// überprüft ob die 4 < andere Element im array
|
|
||||||
// es soll ab i + 1 überprüft werden
|
|
||||||
for (int j = i + 1; j < arr.length; j++) {
|
|
||||||
//ja, die 2 < 4
|
|
||||||
if (arr[j] < arr[minIndex]) {
|
|
||||||
// also minIndex = index (2) also gleich 2
|
|
||||||
minIndex = j;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
// falls minIndex anderes Index bekommen hat?
|
|
||||||
if (minIndex != i) {
|
|
||||||
//speichere erst die 4 hier
|
|
||||||
int temp = arr[i];
|
|
||||||
// ersetzte die 2 durch die 4
|
|
||||||
arr[i] = arr[minIndex];
|
|
||||||
//ersetze die 4 durch die 2
|
|
||||||
arr[minIndex] = temp;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return arr; // Rückgabe des sortierten Arrays
|
|
||||||
}
|
|
||||||
|
|
||||||
public static int[] bubbleSort(int[] arr) {
|
|
||||||
// Big-O: O(n²)
|
|
||||||
for (int i = 0; i < arr.length; i++)
|
|
||||||
for(int j = 0; j < arr.length; j++)
|
|
||||||
if (arr[i] < arr[j]) {
|
|
||||||
int temp = arr[i];
|
|
||||||
arr[i] = arr[j];
|
|
||||||
arr[j] = temp;
|
|
||||||
}
|
|
||||||
return arr;
|
|
||||||
}
|
|
||||||
|
|
||||||
public static int binarySearch(int[] arr, int value) {
|
|
||||||
int erst = 0; // Initialisierung des Startindexes auf den ersten Index des Arrays
|
|
||||||
int last = arr.length - 1; // Initialisierung des Endindexes auf den letzten Index des Arrays
|
|
||||||
|
|
||||||
while (erst <= last) { // Schleife läuft, solange der Startindex kleiner oder gleich dem Endindex ist
|
|
||||||
int mittel = (erst + last) / 2; // Berechnung des mittleren Indexes durch Addition von Start und Ende, dann Division durch 2
|
|
||||||
|
|
||||||
if (arr[mittel] == value) // Überprüfung, ob der Wert im Array an der mittleren Position dem gesuchten Wert entspricht
|
|
||||||
return mittel; // Wenn ja, wird der mittlere Index als Ergebnis zurückgegeben
|
|
||||||
else if (arr[mittel] < value) // Überprüfung, ob der Wert im Array an der mittleren Position kleiner als der gesuchte Wert ist
|
|
||||||
erst = mittel + 1; // Wenn ja, wird der Startindex auf die Position nach der Mitte gesetzt
|
|
||||||
|
|
||||||
else // Wenn der Wert im Array an der mittleren Position größer als der gesuchte Wert ist
|
|
||||||
last = mittel - 1; // Setzt den Endindex auf die Position vor der Mitte
|
|
||||||
}
|
|
||||||
return -1; // Wenn der Wert nicht gefunden wird, wird -1 zurückgegeben
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
@ -1,54 +0,0 @@
|
||||||
package Algorithmus;
|
|
||||||
public class Array {
|
|
||||||
|
|
||||||
public static void main(String[] args) {
|
|
||||||
// Erstellt ein Array für 5 Elemente vom Typ int
|
|
||||||
int[] array = new int[5];
|
|
||||||
|
|
||||||
// Erstellt und initialisiert das Array mit Werten
|
|
||||||
int[] array2 = {1, 2, 3, 4, 5};
|
|
||||||
|
|
||||||
// Zugriff auf das erste Element
|
|
||||||
int firstElement = array[0];
|
|
||||||
|
|
||||||
// Zugriff auf das letzte Element (bei einem Array der Größe 5)
|
|
||||||
int lastElement = array[4];
|
|
||||||
|
|
||||||
// Setzt das dritte Element des Arrays auf 10
|
|
||||||
array2[2] = 10;
|
|
||||||
|
|
||||||
//for schleife mit einem Array
|
|
||||||
for(int i = 0; i < array.length; i++)
|
|
||||||
System.out.println(array[i]);
|
|
||||||
|
|
||||||
//foreach Schleife
|
|
||||||
for(int element : array)
|
|
||||||
System.out.println(element);
|
|
||||||
|
|
||||||
|
|
||||||
// Erstellt ein 3x3-Array (Matrix
|
|
||||||
int[][] array_21d = new int[3][3];
|
|
||||||
|
|
||||||
//Initialisieren eines 2D-Arrays:
|
|
||||||
int[][] array_2d = {
|
|
||||||
{1, 2, 3},
|
|
||||||
{4, 5, 6},
|
|
||||||
{7, 8, 9}
|
|
||||||
};
|
|
||||||
|
|
||||||
|
|
||||||
// Greift auf das Element in der zweiten Zeile und dritten Spalte zu
|
|
||||||
int element = array_2d[1][2];
|
|
||||||
|
|
||||||
|
|
||||||
//Array mit Objekten, hier sollte eine Klass mit Name Person erstellt werden
|
|
||||||
/*
|
|
||||||
* Person[] persons = new Person[2]; // Erstellt ein Array für 2 Person-Objekte
|
|
||||||
persons[0] = new Person("Alice", 30);
|
|
||||||
persons[1] = new Person("Bob", 25);
|
|
||||||
System.out.println(persons[0].name); // Ausgabe: Alice
|
|
||||||
*/
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
Binary file not shown.
|
|
@ -1,52 +0,0 @@
|
||||||
package Algorithmus;
|
|
||||||
|
|
||||||
public class Logischen_Operatoren {
|
|
||||||
|
|
||||||
public static void main(String[] args) {
|
|
||||||
|
|
||||||
/* Bitweises UND (&):
|
|
||||||
* - Funktion: Der & Operator prüft beide Operanden und gibt true zurück, wenn beide Operanden true sind.
|
|
||||||
* - Merkmal: Beide Bedingungen (a und b) werden immer ausgewertet, unabhängig davon, ob die erste Bedingung false ergibt.
|
|
||||||
* - Das Prinzip gilt auch für die anderen Logischen_Operatoren
|
|
||||||
*/
|
|
||||||
|
|
||||||
//Beispiel:
|
|
||||||
boolean x = true;
|
|
||||||
boolean y = false;
|
|
||||||
// Z ist false, weil y false ist, aber y wird dennoch ausgewertet.
|
|
||||||
boolean z = x & y;
|
|
||||||
|
|
||||||
//Praktischer Einsatz:
|
|
||||||
int a = 5;
|
|
||||||
int b = 0;
|
|
||||||
|
|
||||||
//Beide Bedingungen werden überprüft, b wird erhöht, auch wenn a false ist!
|
|
||||||
if ( a > 5 & (b++ < 10))
|
|
||||||
System.out.println(a);
|
|
||||||
|
|
||||||
System.out.println(b);// b = 1
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
/* Logisches UND (&&):
|
|
||||||
* - Funktion: Der && Operator prüft ebenfalls beide Operanden und gibt true zurück, wenn beide true sind.
|
|
||||||
* - Merkmal: Wenn der erste Operand false ist, wird der zweite Operand nicht mehr ausgewertet. Dies spart Rechenzeit und kann in bestimmten Fällen Fehler vermeiden.
|
|
||||||
*/
|
|
||||||
|
|
||||||
//Praktischer Einsatz:
|
|
||||||
int a2 = 5;
|
|
||||||
int b2 = 0;
|
|
||||||
|
|
||||||
// Beide Bedingungen werden überprüft, b wird nicht erhöht, da a false ist!
|
|
||||||
if (a2 > 5 && (b2++ < 10))
|
|
||||||
System.out.println(a2);
|
|
||||||
|
|
||||||
System.out.println(b2);// b = 0
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
@ -1,50 +0,0 @@
|
||||||
package BankSystemGUI;
|
|
||||||
|
|
||||||
import java.io.File;
|
|
||||||
import java.io.FileWriter;
|
|
||||||
import java.io.IOException;
|
|
||||||
import java.io.PrintWriter;
|
|
||||||
|
|
||||||
public class BankController {
|
|
||||||
private File file;
|
|
||||||
BankController(){
|
|
||||||
file = new File("C:\\Users\\obaya\\git\\Programmierung2\\Programmierung2\\src\\BankSystemGUI\\Kunde.txt");
|
|
||||||
if (!file.exists()) {
|
|
||||||
try {
|
|
||||||
if (file.createNewFile()) // createNewFile() gibt boolean zurück,ob der File ergolgreich erstellt wurde
|
|
||||||
// oder nicht
|
|
||||||
System.out.println("Datei erstellt: " + file.getName()); // der File muss im Pfad nicht existieren,
|
|
||||||
// damit es erstellt wurde
|
|
||||||
} catch (IOException d) {
|
|
||||||
d.printStackTrace();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
public BankSystem addKunde(String name,String vorname,String password,String email) {
|
|
||||||
BankSystem b1 = new BankSystem(name,vorname,password,email);
|
|
||||||
saveKunde(b1);
|
|
||||||
return b1;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
public void saveKunde(BankSystem b1) {
|
|
||||||
try (PrintWriter write = new PrintWriter(new FileWriter(file))) {
|
|
||||||
write.println("ID: " + b1.getId());
|
|
||||||
write.println("Vorname: " + b1.getVorname());
|
|
||||||
write.println("Nachname: " + b1.getName());
|
|
||||||
write.println("Password: " + b1.getPassword());
|
|
||||||
write.println("Email: " + b1.getEmail());
|
|
||||||
write.println("kontoStand " + b1.getKontoStand());
|
|
||||||
write.println(); // Leere Zeile zwischen Einträgen
|
|
||||||
write.flush();
|
|
||||||
write.close();
|
|
||||||
System.out.println(b1.toString());
|
|
||||||
} catch (IOException e) {
|
|
||||||
e.printStackTrace();
|
|
||||||
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
@ -1,93 +0,0 @@
|
||||||
package BankSystemGUI;
|
|
||||||
|
|
||||||
import java.awt.Dimension;
|
|
||||||
import java.awt.FlowLayout;
|
|
||||||
import java.awt.event.ActionEvent;
|
|
||||||
import java.awt.event.ActionListener;
|
|
||||||
|
|
||||||
import javax.swing.JFrame;
|
|
||||||
import javax.swing.JTextField;
|
|
||||||
// Recourses Klasse (Model)
|
|
||||||
public class BankSystem {
|
|
||||||
private String name;
|
|
||||||
private String vorname;
|
|
||||||
private String password;
|
|
||||||
private String email;
|
|
||||||
private double kontoStand;
|
|
||||||
private int Id;
|
|
||||||
private static int IDCounter = 0;
|
|
||||||
|
|
||||||
BankSystem(){}
|
|
||||||
BankSystem(String name,String vorname,String password,String email){
|
|
||||||
this.name = name;
|
|
||||||
this.vorname = vorname;
|
|
||||||
this.password = password;
|
|
||||||
this.email = email;
|
|
||||||
this.kontoStand = 0;
|
|
||||||
this.Id = ++IDCounter;
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
public double einzahlung(double wert) {
|
|
||||||
|
|
||||||
return this.kontoStand += wert;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
public int loadIDCounter() {
|
|
||||||
return Id;
|
|
||||||
}
|
|
||||||
|
|
||||||
public String getEmail() {
|
|
||||||
return email;
|
|
||||||
}
|
|
||||||
|
|
||||||
public void setEmail(String email) {
|
|
||||||
this.email = email;
|
|
||||||
}
|
|
||||||
|
|
||||||
public String getName() {
|
|
||||||
return name;
|
|
||||||
}
|
|
||||||
|
|
||||||
public void setName(String name) {
|
|
||||||
this.name = name;
|
|
||||||
}
|
|
||||||
|
|
||||||
public String getVorname() {
|
|
||||||
return vorname;
|
|
||||||
}
|
|
||||||
|
|
||||||
public void setVorname(String vorname) {
|
|
||||||
this.vorname = vorname;
|
|
||||||
}
|
|
||||||
|
|
||||||
public String getPassword() {
|
|
||||||
return password;
|
|
||||||
}
|
|
||||||
|
|
||||||
public void setPassword(String password) {
|
|
||||||
this.password = password;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
public double getKontoStand() {
|
|
||||||
return kontoStand;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
public int getId() {
|
|
||||||
return Id;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
@Override
|
|
||||||
public String toString() {
|
|
||||||
return "BankSystem [name=" + name + ", vorname=" + vorname + ", password=" + password + ", kontoStand="
|
|
||||||
+ kontoStand + ", Id=" + Id + "]";
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
@ -1,14 +0,0 @@
|
||||||
package BankSystemGUI;
|
|
||||||
|
|
||||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
|
||||||
import org.junit.jupiter.api.Test;
|
|
||||||
|
|
||||||
public class BankSystemTest {
|
|
||||||
|
|
||||||
@Test
|
|
||||||
public void testEinzahlung() {
|
|
||||||
BankSystem test = new BankSystem();
|
|
||||||
double x = test.einzahlung(100);
|
|
||||||
assertEquals(100, x, 0.001); // Hier wird überprüft, ob der Kontostand 100.0 ist
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
@ -1,57 +0,0 @@
|
||||||
package BankSystemGUI;
|
|
||||||
|
|
||||||
import java.io.File;
|
|
||||||
import java.io.FileNotFoundException;
|
|
||||||
import java.util.Scanner;
|
|
||||||
|
|
||||||
import javax.swing.JLabel;
|
|
||||||
|
|
||||||
public class Hauptfenster extends BankSystem {
|
|
||||||
private Window fenster;
|
|
||||||
private Scanner scan;
|
|
||||||
|
|
||||||
Hauptfenster() throws FileNotFoundException{
|
|
||||||
File fr = new File("C:\\Users\\obaya\\git\\Programmierung2\\Programmierung2\\src\\BankSystemGUI\\Kunde.txt");
|
|
||||||
scan = new Scanner(fr);
|
|
||||||
String vorname = null;
|
|
||||||
String name = null;
|
|
||||||
double kontoStand = 0.0;
|
|
||||||
while (scan.hasNextLine()) {
|
|
||||||
String line = scan.nextLine();
|
|
||||||
// Prüfen, ob die Zeile den "Vorname" enthält
|
|
||||||
if (line.startsWith("Vorname:"))
|
|
||||||
vorname = line.split(":")[1].trim(); // Den Namen extrahieren
|
|
||||||
|
|
||||||
if (line.startsWith("Nachname: "))
|
|
||||||
name = line.split(":")[1].trim();
|
|
||||||
|
|
||||||
if (line.startsWith("kontoStand ")) {
|
|
||||||
String value = line.split(" ")[1].trim();
|
|
||||||
kontoStand = Double.parseDouble(value);
|
|
||||||
break; // Wir haben den Namen gefunden, also beenden wir die Schleife
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
fenster = new Window();
|
|
||||||
fenster.setTitle("Haupseite");
|
|
||||||
|
|
||||||
JLabel willkommennachricht = new JLabel("Willkommen " + vorname + " " + name);
|
|
||||||
willkommennachricht.setBounds(10, 10, 200, 40);
|
|
||||||
|
|
||||||
|
|
||||||
JLabel konotstand = new JLabel("Deine Aktuelle Kontostand: " + kontoStand);
|
|
||||||
konotstand.setBounds(10,50 ,200 ,40 );
|
|
||||||
|
|
||||||
|
|
||||||
fenster.add(konotstand);
|
|
||||||
fenster.add(willkommennachricht);
|
|
||||||
}
|
|
||||||
|
|
||||||
public static void main(String[] args) throws FileNotFoundException {
|
|
||||||
Hauptfenster test = new Hauptfenster();
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
@ -1,7 +0,0 @@
|
||||||
ID: 1
|
|
||||||
Vorname: obai
|
|
||||||
Nachname: albek
|
|
||||||
Password: 12345
|
|
||||||
Email: obay@gmail.com
|
|
||||||
kontoStand 0.0
|
|
||||||
|
|
||||||
|
|
@ -1,125 +0,0 @@
|
||||||
package BankSystemGUI;
|
|
||||||
|
|
||||||
import java.awt.Color;
|
|
||||||
import java.awt.Dimension;
|
|
||||||
import java.awt.GridLayout;
|
|
||||||
import java.awt.event.ActionEvent;
|
|
||||||
import java.awt.event.ActionListener;
|
|
||||||
import java.io.File;
|
|
||||||
import java.io.FileNotFoundException;
|
|
||||||
import java.io.FileWriter;
|
|
||||||
import java.io.IOException;
|
|
||||||
import java.io.PrintWriter;
|
|
||||||
|
|
||||||
import javax.swing.JButton;
|
|
||||||
import javax.swing.JFrame;
|
|
||||||
import javax.swing.JLabel;
|
|
||||||
import javax.swing.JOptionPane;
|
|
||||||
import javax.swing.JPanel;
|
|
||||||
import javax.swing.JTextField;
|
|
||||||
|
|
||||||
public class LogIn extends JFrame implements ActionListener {
|
|
||||||
private JButton submit;
|
|
||||||
private File file;
|
|
||||||
private PrintWriter write;
|
|
||||||
private JTextField eingabeVorname;
|
|
||||||
private JTextField eingabenNachname;
|
|
||||||
private JTextField eingabenPassword;
|
|
||||||
private JTextField eingabeEmail;
|
|
||||||
private BankController controller;
|
|
||||||
private Window fenster;
|
|
||||||
|
|
||||||
LogIn() {
|
|
||||||
controller = new BankController();
|
|
||||||
fenster = new Window();
|
|
||||||
fenster.setTitle("log in Seite");
|
|
||||||
|
|
||||||
JLabel überschrift = new JLabel("loggen Sie sich ein: ");
|
|
||||||
überschrift.setBounds(10, 2, 120, 40);
|
|
||||||
|
|
||||||
JLabel vorname = new JLabel("Vorname: ");
|
|
||||||
vorname.setBounds(10, 50, 60, 10);
|
|
||||||
eingabeVorname = new JTextField();
|
|
||||||
eingabeVorname.setBounds(80, 50, 100, 20);
|
|
||||||
|
|
||||||
// setBounds(int x, int y, int width, int height)
|
|
||||||
JLabel nachname = new JLabel("nachname: ");
|
|
||||||
nachname.setBounds(10, 90, 100, 20);
|
|
||||||
|
|
||||||
eingabenNachname = new JTextField();
|
|
||||||
eingabenNachname.setBounds(80, 90, 100, 20);
|
|
||||||
|
|
||||||
JLabel password = new JLabel("password: ");
|
|
||||||
password.setBounds(10, 130, 100, 20);
|
|
||||||
|
|
||||||
eingabenPassword = new JTextField();
|
|
||||||
eingabenPassword.setBounds(80, 130, 100, 20);
|
|
||||||
|
|
||||||
JLabel email = new JLabel("Email: ");
|
|
||||||
email.setBounds(10, 170, 100, 20);
|
|
||||||
|
|
||||||
eingabeEmail = new JTextField();
|
|
||||||
eingabeEmail.setBounds(80, 170, 100, 20);
|
|
||||||
|
|
||||||
submit = new JButton("Submit");
|
|
||||||
submit.setBounds(10, 210, 100, 20);
|
|
||||||
|
|
||||||
submit.addActionListener(new ActionListener() {
|
|
||||||
@Override
|
|
||||||
public void actionPerformed(ActionEvent e) {
|
|
||||||
try {
|
|
||||||
logUser();
|
|
||||||
} catch (IOException e1) {
|
|
||||||
// TODO Auto-generated catch block
|
|
||||||
e1.printStackTrace();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
});
|
|
||||||
|
|
||||||
fenster.add(überschrift);
|
|
||||||
fenster.add(vorname);
|
|
||||||
fenster.add(eingabeVorname);
|
|
||||||
fenster.add(nachname);
|
|
||||||
fenster.add(eingabenNachname);
|
|
||||||
fenster.add(password);
|
|
||||||
fenster.add(eingabenPassword);
|
|
||||||
fenster.add(email);
|
|
||||||
fenster.add(eingabeEmail);
|
|
||||||
fenster.add(submit);
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
public void logUser() throws IOException {
|
|
||||||
if (eingabeVorname.getText().isEmpty() || eingabenNachname.getText().isEmpty()
|
|
||||||
|| eingabenPassword.getText().isEmpty() || eingabeEmail.getText().isEmpty())
|
|
||||||
JOptionPane.showMessageDialog(null, "Alle Felder sind erforderlich", "Fehler", JOptionPane.ERROR_MESSAGE);
|
|
||||||
else {
|
|
||||||
String vorname = eingabeVorname.getText();
|
|
||||||
String nachname = eingabenNachname.getText();
|
|
||||||
String password = eingabenPassword.getText();
|
|
||||||
String email = eingabeEmail.getText();
|
|
||||||
|
|
||||||
BankSystem kunde = controller.addKunde(nachname, vorname, password, email);
|
|
||||||
//JOptionPane.showMessageDialog(null, "Erfolgreich eingeloggt!", "Info", JOptionPane.INFORMATION_MESSAGE);
|
|
||||||
fenster.dispose();
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
@Override
|
|
||||||
public void actionPerformed(ActionEvent e) {
|
|
||||||
// TODO Auto-generated method stub
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
public static void main(String[] args) {
|
|
||||||
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
@ -1,18 +0,0 @@
|
||||||
package BankSystemGUI;
|
|
||||||
|
|
||||||
import java.util.ArrayList;
|
|
||||||
|
|
||||||
public class Test {
|
|
||||||
|
|
||||||
public static void main(String[] args) {
|
|
||||||
|
|
||||||
BankSystem b1 = new BankSystem("obai","albek","12345","obay@gmail.com");
|
|
||||||
System.out.println(b1.toString());
|
|
||||||
b1.einzahlung(100);
|
|
||||||
System.out.println(b1.getKontoStand());
|
|
||||||
System.out.println(b1.toString());
|
|
||||||
//
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
@ -1,22 +0,0 @@
|
||||||
package BankSystemGUI;
|
|
||||||
|
|
||||||
import java.awt.FlowLayout;
|
|
||||||
import java.awt.GridLayout;
|
|
||||||
|
|
||||||
import javax.swing.JFrame;
|
|
||||||
|
|
||||||
public class Window extends JFrame {
|
|
||||||
|
|
||||||
public JFrame window;
|
|
||||||
|
|
||||||
Window(){
|
|
||||||
|
|
||||||
setSize(700, 700);
|
|
||||||
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
|
|
||||||
setLayout(null);
|
|
||||||
setVisible(true);
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
@ -1,453 +0,0 @@
|
||||||
package BinaryTree;
|
|
||||||
|
|
||||||
import java.util.ArrayList;
|
|
||||||
import java.util.LinkedList;
|
|
||||||
import java.util.Queue;
|
|
||||||
|
|
||||||
public class BinaryBaumList {
|
|
||||||
Node root;
|
|
||||||
|
|
||||||
// -----------------------------------------------------------------
|
|
||||||
private int findTreeHeightRekursiv(Node temp) {
|
|
||||||
if (temp == null)
|
|
||||||
return -1;
|
|
||||||
|
|
||||||
int left_subTree = findTreeHeightRekursiv(temp.left);
|
|
||||||
int right_subTree = findTreeHeightRekursiv(temp.right);
|
|
||||||
|
|
||||||
if (left_subTree > right_subTree)
|
|
||||||
return 1 + left_subTree;
|
|
||||||
|
|
||||||
return 1 + right_subTree;
|
|
||||||
}
|
|
||||||
|
|
||||||
public int getHeight() {
|
|
||||||
return findTreeHeightRekursiv(root);
|
|
||||||
}
|
|
||||||
|
|
||||||
// -----------------------------------------------------------------
|
|
||||||
private void additerativ(int value) {
|
|
||||||
// erzeuge eine neue knote
|
|
||||||
Node newNode = new Node();
|
|
||||||
// setze in knote einen Wert
|
|
||||||
newNode.value = value;
|
|
||||||
// ersetze left Knote auf Null
|
|
||||||
newNode.left = null;
|
|
||||||
// ersetze rechte Knote auf Null
|
|
||||||
newNode.right = null;
|
|
||||||
|
|
||||||
// wenn meine Liste leer ist
|
|
||||||
if (root == null) {
|
|
||||||
this.root = newNode;
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
// Wenn sie nicht leer!
|
|
||||||
|
|
||||||
// temp root, um einfacher zu suchen
|
|
||||||
Node temp = root;
|
|
||||||
// da mein Temp bis null Knote läuft,
|
|
||||||
// speichere ich seinen vorhängieren Wert
|
|
||||||
Node merker = temp;
|
|
||||||
while (temp != null) {
|
|
||||||
// speichere temp vorhängieren Wert
|
|
||||||
merker = temp;
|
|
||||||
// wenn soll ich die linke Seite betrachten
|
|
||||||
if (value < temp.value)
|
|
||||||
temp = temp.left;
|
|
||||||
|
|
||||||
// wenn nein soll ich die rechte Seite betrachten
|
|
||||||
else
|
|
||||||
temp = temp.right;
|
|
||||||
}
|
|
||||||
// so wenn ich ganz unten bin, soll ich sehen, ob ich die Knote rechts oder
|
|
||||||
// linke einsetzen soll
|
|
||||||
// Wenn ja, Knote auf der Linke Seite einsetzen
|
|
||||||
if (value < merker.value)
|
|
||||||
merker.left = newNode;
|
|
||||||
// Wenn nein, Knote auf der rechte Seite einsetzen
|
|
||||||
else
|
|
||||||
merker.right = newNode;
|
|
||||||
}
|
|
||||||
|
|
||||||
private void addRekursiv(Node temp, int value) {
|
|
||||||
|
|
||||||
// erzeuge eine neue knote
|
|
||||||
Node newNode = new Node();
|
|
||||||
// setze in knote einen Wert
|
|
||||||
newNode.value = value;
|
|
||||||
// ersetze left Knote auf Null
|
|
||||||
newNode.left = null;
|
|
||||||
// ersetze rechte Knote auf Null
|
|
||||||
newNode.right = null;
|
|
||||||
// falls die Liste leer ist!
|
|
||||||
if (temp == null) {
|
|
||||||
root = newNode;
|
|
||||||
System.out.println("Die Root: " + root.value);
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
// Wenn ja die Linke Seite betrachten
|
|
||||||
if (value < temp.value) {
|
|
||||||
// Wenn mein temp die die Knote null erreicht
|
|
||||||
if (temp.left == null) {
|
|
||||||
// erstze die Knote
|
|
||||||
temp.left = newNode;
|
|
||||||
System.out.println("Linke Knote: " + temp.left.value);
|
|
||||||
}
|
|
||||||
// wenn mein Temp die Knote null nicht erreicht hat
|
|
||||||
else {
|
|
||||||
// laufe weiter
|
|
||||||
addRekursiv(temp.left, value);
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
// wenn die Value größer als die Root
|
|
||||||
// also die rechte Seite betrachten
|
|
||||||
else {
|
|
||||||
if (temp.right == null) {
|
|
||||||
// erstze die Knote
|
|
||||||
temp.right = newNode;
|
|
||||||
System.out.println("Rechte Knote: " + temp.right.value);
|
|
||||||
|
|
||||||
} else {
|
|
||||||
// laufe Weiter
|
|
||||||
addRekursiv(temp.right, value);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
public void addElement(int value) {
|
|
||||||
// additerativ(value);
|
|
||||||
addRekursiv(root, value);
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
// -----------------------------------------------------------------
|
|
||||||
private int findMinRekursiv(Node temp) {
|
|
||||||
|
|
||||||
if (temp.left == null)
|
|
||||||
return temp.value;
|
|
||||||
|
|
||||||
return findMinRekursiv(temp.left);
|
|
||||||
}
|
|
||||||
|
|
||||||
private int findMinIterativ(Node temp) {
|
|
||||||
|
|
||||||
while (temp.left != null)
|
|
||||||
temp = temp.left;
|
|
||||||
|
|
||||||
return temp.value;
|
|
||||||
}
|
|
||||||
|
|
||||||
public int findMin() {
|
|
||||||
return findMinRekursiv(root);
|
|
||||||
// return findMinIterativ(root);
|
|
||||||
}
|
|
||||||
// -----------------------------------------------------------------
|
|
||||||
|
|
||||||
// -----------------------------------------------------------------
|
|
||||||
private int findMaxRekursiv(Node temp) {
|
|
||||||
// // Wenn es kein rechtes Kind gibt, ist dies das Maximum
|
|
||||||
if (temp.right == null)
|
|
||||||
return temp.value;
|
|
||||||
|
|
||||||
// Rekursiv weiter nach rechts gehen
|
|
||||||
return findMaxRekursiv(temp.right);
|
|
||||||
}
|
|
||||||
|
|
||||||
private int findMaxIterativ(Node temp) {
|
|
||||||
while (temp.right != null)
|
|
||||||
temp = temp.right;
|
|
||||||
|
|
||||||
return temp.value;
|
|
||||||
}
|
|
||||||
|
|
||||||
public int findMax() {
|
|
||||||
// Es gibt keine Elemente
|
|
||||||
if (root == null)
|
|
||||||
return -1;
|
|
||||||
|
|
||||||
// Wenn ja, dann hat root den Max Wert
|
|
||||||
if (root.right == null)
|
|
||||||
return root.value;
|
|
||||||
|
|
||||||
// return findMaxRekursiv(root);
|
|
||||||
return findMaxIterativ(root);
|
|
||||||
}
|
|
||||||
|
|
||||||
// -----------------------------------------------------------------
|
|
||||||
private void printPreorder(Node temp) {// [root][left][right]
|
|
||||||
if (temp == null)
|
|
||||||
return;
|
|
||||||
System.out.print(temp.value + " ");
|
|
||||||
printPreorder(temp.left);
|
|
||||||
printPreorder(temp.right);
|
|
||||||
}
|
|
||||||
|
|
||||||
private void printInorder(Node temp) {// [left][root][right]
|
|
||||||
if (temp == null) {
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
printInorder(temp.left);
|
|
||||||
System.out.print(temp.value + " ");
|
|
||||||
printInorder(temp.right);
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
private void printPostoder(Node temp) {// [left][right][root]
|
|
||||||
if (temp == null)
|
|
||||||
return;
|
|
||||||
|
|
||||||
printPreorder(temp.left);
|
|
||||||
printPreorder(temp.right);
|
|
||||||
System.out.print(temp.value + " ");
|
|
||||||
}
|
|
||||||
|
|
||||||
private void BreadthFirst() {
|
|
||||||
// Erstelle eine Queue (Warteschlange) vom Typ LinkedList, um die Knoten für die
|
|
||||||
// Level-Order Traversal zu speichern.
|
|
||||||
Queue<Node> q1 = new LinkedList<>();
|
|
||||||
|
|
||||||
// Füge den Wurzelknoten des Baums in die Warteschlange ein.
|
|
||||||
// Dies ist der Startpunkt für die Breadth-First Traversal.
|
|
||||||
q1.add(root);
|
|
||||||
|
|
||||||
// Solange die Warteschlange nicht leer ist, gibt es noch Knoten zu besuchen.
|
|
||||||
while (!q1.isEmpty()) {
|
|
||||||
// Schau dir das erste Element in der Warteschlange an, ohne es zu entfernen.
|
|
||||||
// Dies gibt dir den aktuellen Knoten, den du verarbeiten willst.
|
|
||||||
Node temp = q1.peek();
|
|
||||||
|
|
||||||
// Entferne das Element (den Knoten), das gerade verarbeitet wird, aus der
|
|
||||||
// Warteschlange.
|
|
||||||
// Dies verschiebt die Warteschlange und macht den nächsten Knoten zum
|
|
||||||
// "Front"-Element.
|
|
||||||
q1.remove();
|
|
||||||
|
|
||||||
// Gib den Wert des aktuellen Knotens aus, den du gerade bearbeitest.
|
|
||||||
// Dies ist der eigentliche Schritt, bei dem du die Traversal-Ergebnisse
|
|
||||||
// ausgibst.
|
|
||||||
System.out.print(temp.value + " ");
|
|
||||||
|
|
||||||
// Wenn der linke Kindknoten existiert, füge ihn zur Warteschlange hinzu.
|
|
||||||
// Dies stellt sicher, dass der linke Kindknoten später in der richtigen
|
|
||||||
// Reihenfolge bearbeitet wird.
|
|
||||||
if (temp.left != null)
|
|
||||||
q1.add(temp.left);
|
|
||||||
|
|
||||||
// Wenn der rechte Kindknoten existiert, füge ihn ebenfalls zur Warteschlange
|
|
||||||
// hinzu.
|
|
||||||
// Dies stellt sicher, dass der rechte Kindknoten nach dem linken Kindknoten
|
|
||||||
// bearbeitet wird.
|
|
||||||
if (temp.right != null)
|
|
||||||
q1.add(temp.right);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
public void printDepth() {
|
|
||||||
// printPreorder(root);
|
|
||||||
// printInorder(root);
|
|
||||||
BreadthFirst();
|
|
||||||
}
|
|
||||||
// -----------------------------------------------------------------
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Löschen von Knoten:
|
|
||||||
* - wenn eine Knote gelöscht werden soll, sollen erst 4 wichtige Eigenschaften betrachtet werden:
|
|
||||||
* 1. ob die Knote überhaupt igrendwo im Baum liegt (suchen)
|
|
||||||
* 2. ob die Knote ein Blatt (leaf Node) ist,das heißt die Knote hat weder rechte Knote noch linke Knote
|
|
||||||
* 3. ob die Knote nur ein einziges Kind hat
|
|
||||||
* 4. ob die Knote zwei Kinder hat
|
|
||||||
* 4.1 hier entscheidt man, was er nehmen möchte:
|
|
||||||
* . Inorder-Vorgänger: Suche nach dem größten Knoten im linken Teilbaum
|
|
||||||
* . Inorder-Nachfolger: Suche nach dem kleinsten Knoten im rechten Teilbaum.
|
|
||||||
*
|
|
||||||
*/
|
|
||||||
|
|
||||||
// 1. Suchen
|
|
||||||
private boolean searchNummberIterativ(int value) {
|
|
||||||
if (root == null)
|
|
||||||
return false;
|
|
||||||
|
|
||||||
Node temp = root;
|
|
||||||
while (temp.value != value) {
|
|
||||||
if (value < temp.value && temp.left != null)
|
|
||||||
temp = temp.left;
|
|
||||||
|
|
||||||
else if (value >= temp.value && temp.right != null)
|
|
||||||
temp = temp.right;
|
|
||||||
|
|
||||||
else
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
if (temp.value == value)
|
|
||||||
return true;
|
|
||||||
|
|
||||||
return false;
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
private boolean searchNummberRekursiv(Node temp , int value) {
|
|
||||||
if (temp == null)
|
|
||||||
return false;
|
|
||||||
|
|
||||||
if (temp.value == value)
|
|
||||||
return true;
|
|
||||||
|
|
||||||
else if(value < temp.value)
|
|
||||||
return searchNummberRekursiv(temp.left , value);
|
|
||||||
|
|
||||||
else
|
|
||||||
return searchNummberRekursiv(temp.right , value);
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
public void searchNummber(int value) {
|
|
||||||
|
|
||||||
if(searchNummberRekursiv(root,value))
|
|
||||||
System.out.println("Ist gefunden: " + value);
|
|
||||||
else
|
|
||||||
System.out.println("Ist nicht gefunden!");
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
//2. löschen als leaf Node
|
|
||||||
private void removeleafNode(int value) {
|
|
||||||
if (!searchNummberIterativ(value)) {
|
|
||||||
System.out.println("Die zahl befindet sich nicht im Baum!");
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
Node temp = root;
|
|
||||||
Node merker = null;
|
|
||||||
while( temp.value != value) {
|
|
||||||
merker = temp;
|
|
||||||
if (value < temp.value)
|
|
||||||
temp = temp.left;
|
|
||||||
|
|
||||||
else if (value >= temp.value)
|
|
||||||
temp = temp.right;
|
|
||||||
}
|
|
||||||
if (temp.value < merker.value)
|
|
||||||
merker.left = null;
|
|
||||||
|
|
||||||
else
|
|
||||||
merker.right = null;
|
|
||||||
}
|
|
||||||
|
|
||||||
//3. lösche eine Knote mit einem einzigen Kind
|
|
||||||
private void removeWithOneChild(int value) {
|
|
||||||
if (!searchNummberIterativ(value)) {
|
|
||||||
System.out.println("Die zahl befindet sich nicht im Baum!");
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
Node temp = root;
|
|
||||||
Node merker = null;
|
|
||||||
while( temp.value != value) {
|
|
||||||
merker = temp;
|
|
||||||
if (value < temp.value)
|
|
||||||
temp = temp.left;
|
|
||||||
|
|
||||||
else if (value >= temp.value)
|
|
||||||
temp = temp.right;
|
|
||||||
}
|
|
||||||
|
|
||||||
if (temp.left != null)
|
|
||||||
merker.left = temp.left;
|
|
||||||
else
|
|
||||||
merker.right = temp.right;
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
//4. lösche eine Knote mit zwei Kindern
|
|
||||||
private void removeWithTwoChildern(int value) {
|
|
||||||
if (!searchNummberIterativ(value)) {
|
|
||||||
System.out.println("Die zahl befindet sich nicht im Baum!");
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
Node temp = root;
|
|
||||||
Node merker = null;
|
|
||||||
while( temp.value != value) {
|
|
||||||
if (value < temp.value)
|
|
||||||
temp = temp.left;
|
|
||||||
|
|
||||||
else if (value >= temp.value)
|
|
||||||
temp = temp.right;
|
|
||||||
|
|
||||||
merker = temp;
|
|
||||||
}
|
|
||||||
temp = temp.left;
|
|
||||||
Node merker2 = temp;
|
|
||||||
while(temp.right != null) {
|
|
||||||
merker2 = temp;
|
|
||||||
temp = temp.right;
|
|
||||||
}
|
|
||||||
merker.value = temp.value;
|
|
||||||
merker2.right = null;
|
|
||||||
}
|
|
||||||
|
|
||||||
//2,3,4 Cases
|
|
||||||
private void removWithAllCases(int value) {
|
|
||||||
if (!searchNummberIterativ(value)) {
|
|
||||||
System.out.println("Die zahl befindet sich nicht im Baum!");
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
|
|
||||||
Node temp = root;
|
|
||||||
Node merker = null;
|
|
||||||
while (temp.value != value) {
|
|
||||||
merker = temp;
|
|
||||||
if (value < temp.value)
|
|
||||||
temp = temp.left;
|
|
||||||
|
|
||||||
else if (value >= temp.value)
|
|
||||||
temp = temp.right;
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
// Die knote ist ein Blatt (leaf Node)
|
|
||||||
if (temp.left == null && temp.right == null) {
|
|
||||||
if (merker == null)
|
|
||||||
root =null;
|
|
||||||
else if (merker.left == temp)
|
|
||||||
merker.left = null;
|
|
||||||
else
|
|
||||||
merker.right = null;
|
|
||||||
}
|
|
||||||
|
|
||||||
// Die Knote hat genau ein Kind entweder links oder rechts
|
|
||||||
if (temp.left == null || temp.right == null) {
|
|
||||||
if (temp.left != null && temp.right == null)
|
|
||||||
merker.left = temp.left;
|
|
||||||
|
|
||||||
else
|
|
||||||
merker.right = temp.right;
|
|
||||||
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
|
|
||||||
// Die Knote hat zwei Kinder
|
|
||||||
else {
|
|
||||||
merker = temp;
|
|
||||||
// weg(1): nach links gehen und ganz nach unten rechts gehen
|
|
||||||
temp = temp.left;
|
|
||||||
Node merker2 = temp;
|
|
||||||
while (temp.right != null) {
|
|
||||||
merker2 = temp;
|
|
||||||
temp = temp.right;
|
|
||||||
}
|
|
||||||
merker.value = temp.value;
|
|
||||||
merker2.right = null;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
}
|
|
||||||
public void removNode(int value) {
|
|
||||||
// removeleafNode(value);
|
|
||||||
//removeWithOneChild(value);
|
|
||||||
//removeWithTwoChildern(value);
|
|
||||||
removWithAllCases(value);
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
Binary file not shown.
Binary file not shown.
Binary file not shown.
|
|
@ -1,23 +0,0 @@
|
||||||
package BinaryTree;
|
|
||||||
|
|
||||||
import static org.junit.Assert.assertEquals;
|
|
||||||
import static org.junit.jupiter.api.Assertions.*;
|
|
||||||
|
|
||||||
import org.junit.jupiter.api.Test;
|
|
||||||
|
|
||||||
class JuintTeste {
|
|
||||||
|
|
||||||
@Test
|
|
||||||
void test() {
|
|
||||||
BinaryBaumList b1 = new BinaryBaumList();
|
|
||||||
b1.addElement(15);
|
|
||||||
b1.addElement(6);
|
|
||||||
b1.addElement(3);
|
|
||||||
b1.addElement(9);
|
|
||||||
b1.addElement(8);
|
|
||||||
b1.addElement(20);
|
|
||||||
b1.addElement(25);
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
@ -1,8 +0,0 @@
|
||||||
package BinaryTree;
|
|
||||||
|
|
||||||
public class Node {
|
|
||||||
int value;
|
|
||||||
Node left;
|
|
||||||
Node right;
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
@ -1,39 +0,0 @@
|
||||||
package BinaryTree;
|
|
||||||
|
|
||||||
public class Test {
|
|
||||||
|
|
||||||
public static void main(String[] args) {
|
|
||||||
BinaryBaumList b1 = new BinaryBaumList();
|
|
||||||
b1.addElement(50);
|
|
||||||
b1.addElement(30);
|
|
||||||
b1.addElement(70);
|
|
||||||
b1.addElement(20);
|
|
||||||
b1.addElement(40);
|
|
||||||
b1.addElement(60);
|
|
||||||
b1.addElement(80);
|
|
||||||
b1.addElement(15);
|
|
||||||
b1.addElement(22);
|
|
||||||
b1.addElement(35);
|
|
||||||
b1.addElement(45);
|
|
||||||
b1.addElement(21);
|
|
||||||
b1.addElement(25);
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
System.out.print("[");
|
|
||||||
b1.printDepth();
|
|
||||||
System.out.print("]");
|
|
||||||
System.out.println();
|
|
||||||
b1.removNode(30);
|
|
||||||
System.out.print("[");
|
|
||||||
b1.printDepth();
|
|
||||||
System.out.print("]");
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
}
|
|
||||||
Binary file not shown.
|
|
@ -1,10 +0,0 @@
|
||||||
package Collection;
|
|
||||||
public class Collections {
|
|
||||||
|
|
||||||
/* Collections: eine Sammlung von Werten, die vom gleichen Datentyp sein können oder auch nicht.
|
|
||||||
* 1. Array:
|
|
||||||
* - ist änderbar, hat fixed Size und indexed
|
|
||||||
*
|
|
||||||
*/
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
@ -1,46 +0,0 @@
|
||||||
package Collection;
|
|
||||||
|
|
||||||
|
|
||||||
import java.util.ArrayList;
|
|
||||||
import java.util.LinkedList;
|
|
||||||
import java.util.List;
|
|
||||||
import java.util.Stack;
|
|
||||||
import java.util.Vector;
|
|
||||||
|
|
||||||
public class Lists {
|
|
||||||
/*
|
|
||||||
* - Duplikate von Elementen ist zulassen
|
|
||||||
* - die Methoden alle KlassenLists sind ähnlich zueinander
|
|
||||||
* - Stack Prinzip : LIFO (Last In, First Out)
|
|
||||||
* - indexded Lists
|
|
||||||
*/
|
|
||||||
|
|
||||||
public static void main(String[] args) {
|
|
||||||
// Die vier Lists sind dynamischen Lists
|
|
||||||
ArrayList<String> arrayList = new ArrayList<>();
|
|
||||||
|
|
||||||
LinkedList<String> linkedList = new LinkedList<>();
|
|
||||||
|
|
||||||
List<String> vector = new Vector<>();
|
|
||||||
// stack erbt von Vector
|
|
||||||
Stack<String> stack = new Stack<>();
|
|
||||||
|
|
||||||
arrayList.add("arrayList");
|
|
||||||
linkedList.add("LinkedList");
|
|
||||||
vector.add("Vektor");
|
|
||||||
stack.add("Stack");
|
|
||||||
System.out.println(arrayList);
|
|
||||||
System.out.println(linkedList);
|
|
||||||
System.out.println(vector);
|
|
||||||
System.out.println(stack);
|
|
||||||
stack.push("pushed String");
|
|
||||||
System.out.println(stack);
|
|
||||||
stack.pop();
|
|
||||||
System.out.println(stack);
|
|
||||||
// gibt das oberste Element zurück
|
|
||||||
stack.peek();
|
|
||||||
System.out.println(stack);
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
@ -1,71 +0,0 @@
|
||||||
package Collection;
|
|
||||||
|
|
||||||
|
|
||||||
import java.util.LinkedList;
|
|
||||||
import java.util.PriorityQueue;
|
|
||||||
import java.util.Queue;
|
|
||||||
import java.util.Deque;
|
|
||||||
import java.util.ArrayDeque;
|
|
||||||
|
|
||||||
public class Queueslist {
|
|
||||||
/*
|
|
||||||
* - Queue Prinzip: FIFO (First In, First Out)
|
|
||||||
* - dynamische nicht indexed lists
|
|
||||||
*
|
|
||||||
*/
|
|
||||||
|
|
||||||
public static void main(String[] args) {
|
|
||||||
Queue<String> queue = new LinkedList<>();
|
|
||||||
|
|
||||||
//füge ein Element am Ende hinzu
|
|
||||||
queue.add("1");
|
|
||||||
System.out.println(queue);
|
|
||||||
// füge ein Element am Ende hinzu
|
|
||||||
queue.add("2");
|
|
||||||
System.out.println(queue);
|
|
||||||
|
|
||||||
// füge ein Element am Ende hinzu, gibt false zurück, wenn die Queue full ist
|
|
||||||
queue.offer("3");
|
|
||||||
System.out.println(queue);
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
//Entfernt das erste Element in der Queue und gibt es zurück.
|
|
||||||
queue.remove();
|
|
||||||
//Entfernt das erste Element in der Queue und gibt es zurück. Gibt null zurück, wenn die Queue leer ist,
|
|
||||||
queue.poll();
|
|
||||||
|
|
||||||
|
|
||||||
/* Spezielle Queue-Typen:
|
|
||||||
*
|
|
||||||
* 1. PriorityQueue: ordnet ihre Elemente in einer natürlichen Ordnung oder nach einem angegebenen Comparator.
|
|
||||||
*/
|
|
||||||
|
|
||||||
PriorityQueue<Integer> priorityQueue = new PriorityQueue<>();
|
|
||||||
priorityQueue.add(10);
|
|
||||||
priorityQueue.add(20);
|
|
||||||
priorityQueue.add(7);
|
|
||||||
|
|
||||||
System.out.println(priorityQueue.poll()); // Ausgabe: 7 (niedrigster Wert zuerst)
|
|
||||||
System.out.println(priorityQueue.poll()); // Ausgabe: 10 zweite niedrigster Wert
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Spezielle Queue-Typen:
|
|
||||||
*
|
|
||||||
* 1. Deque (Double-Ended Queue): erlaubt das Hinzufügen und Entfernen von Elementen an beiden Enden der Queue.
|
|
||||||
*/
|
|
||||||
|
|
||||||
Deque<String> deque = new ArrayDeque<>();
|
|
||||||
|
|
||||||
deque.addFirst("First");
|
|
||||||
deque.addLast("Last");
|
|
||||||
deque.addFirst("New First");
|
|
||||||
|
|
||||||
System.out.println(deque.removeFirst()); // New First
|
|
||||||
System.out.println(deque.removeLast()); // Last
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
@ -1,60 +0,0 @@
|
||||||
package Collection;
|
|
||||||
|
|
||||||
|
|
||||||
import java.util.HashSet;
|
|
||||||
import java.util.LinkedHashSet;
|
|
||||||
import java.util.Set;
|
|
||||||
import java.util.TreeSet;
|
|
||||||
|
|
||||||
public class Setlists {
|
|
||||||
/* - nicht indexed lists
|
|
||||||
* - erlaubt keine doppelten Elemente
|
|
||||||
* - HashSet, LinkedHashSet und TreeSet
|
|
||||||
*
|
|
||||||
*/
|
|
||||||
public static void main(String[] args) {
|
|
||||||
|
|
||||||
/*
|
|
||||||
* 1. HashSet:
|
|
||||||
* - Verwendet eine HashMap intern, um die Elemente zu speichern
|
|
||||||
* - Bietet konstante Zeit für die grundlegenden Operationen (add, remove, contains), solange die Hash-Funktion effizient ist.
|
|
||||||
* - Die Reihenfolge der Elemente ist nicht garantiert.
|
|
||||||
*/
|
|
||||||
Set<String> hashSet = new HashSet<>();
|
|
||||||
hashSet.add("Apple");
|
|
||||||
hashSet.add("Banana");
|
|
||||||
hashSet.add("Apple"); // wird ignoriert, da "Apple" bereits existiert
|
|
||||||
|
|
||||||
System.out.println(hashSet); // Ausgabe: Apple,Banana
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
* 2. LinkedHashSet:
|
|
||||||
* - Verwendet eine verknüpfte Liste (LinkedList) zusammen mit einer HashMap, um die Elemente zu speichern.
|
|
||||||
*/
|
|
||||||
|
|
||||||
Set<String> linkedHashSet = new LinkedHashSet<>();
|
|
||||||
linkedHashSet.add("Apple");
|
|
||||||
linkedHashSet.add("Banana");
|
|
||||||
linkedHashSet.add("Apple");
|
|
||||||
System.out.println(linkedHashSet);// wird ignoriert, da "Apple" bereits existiert
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
* 3. TreeSet:
|
|
||||||
* - Verwendet eine selbstbalancierende Baumstruktur (Red-Black Tree), um die Elemente zu speichern.
|
|
||||||
* - Elemente werden in natürlicher Ordnung (oder durch einen Comparator, falls angegeben) sortiert gespeichert.
|
|
||||||
*/
|
|
||||||
|
|
||||||
Set<String> treeSet = new TreeSet<>();
|
|
||||||
treeSet.add("Banana");
|
|
||||||
treeSet.add("Apple");
|
|
||||||
treeSet.add("Apple");
|
|
||||||
|
|
||||||
// die zweite Apple wird ignorieret und die Reihnfolge wird automatisch sortiert
|
|
||||||
System.out.println(treeSet);
|
|
||||||
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
Binary file not shown.
|
|
@ -1,68 +0,0 @@
|
||||||
package FassadenKlasse;
|
|
||||||
/*In Allgemein: Also zu verstehe ist, das Fassade-Muster hilft dabei
|
|
||||||
* , die Komplexität eines Systems zu verbergen und es für den Benutzer einfacher zu machen
|
|
||||||
* , mit dem System zu interagieren.
|
|
||||||
*/
|
|
||||||
|
|
||||||
// Subsystem-Klasse für Speicherverwaltung
|
|
||||||
class Speicher {
|
|
||||||
public void initialisiereSpeicher() {
|
|
||||||
System.out.println("Speicher wird initialisiert...");
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Subsystem-Klasse für Prozessorverwaltung
|
|
||||||
class Prozessor {
|
|
||||||
public void initialisiereProzessor() {
|
|
||||||
System.out.println("Prozessor wird initialisiert...");
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Subsystem-Klasse für Eingabegeräteverwaltung
|
|
||||||
class Eingabegeräte {
|
|
||||||
public void initialisiereEingabegeräte() {
|
|
||||||
System.out.println("Eingabegeräte werden initialisiert...");
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Subsystem-Klasse für Netzwerkverwaltung
|
|
||||||
class Netzwerk {
|
|
||||||
public void initialisiereNetzwerk() {
|
|
||||||
System.out.println("Netzwerk wird initialisiert...");
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Fassade-Klasse, die eine einfache Schnittstelle bereitstellt
|
|
||||||
class ComputersystemFassade {
|
|
||||||
private Speicher speicher;
|
|
||||||
private Prozessor prozessor;
|
|
||||||
private Eingabegeräte eingabegeräte;
|
|
||||||
private Netzwerk netzwerk;
|
|
||||||
|
|
||||||
public ComputersystemFassade() {
|
|
||||||
this.speicher = new Speicher();
|
|
||||||
this.prozessor = new Prozessor();
|
|
||||||
this.eingabegeräte = new Eingabegeräte();
|
|
||||||
this.netzwerk = new Netzwerk();
|
|
||||||
}
|
|
||||||
|
|
||||||
// Die Fassade-Methode, die das System startet
|
|
||||||
public void systemStarten() {
|
|
||||||
System.out.println("Systemstart wird vorbereitet...");
|
|
||||||
speicher.initialisiereSpeicher();
|
|
||||||
prozessor.initialisiereProzessor();
|
|
||||||
eingabegeräte.initialisiereEingabegeräte();
|
|
||||||
netzwerk.initialisiereNetzwerk();
|
|
||||||
System.out.println("System erfolgreich gestartet!");
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Client-Code, der die Fassade verwendet
|
|
||||||
public class Fassadenklasse {
|
|
||||||
public static void main(String[] args) {
|
|
||||||
// Der Client verwendet die Fassade, um das System zu starten
|
|
||||||
ComputersystemFassade fassade = new ComputersystemFassade();
|
|
||||||
fassade.systemStarten();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
@ -1,58 +0,0 @@
|
||||||
package GUIAnwendungen;
|
|
||||||
|
|
||||||
import java.awt.Color;
|
|
||||||
import java.awt.event.ActionEvent;
|
|
||||||
import java.awt.event.ActionListener;
|
|
||||||
|
|
||||||
import javax.swing.JFrame;
|
|
||||||
import javax.swing.JPanel;
|
|
||||||
import javax.swing.Timer;
|
|
||||||
|
|
||||||
public class BewegePanle extends JPanel {
|
|
||||||
private int yPosition = 0; // Startposition des Panels oben
|
|
||||||
private final int speed = 1; // Geschwindigkeit der Bewegung
|
|
||||||
private final int panelWidth = 100;
|
|
||||||
private final int panelHeight = 100;
|
|
||||||
|
|
||||||
public BewegePanle() {
|
|
||||||
// Setze die Hintergrundfarbe des Panels
|
|
||||||
setBackground(Color.red);
|
|
||||||
|
|
||||||
// Timer initialisieren und starten
|
|
||||||
//(int delay, ActionListener listener)
|
|
||||||
Timer timer = new Timer(10, new ActionListener() {
|
|
||||||
@Override
|
|
||||||
public void actionPerformed(ActionEvent e) {
|
|
||||||
// Aktualisiere die y-Position
|
|
||||||
yPosition += speed;
|
|
||||||
|
|
||||||
// Wenn das Panel unten angekommen ist, starte wieder von oben
|
|
||||||
if (yPosition > 750 - panelHeight) {
|
|
||||||
yPosition = 0; // Zurück an den oberen Rand
|
|
||||||
}
|
|
||||||
|
|
||||||
// Erzwinge das Neuzeichnen des Panels
|
|
||||||
setBounds(0, yPosition, panelWidth, panelHeight);
|
|
||||||
}
|
|
||||||
});
|
|
||||||
|
|
||||||
timer.start(); // Timer starten
|
|
||||||
}
|
|
||||||
|
|
||||||
public static void main(String[] args) {
|
|
||||||
// Erstelle das Hauptfenster
|
|
||||||
JFrame frame = new JFrame();
|
|
||||||
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
|
|
||||||
frame.setSize(750, 750);
|
|
||||||
frame.setLayout(null); // Deaktiviere das Layout-Management
|
|
||||||
|
|
||||||
// Erstelle eine Instanz von Jpanel und füge sie dem Fenster hinzu
|
|
||||||
BewegePanle panel = new BewegePanle();
|
|
||||||
panel.setBounds(0, 0, 100, 100); // Initiale Position und Größe
|
|
||||||
frame.add(panel);
|
|
||||||
|
|
||||||
// Mache das Fenster sichtbar
|
|
||||||
frame.setVisible(true);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
@ -1,82 +0,0 @@
|
||||||
package GUIAnwendungen;
|
|
||||||
import java.awt.BorderLayout;
|
|
||||||
import java.awt.Color;
|
|
||||||
import java.awt.Dimension;
|
|
||||||
import javax.swing.JFrame;
|
|
||||||
import javax.swing.JPanel;
|
|
||||||
|
|
||||||
public class Borderlayout {
|
|
||||||
/*
|
|
||||||
* steuert die Positionierung von Komponenten in einem Container
|
|
||||||
* Z.B:
|
|
||||||
* NORTH (oben)
|
|
||||||
SOUTH (unten)
|
|
||||||
EAST (rechts)
|
|
||||||
WEST (links)
|
|
||||||
CENTER (Mitte)
|
|
||||||
|
|
||||||
*/
|
|
||||||
|
|
||||||
public static void main(String[] args) {
|
|
||||||
|
|
||||||
// Erstelle ein Fenster (JFrame-Objekt)
|
|
||||||
JFrame frame = new JFrame();
|
|
||||||
|
|
||||||
// Setzt das Layout des Rahmens auf BorderLayout mit einem Abstand von 10 Pixeln zwischen den Komponenten
|
|
||||||
frame.setLayout(new BorderLayout(10,10));
|
|
||||||
|
|
||||||
// Legt die Größe des Fensters fest (Breite: 750 Pixel, Höhe: 750 Pixel)
|
|
||||||
frame.setSize(750, 750);
|
|
||||||
|
|
||||||
// Stellt sicher, dass das Programm beendet wird, wenn das Fenster geschlossen wird
|
|
||||||
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
|
|
||||||
|
|
||||||
// Setzt den Titel des Fensters
|
|
||||||
frame.setTitle("Mein erstes Fenster");
|
|
||||||
|
|
||||||
// Macht das Fenster sichtbar
|
|
||||||
frame.setVisible(true);
|
|
||||||
|
|
||||||
// Erstelle fünf JPanel-Objekte, die als Container für andere Komponenten dienen können
|
|
||||||
JPanel panel1 = new JPanel();
|
|
||||||
JPanel panel2 = new JPanel();
|
|
||||||
JPanel panel3 = new JPanel();
|
|
||||||
JPanel panel4 = new JPanel();
|
|
||||||
JPanel panel5 = new JPanel();
|
|
||||||
|
|
||||||
// Setzt den Hintergrund von panel1 auf Rot
|
|
||||||
panel1.setBackground(Color.red);
|
|
||||||
// Setzt den Hintergrund von panel2 auf Grün
|
|
||||||
panel2.setBackground(Color.green);
|
|
||||||
// Setzt den Hintergrund von panel3 auf Gelb
|
|
||||||
panel3.setBackground(Color.yellow);
|
|
||||||
// Setzt den Hintergrund von panel4 auf Magenta
|
|
||||||
panel4.setBackground(Color.magenta);
|
|
||||||
// Setzt den Hintergrund von panel5 auf Blau
|
|
||||||
panel5.setBackground(Color.blue);
|
|
||||||
|
|
||||||
// Legt die bevorzugte Größe von panel1 fest (100x100 Pixel)
|
|
||||||
panel1.setPreferredSize(new Dimension(100,100));
|
|
||||||
// Legt die bevorzugte Größe von panel2 fest (100x100 Pixel)
|
|
||||||
panel2.setPreferredSize(new Dimension(100,100));
|
|
||||||
// Legt die bevorzugte Größe von panel3 fest (100x100 Pixel)
|
|
||||||
panel3.setPreferredSize(new Dimension(100,100));
|
|
||||||
// Legt die bevorzugte Größe von panel4 fest (100x100 Pixel)
|
|
||||||
panel4.setPreferredSize(new Dimension(100,100));
|
|
||||||
// Legt die bevorzugte Größe von panel5 fest (100x100 Pixel)
|
|
||||||
panel5.setPreferredSize(new Dimension(100,100));
|
|
||||||
|
|
||||||
// Fügt panel1 im Bereich NORTH des BorderLayouts hinzu
|
|
||||||
frame.add(panel1, BorderLayout.NORTH);
|
|
||||||
// Fügt panel2 im Bereich WEST des BorderLayouts hinzu
|
|
||||||
frame.add(panel2, BorderLayout.WEST);
|
|
||||||
// Fügt panel3 im Bereich EAST des BorderLayouts hinzu
|
|
||||||
frame.add(panel3, BorderLayout.EAST);
|
|
||||||
// Fügt panel4 im Bereich SOUTH des BorderLayouts hinzu
|
|
||||||
frame.add(panel4, BorderLayout.SOUTH);
|
|
||||||
// Fügt panel5 im Bereich CENTER des BorderLayouts hinzu
|
|
||||||
frame.add(panel5, BorderLayout.CENTER);
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
@ -1,64 +0,0 @@
|
||||||
package GUIAnwendungen;
|
|
||||||
import java.awt.BorderLayout;
|
|
||||||
import java.awt.Color;
|
|
||||||
import java.awt.Dimension;
|
|
||||||
import java.awt.FlowLayout;
|
|
||||||
|
|
||||||
import javax.swing.JButton;
|
|
||||||
import javax.swing.JFrame;
|
|
||||||
import javax.swing.JPanel;
|
|
||||||
|
|
||||||
public class Flowlayout {
|
|
||||||
|
|
||||||
/*
|
|
||||||
* - Ordent die Komponenten innerhalb eines Containers in einer einzigen Zeile
|
|
||||||
* - Ausrichtung: Die Komponenten können linksbündig (LEFT), zentriert (CENTER), oder rechtsbündig (RIGHT) ausgerichtet werden.
|
|
||||||
* - hier wird auch angezeigt, wie man button auf Panel paltziert
|
|
||||||
* Hinweis: FlowLayout bietet keine Möglichkeit, eine einzelne Komponente manuell zu platzieren.
|
|
||||||
*/
|
|
||||||
|
|
||||||
public static void main(String[] args) {
|
|
||||||
|
|
||||||
// Erstelle ein JFrame-Fenster
|
|
||||||
JFrame fenster = new JFrame();
|
|
||||||
|
|
||||||
// Beendet das Programm beim Schließen des Fensters
|
|
||||||
fenster.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
|
|
||||||
|
|
||||||
// Legt die Größe des Fensters auf 500x500 Pixel fest
|
|
||||||
fenster.setSize(500, 500);
|
|
||||||
|
|
||||||
// Setzt das Layout des Fensters auf FlowLayout mit zentrierter Ausrichtung und
|
|
||||||
// Abständen von 10 Pixeln
|
|
||||||
fenster.setLayout(new FlowLayout(FlowLayout.CENTER, 10, 10));
|
|
||||||
|
|
||||||
// Erstelle ein JPanel mit vordefinierter Größe 250x250 Pixel und hellgrauem
|
|
||||||
// Hintergrund
|
|
||||||
JPanel panel1 = new JPanel();
|
|
||||||
panel1.setPreferredSize(new Dimension(250, 250));
|
|
||||||
panel1.setBackground(Color.lightGray);
|
|
||||||
|
|
||||||
// Setzt das Layout von panel1 ebenfalls auf FlowLayout
|
|
||||||
panel1.setLayout(new FlowLayout());
|
|
||||||
|
|
||||||
// Füge dem Panel 9 Buttons hinzu, die in einer Zeile oder mehreren Zeilen
|
|
||||||
// angeordnet werden
|
|
||||||
panel1.add(new JButton("1"));
|
|
||||||
panel1.add(new JButton("2"));
|
|
||||||
panel1.add(new JButton("3"));
|
|
||||||
panel1.add(new JButton("4"));
|
|
||||||
panel1.add(new JButton("5"));
|
|
||||||
panel1.add(new JButton("6"));
|
|
||||||
panel1.add(new JButton("7"));
|
|
||||||
panel1.add(new JButton("8"));
|
|
||||||
panel1.add(new JButton("9"));
|
|
||||||
|
|
||||||
// Füge das Panel dem JFrame hinzu
|
|
||||||
fenster.add(panel1);
|
|
||||||
|
|
||||||
// Macht das Fenster sichtbar
|
|
||||||
fenster.setVisible(true);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
@ -1,31 +0,0 @@
|
||||||
package GUIAnwendungen;
|
|
||||||
|
|
||||||
import javax.swing.*;
|
|
||||||
import java.awt.*;
|
|
||||||
import java.awt.BorderLayout;
|
|
||||||
import java.awt.Color;
|
|
||||||
import java.awt.Dimension;
|
|
||||||
import java.awt.FlowLayout;
|
|
||||||
import java.awt.GridLayout;
|
|
||||||
|
|
||||||
import javax.swing.JButton;
|
|
||||||
import javax.swing.JFrame;
|
|
||||||
import javax.swing.JPanel;
|
|
||||||
public class GridBagLayoutExample {
|
|
||||||
/*- manuell positionien von Elementen
|
|
||||||
* - in viel flexibleres Layout-Manager, bei dem du die Position,
|
|
||||||
* Größe und Ausdehnung (über mehrere Zeilen/Spalten) der einzelnen Komponenten präzise steuern kannst.
|
|
||||||
* - Du kannst einzelne Komponenten unterschiedlich groß machen, sie über mehrere Zellen spannen und Abstände festlegen.
|
|
||||||
*/
|
|
||||||
public static void main(String[] args) {
|
|
||||||
JFrame frame = new JFrame("GridBagLayout Example");
|
|
||||||
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
|
|
||||||
frame.setLayout(null);
|
|
||||||
JButton button1 = new JButton("Button1");
|
|
||||||
frame.add(button1);
|
|
||||||
|
|
||||||
button1.setBounds(0, 0, 120, 30);
|
|
||||||
frame.setSize(800, 800);
|
|
||||||
frame.setVisible(true);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
@ -1,42 +0,0 @@
|
||||||
package GUIAnwendungen;
|
|
||||||
|
|
||||||
import java.awt.BorderLayout;
|
|
||||||
import java.awt.Color;
|
|
||||||
import java.awt.Dimension;
|
|
||||||
import java.awt.FlowLayout;
|
|
||||||
import java.awt.GridLayout;
|
|
||||||
|
|
||||||
import javax.swing.JButton;
|
|
||||||
import javax.swing.JFrame;
|
|
||||||
import javax.swing.JPanel;
|
|
||||||
|
|
||||||
public class Gridlayout {
|
|
||||||
|
|
||||||
public static void main(String[] args) {
|
|
||||||
|
|
||||||
// Erstelle ein JFrame-Fenster
|
|
||||||
JFrame fenster = new JFrame();
|
|
||||||
|
|
||||||
// Beendet das Programm beim Schließen des Fensters
|
|
||||||
fenster.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
|
|
||||||
|
|
||||||
// Legt die Größe des Fensters auf 500x500 Pixel fest
|
|
||||||
fenster.setSize(500, 500);
|
|
||||||
fenster.setLayout(new GridLayout(4,3,10,4));
|
|
||||||
|
|
||||||
fenster.add(new JButton("1"));
|
|
||||||
fenster.add(new JButton("2"));
|
|
||||||
fenster.add(new JButton("3"));
|
|
||||||
fenster.add(new JButton("4"));
|
|
||||||
fenster.add(new JButton("5"));
|
|
||||||
fenster.add(new JButton("6"));
|
|
||||||
fenster.add(new JButton("7"));
|
|
||||||
fenster.add(new JButton("8"));
|
|
||||||
fenster.add(new JButton("9"));
|
|
||||||
|
|
||||||
fenster.setVisible(true);
|
|
||||||
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
@ -1,40 +0,0 @@
|
||||||
package GUIAnwendungen;
|
|
||||||
|
|
||||||
import java.awt.Color;
|
|
||||||
|
|
||||||
import javax.swing.JFrame;
|
|
||||||
|
|
||||||
public class Jframe {
|
|
||||||
|
|
||||||
/*
|
|
||||||
* - mit der Klasse(JFrame) erzeugen wir ein Fenster
|
|
||||||
*/
|
|
||||||
|
|
||||||
public static void main(String[] args) {
|
|
||||||
|
|
||||||
// Erstelle ein Fenster
|
|
||||||
JFrame frame = new JFrame();
|
|
||||||
|
|
||||||
//setVisible(boolean): gibt an, ob mein Fenster sichtbar ist oder nicht
|
|
||||||
frame.setVisible(true);
|
|
||||||
|
|
||||||
//setSize(width, height)
|
|
||||||
frame.setSize(420, 500);
|
|
||||||
|
|
||||||
// setzte einen Überschrift für mein Fenster
|
|
||||||
frame.setTitle("Mein erstes Fenster");
|
|
||||||
|
|
||||||
// Schließe das Fenster richtig zu
|
|
||||||
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
|
|
||||||
|
|
||||||
// Mein Fenster kann ab jetzt nicht mehr vergößert oder verkleinert werden
|
|
||||||
frame.setResizable(false);
|
|
||||||
|
|
||||||
//gib das Fenster eine Farbe
|
|
||||||
frame.getContentPane().setBackground(Color.green);
|
|
||||||
//oder rgb Farbe
|
|
||||||
frame.getContentPane().setBackground(new Color(0,0,100));
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
@ -1,42 +0,0 @@
|
||||||
package GUIAnwendungen;
|
|
||||||
|
|
||||||
import java.awt.Color;
|
|
||||||
import java.awt.Font;
|
|
||||||
|
|
||||||
import javax.swing.BorderFactory;
|
|
||||||
import javax.swing.ImageIcon;
|
|
||||||
import javax.swing.JFrame;
|
|
||||||
import javax.swing.JLabel;
|
|
||||||
import javax.swing.JPanel;
|
|
||||||
import javax.swing.border.Border;
|
|
||||||
|
|
||||||
// mit Jpanel kann man alle grafischen Bauelemente einsetzen
|
|
||||||
public class Jpanel {
|
|
||||||
|
|
||||||
public static void main(String[] args) {
|
|
||||||
JPanel panel = new JPanel();
|
|
||||||
panel.setBackground(Color.red);
|
|
||||||
// setze eine Grafisches Bauelement (int x, int y, int width, int height)
|
|
||||||
panel.setBounds(100, 100, 10, 10);
|
|
||||||
|
|
||||||
|
|
||||||
JFrame frame = new JFrame();
|
|
||||||
|
|
||||||
//stellt sicher, dass keine automatische Positionierung und Größenanpassung erhalten
|
|
||||||
frame.setLayout(null);
|
|
||||||
|
|
||||||
// setSize(width, height)
|
|
||||||
frame.setSize(750, 750);
|
|
||||||
|
|
||||||
// setzte einen Überschrift für mein Fenster
|
|
||||||
frame.setTitle("Mein erstes Fenster");
|
|
||||||
|
|
||||||
//setVisible(boolean): gibt an, ob mein Fenster sichtbar ist oder nicht
|
|
||||||
frame.setVisible(true);
|
|
||||||
|
|
||||||
frame.add(panel);
|
|
||||||
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
@ -1,31 +0,0 @@
|
||||||
package GUIAnwendungen;
|
|
||||||
|
|
||||||
import javax.swing.*;
|
|
||||||
import java.awt.event.ActionEvent;
|
|
||||||
|
|
||||||
public class KeyBindingsExample extends JFrame {
|
|
||||||
public KeyBindingsExample() {
|
|
||||||
setTitle("KeyBindings Beispiel");
|
|
||||||
setSize(300, 200);
|
|
||||||
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
|
|
||||||
|
|
||||||
// Panel erstellen
|
|
||||||
JPanel panel = new JPanel();
|
|
||||||
add(panel);
|
|
||||||
|
|
||||||
// KeyBinding hinzufügen: 'A' Taste
|
|
||||||
panel.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW).put(KeyStroke.getKeyStroke("A"), "keyA");
|
|
||||||
panel.getActionMap().put("keyA", new AbstractAction() {
|
|
||||||
@Override
|
|
||||||
public void actionPerformed(ActionEvent e) {
|
|
||||||
System.out.println("Taste 'A' wurde gedrückt (KeyBindings).");
|
|
||||||
}
|
|
||||||
});
|
|
||||||
|
|
||||||
setVisible(true);
|
|
||||||
}
|
|
||||||
|
|
||||||
public static void main(String[] args) {
|
|
||||||
new KeyBindingsExample();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
@ -1,83 +0,0 @@
|
||||||
package GUIAnwendungen;
|
|
||||||
|
|
||||||
import java.awt.Color;
|
|
||||||
import java.awt.Font;
|
|
||||||
|
|
||||||
import javax.swing.BorderFactory;
|
|
||||||
import javax.swing.ImageIcon;
|
|
||||||
import javax.swing.JFrame;
|
|
||||||
import javax.swing.JLabel;
|
|
||||||
import javax.swing.border.Border;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* JLabel = ist ein GUI Anzeiger für hinzufügen von Texten und Bildern
|
|
||||||
*/
|
|
||||||
|
|
||||||
public class Labels {
|
|
||||||
|
|
||||||
public static void main(String[] args) {
|
|
||||||
// Erstelle eine Label
|
|
||||||
JLabel label = new JLabel();
|
|
||||||
|
|
||||||
// Erstelle einen Border für das Fenster
|
|
||||||
Border b1 = BorderFactory.createLineBorder(Color.GREEN,5);
|
|
||||||
|
|
||||||
// füge den Text auf dem Fenster hinzu
|
|
||||||
label.setText("Hall Welt");
|
|
||||||
|
|
||||||
/*
|
|
||||||
* - Mit diesen zwei Methode positioniere ich den Text auf dem Bild
|
|
||||||
* 1. setHorizontalTextPosition(JLabel.CENTER); set Text LEFT,CENTER,RIGHT auf dem Bild
|
|
||||||
* 2. label.setVerticalTextPosition(JLabel.TOP);set Text TOP,CENTER, DOWN auf dem Bild
|
|
||||||
* - man kann auch integer Werte eingeben
|
|
||||||
*/
|
|
||||||
label.setHorizontalTextPosition(JLabel.CENTER); // Horozional
|
|
||||||
label.setVerticalTextPosition(JLabel.TOP); // vertikal
|
|
||||||
|
|
||||||
// gib für den Schrifft eine Farbe aus der Klasse Color ein
|
|
||||||
// entweder:
|
|
||||||
label.setForeground(Color.GREEN);
|
|
||||||
// oder:
|
|
||||||
label.setForeground(new Color(0,0,100));
|
|
||||||
|
|
||||||
//gib Schriftart aus der Klasse Font ein
|
|
||||||
label.setFont(new Font("MV Boli",Font.PLAIN,20));
|
|
||||||
|
|
||||||
// verschiebe den Text nach beliebg Position
|
|
||||||
label.setIconTextGap(20);
|
|
||||||
|
|
||||||
// setze eine Farbe für Background
|
|
||||||
label.setBackground(Color.black);
|
|
||||||
label.setOpaque(true);
|
|
||||||
|
|
||||||
//zeige den Border auf dem Fenster
|
|
||||||
label.setBorder(b1);
|
|
||||||
|
|
||||||
|
|
||||||
//füge ein Bild hinzu
|
|
||||||
ImageIcon image = new ImageIcon("C:\\Users\\obaya\\eclipse-workspace\\OOP\\src\\GUIAnwendungen\\Test.jpg");
|
|
||||||
label.setIcon(image);
|
|
||||||
|
|
||||||
|
|
||||||
// Erstelle ein Fenster
|
|
||||||
JFrame frame = new JFrame();
|
|
||||||
// setSize(width, height)
|
|
||||||
frame.setSize(500, 500);
|
|
||||||
|
|
||||||
// setzte einen Überschrift für mein Fenster
|
|
||||||
frame.setTitle("Mein erstes Fenster");
|
|
||||||
|
|
||||||
//setVisible(boolean): gibt an, ob mein Fenster sichtbar ist oder nicht
|
|
||||||
frame.setVisible(true);
|
|
||||||
|
|
||||||
// zeige den Text auf dem Fenster
|
|
||||||
frame.add(label);
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
@ -1,63 +0,0 @@
|
||||||
package GUIAnwendungen;
|
|
||||||
|
|
||||||
import javax.swing.JFrame;
|
|
||||||
import javax.swing.JOptionPane;
|
|
||||||
|
|
||||||
public class ShowMessage {
|
|
||||||
|
|
||||||
/*
|
|
||||||
* - erstellt einfache Dialogfenster (Pop-up-Fenster)
|
|
||||||
* - können verwendet werden, um Nachrichten anzuzeigen, Eingaben vom Benutzer zu erfassen oder den Benutzer vor bestimmten Aktionen zu warnen.
|
|
||||||
* - durch null kann man viele sachen ersetzen:
|
|
||||||
* . Fenster
|
|
||||||
* . Jpanel
|
|
||||||
* . public MeinFenster() {
|
|
||||||
super("Mein Fenster");
|
|
||||||
JOptionPane.showMessageDialog(this, "Beispiel.", "Titel", JOptionPane.WARNING_MESSAGE);
|
|
||||||
|
|
||||||
. etc...
|
|
||||||
}
|
|
||||||
*/
|
|
||||||
|
|
||||||
public static void main(String[] args) {
|
|
||||||
// Erstelle ein JFrame-Fenster mit dem Titel "Mein Fenster"
|
|
||||||
JFrame fenster = new JFrame("Mein Fenster");
|
|
||||||
|
|
||||||
// Zeige eine Fehlermeldung in einem Dialog an, zentriert relativ zu 'fenster'
|
|
||||||
JOptionPane.showMessageDialog(fenster, "Beispiel.", "title", JOptionPane.ERROR_MESSAGE);
|
|
||||||
|
|
||||||
// Zeige eine Informationsmeldung in einem Dialog an, zentriert auf dem Bildschirm
|
|
||||||
JOptionPane.showMessageDialog(null, "Beispiel..", "title", JOptionPane.INFORMATION_MESSAGE);
|
|
||||||
|
|
||||||
// Zeige eine Frage in einem Dialog an, zentriert auf dem Bildschirm
|
|
||||||
JOptionPane.showMessageDialog(null, "Beispiel.", "title", JOptionPane.QUESTION_MESSAGE);
|
|
||||||
|
|
||||||
// Zeige eine Warnung in einem Dialog an, zentriert auf dem Bildschirm
|
|
||||||
JOptionPane.showMessageDialog(null, "Beispiel.", "title", JOptionPane.WARNING_MESSAGE);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Zeige einen Bestätigungsdialog an, um den Benutzer zu fragen,
|
|
||||||
* ob er fortfahren möchte (Ja/Nein/Abbrechen).
|
|
||||||
* Antwort wird in 'antwort' gespeichert.
|
|
||||||
*/
|
|
||||||
int antwort = JOptionPane.showConfirmDialog(null, "Möchten Sie fortfahren?");
|
|
||||||
if (antwort == JOptionPane.YES_OPTION) {
|
|
||||||
// Benutzer hat 'Ja' gewählt
|
|
||||||
System.out.println("Benutzer hat 'Ja' gewählt.");
|
|
||||||
} else if (antwort == JOptionPane.NO_OPTION) {
|
|
||||||
// Benutzer hat 'Nein' gewählt
|
|
||||||
System.out.println("Benutzer hat 'Nein' gewählt.");
|
|
||||||
} else if (antwort == JOptionPane.CANCEL_OPTION) {
|
|
||||||
// Benutzer hat 'Abbrechen' gewählt
|
|
||||||
System.out.println("Benutzer hat 'Cancel' gewählt.");
|
|
||||||
}
|
|
||||||
|
|
||||||
// Zeige einen Eingabedialog an, um den Benutzer nach seinem Namen zu fragen
|
|
||||||
String eingabe = JOptionPane.showInputDialog("Geben Sie Ihren Namen ein:");
|
|
||||||
// Gib den eingegebenen Namen in der Konsole aus
|
|
||||||
System.out.println("Benutzername: " + eingabe);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
Binary file not shown.
|
Before Width: | Height: | Size: 20 KiB |
|
|
@ -1,58 +0,0 @@
|
||||||
package GUIAnwendungen;
|
|
||||||
|
|
||||||
import java.awt.Dimension;
|
|
||||||
import java.awt.FlowLayout;
|
|
||||||
import java.awt.event.ActionEvent;
|
|
||||||
import java.awt.event.ActionListener;
|
|
||||||
import javax.swing.JButton;
|
|
||||||
import javax.swing.JFrame;
|
|
||||||
import javax.swing.JTextField;
|
|
||||||
|
|
||||||
/*Beschreibung das Problem:
|
|
||||||
* Instanzvariablen sollten verwendet werden, wenn du sicherstellen möchtest, dass Variablen wie JButton und JTextField in der gesamten Klasse (und in actionPerformed) sichtbar sind.
|
|
||||||
Der Konstruktor der Klasse wird verwendet, um die GUI-Komponenten zu initialisieren und das Fenster aufzubauen.
|
|
||||||
Die main-Methode ist static und dient dazu, die Anwendung zu starten, indem sie eine Instanz der Klasse erstellt.
|
|
||||||
Anonyme innere Klassen sind eine praktische Möglichkeit, wenn du einfache Event-Handling-Logik direkt in der main-Methode implementieren möchtest, ohne eine zusätzliche Klasse oder Instanzmethoden zu erstellen.
|
|
||||||
*
|
|
||||||
*/
|
|
||||||
|
|
||||||
public class TextEingaben extends JFrame implements ActionListener {
|
|
||||||
// Instanzvariablen
|
|
||||||
private JTextField textField;
|
|
||||||
private JButton button1;
|
|
||||||
|
|
||||||
// Konstruktor
|
|
||||||
public TextEingaben() {
|
|
||||||
// Initialisiere das Textfeld und den Button
|
|
||||||
textField = new JTextField();
|
|
||||||
textField.setPreferredSize(new Dimension(240, 40));
|
|
||||||
|
|
||||||
button1 = new JButton("Submit");
|
|
||||||
button1.setPreferredSize(new Dimension(240, 40));
|
|
||||||
button1.addActionListener(this); // `this` verweist auf das aktuelle Objekt der Klasse
|
|
||||||
|
|
||||||
// Setze das Layout und füge die Komponenten hinzu
|
|
||||||
setLayout(new FlowLayout());
|
|
||||||
add(textField);
|
|
||||||
add(button1);
|
|
||||||
|
|
||||||
// Konfiguriere das JFrame
|
|
||||||
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
|
|
||||||
setSize(500, 500);
|
|
||||||
setVisible(true);
|
|
||||||
}
|
|
||||||
|
|
||||||
// Die Methode wird aufgerufen, wenn der Button gedrückt wird
|
|
||||||
@Override
|
|
||||||
public void actionPerformed(ActionEvent e) {
|
|
||||||
if (e.getSource() == button1) {
|
|
||||||
System.out.println("Hallo " + textField.getText());
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
public static void main(String[] args) {
|
|
||||||
// Erstelle eine Instanz der Klasse, wodurch der Konstruktor aufgerufen wird
|
|
||||||
new TextEingaben();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
@ -1,95 +0,0 @@
|
||||||
package GUIAnwendungen;
|
|
||||||
import java.awt.Color;
|
|
||||||
import java.awt.Font;
|
|
||||||
|
|
||||||
import javax.swing.BorderFactory;
|
|
||||||
import javax.swing.ImageIcon;
|
|
||||||
import javax.swing.JButton;
|
|
||||||
import javax.swing.JFrame;
|
|
||||||
import javax.swing.JLabel;
|
|
||||||
import javax.swing.JPanel;
|
|
||||||
import javax.swing.border.Border;
|
|
||||||
import javax.swing.*;
|
|
||||||
import java.awt.event.ActionEvent;
|
|
||||||
import java.awt.event.ActionListener;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* - ActionListener ist ein (marker)Interface Klasse,
|
|
||||||
* die nur eine abstrakte Methode hat, die mit drücken auf Button reagiert
|
|
||||||
*
|
|
||||||
* Also Das Kochrezept:
|
|
||||||
* 1. Button erstellen: JButton button = new JButton("Text");
|
|
||||||
* 2. ActionListener implementieren: Implementiere ActionListener, um die Funktionalität zu definieren.
|
|
||||||
* 3. ActionListener zum Button hinzufügen:
|
|
||||||
* 3.1 button.addActionListener(new ActionListener() { ... });
|
|
||||||
* 3.2 oder mit separater Methode: button.addActionListener(e -> deineMethode());
|
|
||||||
*/
|
|
||||||
public class jbutton implements ActionListener {
|
|
||||||
|
|
||||||
public static void main(String[] args) {
|
|
||||||
//1.
|
|
||||||
JButton button = new JButton();
|
|
||||||
// x y width height
|
|
||||||
button.setBounds(100,100,200, 50);
|
|
||||||
button.setText("Click me");
|
|
||||||
button.addActionListener(null);
|
|
||||||
|
|
||||||
// 2. Hinzufügen des ActionListeners zum Button
|
|
||||||
JLabel label = new JLabel();
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Position und Größe des Labels eingeben warum?
|
|
||||||
* weil ich frame.setLayout(null); aktiviert habe
|
|
||||||
*/
|
|
||||||
label.setBounds(150, 50, 100, 50);
|
|
||||||
/*
|
|
||||||
* new ActionListener() ist nicht das Erzeugen einer Instanz des Interfaces selbst,
|
|
||||||
* sondern das Erstellen einer Instanz einer anonymen Klasse, die das ActionListener-Interface implementiert.
|
|
||||||
*/
|
|
||||||
button.addActionListener(new ActionListener() {
|
|
||||||
@Override
|
|
||||||
public void actionPerformed(ActionEvent e) {
|
|
||||||
// Dies ist die Aktion, die ausgeführt wird, wenn der Button geklickt wird
|
|
||||||
clicked(label);
|
|
||||||
}
|
|
||||||
});
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
// Erstelle ein Fenster
|
|
||||||
JFrame frame = new JFrame();
|
|
||||||
|
|
||||||
//stellt sicher, dass keine automatische Positionierung und Größenanpassung erhalten
|
|
||||||
frame.setLayout(null);
|
|
||||||
|
|
||||||
// setSize(width, height)
|
|
||||||
frame.setSize(750, 750);
|
|
||||||
|
|
||||||
// setzte einen Überschrift für mein Fenster
|
|
||||||
frame.setTitle("Mein erstes Fenster");
|
|
||||||
|
|
||||||
//setVisible(boolean): gibt an, ob mein Fenster sichtbar ist oder nicht
|
|
||||||
frame.setVisible(true);
|
|
||||||
frame.add(label);
|
|
||||||
frame.add(button);
|
|
||||||
// andere Möglichkeit, button auf Fenster zu zeigen
|
|
||||||
// frame.add(new JButton("name"))
|
|
||||||
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
public static void clicked(JLabel label) {
|
|
||||||
label.setText("Hall Welt");
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
@Override
|
|
||||||
public void actionPerformed(ActionEvent e) {
|
|
||||||
// TODO Auto-generated method stub
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
@ -1,16 +0,0 @@
|
||||||
package JunitTest;
|
|
||||||
|
|
||||||
public class Einführung {
|
|
||||||
/*White-Box && Black-Box was ist das?
|
|
||||||
* - Black-Box-Test: Du prüfst nur die Eingaben und Ausgaben, ohne den Code zu sehen oder zu verstehen. Es geht nur darum, ob die Software das Richtige tut.
|
|
||||||
* - White-Box-Test: Du schaust dir den Code genau an und prüfst, ob jede Zeile und jedes Detail korrekt funktioniert. Hier verstehst du den Code und testest ihn gezielt.
|
|
||||||
*/
|
|
||||||
public static void main(String[] args) {
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
public int add(int a, int b) {
|
|
||||||
return a+b;
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
@ -1,14 +0,0 @@
|
||||||
package JunitTest;
|
|
||||||
|
|
||||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
|
||||||
|
|
||||||
import org.junit.jupiter.api.Test;
|
|
||||||
|
|
||||||
public class EinführungTest {
|
|
||||||
|
|
||||||
@Test
|
|
||||||
public void testAdd() {
|
|
||||||
Einführung e1 = new Einführung();
|
|
||||||
assertEquals(4, e1.add(2, 2));
|
|
||||||
}
|
|
||||||
}
|
|
||||||
Binary file not shown.
|
|
@ -1,82 +0,0 @@
|
||||||
package Linked_List;
|
|
||||||
|
|
||||||
public class ElementList {
|
|
||||||
Node head;
|
|
||||||
|
|
||||||
// ADD Methoden
|
|
||||||
public void addAtIndex(int value, int index) {
|
|
||||||
// Erstelle eine neue Knote
|
|
||||||
Node newNode = new Node();
|
|
||||||
// setze drin einen Wert
|
|
||||||
newNode.value = value;
|
|
||||||
// falls meine Liste leer ist!
|
|
||||||
if (head == null) {
|
|
||||||
head = newNode;
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
|
|
||||||
if (index == 0) {
|
|
||||||
newNode.next = head;
|
|
||||||
head = newNode;
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
|
|
||||||
Node temp = head;
|
|
||||||
for (int i = 0; i < index - 1 && temp.next != null ; i++)
|
|
||||||
temp = temp.next;
|
|
||||||
|
|
||||||
newNode.next = temp.next;
|
|
||||||
temp.next = newNode;
|
|
||||||
}
|
|
||||||
public void addLast(int value) {
|
|
||||||
// Erstelle eine neue Knote
|
|
||||||
Node newNode = new Node();
|
|
||||||
// setze drin einen Wert
|
|
||||||
newNode.value = value;
|
|
||||||
// falls meine Liste leer ist!
|
|
||||||
if (head == null) {
|
|
||||||
head = newNode;
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
// falls nicht!
|
|
||||||
Node temp = head;
|
|
||||||
while (temp.next != null)
|
|
||||||
temp = temp.next;
|
|
||||||
|
|
||||||
temp.next = newNode;
|
|
||||||
}
|
|
||||||
public void addFirst(int value) {
|
|
||||||
// Erstelle eine neue Knote
|
|
||||||
Node newNode = new Node();
|
|
||||||
// setze drin einen Wert
|
|
||||||
newNode.value = value;
|
|
||||||
|
|
||||||
if (head == null)
|
|
||||||
head = newNode;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* newNode.next = null, aber ist jetzt nicht mehr null,
|
|
||||||
* weil es jetzt gleich head;
|
|
||||||
*/
|
|
||||||
newNode.next = head;
|
|
||||||
head = newNode;
|
|
||||||
|
|
||||||
}
|
|
||||||
//---------------------------------------------------
|
|
||||||
|
|
||||||
|
|
||||||
public void printList() {
|
|
||||||
if (head == null)
|
|
||||||
return;
|
|
||||||
|
|
||||||
Node temp =head;
|
|
||||||
System.out.print("[");
|
|
||||||
while(temp != null) {
|
|
||||||
System.out.print(temp.value + " ");
|
|
||||||
temp = temp.next;
|
|
||||||
}
|
|
||||||
System.out.print("]");
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
@ -1,6 +0,0 @@
|
||||||
package Linked_List;
|
|
||||||
|
|
||||||
public class Node {
|
|
||||||
int value;
|
|
||||||
Node next;
|
|
||||||
}
|
|
||||||
|
|
@ -1,15 +0,0 @@
|
||||||
package Linked_List;
|
|
||||||
|
|
||||||
public class Test {
|
|
||||||
|
|
||||||
public static void main(String[] args) {
|
|
||||||
ElementList e1 = new ElementList();
|
|
||||||
e1.addLast(1);
|
|
||||||
e1.addLast(2);
|
|
||||||
e1.addLast(3);
|
|
||||||
e1.addLast(5);
|
|
||||||
e1.addAtIndex(10,2);
|
|
||||||
e1.printList();
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
Binary file not shown.
|
|
@ -1,91 +0,0 @@
|
||||||
package MVC_Desighn;
|
|
||||||
|
|
||||||
// Modell, oder domain
|
|
||||||
public class Person_Daten {
|
|
||||||
private String name;
|
|
||||||
private int alter;
|
|
||||||
|
|
||||||
public Person_Daten(String name, int alter) {
|
|
||||||
this.name = name;
|
|
||||||
setAlter(alter);
|
|
||||||
}
|
|
||||||
|
|
||||||
public String getName() {
|
|
||||||
return name;
|
|
||||||
}
|
|
||||||
public void setName(String name) {
|
|
||||||
this.name = name;
|
|
||||||
}
|
|
||||||
public int getAlter() {
|
|
||||||
return alter;
|
|
||||||
}
|
|
||||||
public void setAlter(int alter) {
|
|
||||||
if (alter > 18)
|
|
||||||
this.alter = alter;
|
|
||||||
else
|
|
||||||
System.out.println("Sie sind sehr jung");
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
@Override
|
|
||||||
public String toString() {
|
|
||||||
return "Person_Daten [name=" + name + ", alter=" + alter + "]";
|
|
||||||
}
|
|
||||||
|
|
||||||
public static void main(String[] args) {
|
|
||||||
|
|
||||||
Person_Daten p1 = new Person_Daten("obai" , 22);
|
|
||||||
GUI_DatenView v1 = new GUI_DatenView();
|
|
||||||
|
|
||||||
Controller_DatenPerson c1 = new Controller_DatenPerson(p1,v1);
|
|
||||||
|
|
||||||
c1.updateView();
|
|
||||||
c1.setPersonName("omar");
|
|
||||||
c1.updateView();
|
|
||||||
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
//View oder GUI
|
|
||||||
class GUI_DatenView {
|
|
||||||
|
|
||||||
public void printDatenPerson(String name, int alter) {
|
|
||||||
System.out.println("GUI_DatenView [name=" + name + ", alter=" + alter + "]");
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
// Controller
|
|
||||||
class Controller_DatenPerson{
|
|
||||||
Person_Daten modell;
|
|
||||||
GUI_DatenView view;
|
|
||||||
|
|
||||||
public Controller_DatenPerson(Person_Daten modell, GUI_DatenView view) {
|
|
||||||
this.modell = modell;
|
|
||||||
this.view = view;
|
|
||||||
}
|
|
||||||
|
|
||||||
public String getPersonName() {
|
|
||||||
return this.modell.getName();
|
|
||||||
}
|
|
||||||
|
|
||||||
public void setPersonName(String name) {
|
|
||||||
modell.setName(name);
|
|
||||||
}
|
|
||||||
|
|
||||||
public int getPersonAlter() {
|
|
||||||
return this.modell.getAlter();
|
|
||||||
}
|
|
||||||
|
|
||||||
public void updateView() {
|
|
||||||
|
|
||||||
view.printDatenPerson(modell.getName(),modell.getAlter());
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
@ -1,156 +0,0 @@
|
||||||
package MVC_Desighn;
|
|
||||||
|
|
||||||
import java.awt.event.ActionEvent;
|
|
||||||
import java.awt.event.ActionListener;
|
|
||||||
|
|
||||||
import javax.swing.JButton;
|
|
||||||
import javax.swing.JFrame;
|
|
||||||
import javax.swing.JLabel;
|
|
||||||
import javax.swing.JTextField;
|
|
||||||
|
|
||||||
// modell
|
|
||||||
class Person {
|
|
||||||
private String name;
|
|
||||||
private int age;
|
|
||||||
|
|
||||||
// Konstruktor
|
|
||||||
public Person(String name, int age) throws IllegalArgumentException {
|
|
||||||
this.setName(name);
|
|
||||||
this.setAge(age);
|
|
||||||
}
|
|
||||||
|
|
||||||
// Getter für Name
|
|
||||||
public String getName() {
|
|
||||||
return name;
|
|
||||||
}
|
|
||||||
|
|
||||||
// Setter für Name
|
|
||||||
public void setName(String name) {
|
|
||||||
this.name = name;
|
|
||||||
}
|
|
||||||
|
|
||||||
// Getter für Alter
|
|
||||||
public int getAge() {
|
|
||||||
return age;
|
|
||||||
}
|
|
||||||
|
|
||||||
// Setter für Alter
|
|
||||||
public void setAge(int age) throws IllegalArgumentException {
|
|
||||||
if (age <= 18) {
|
|
||||||
throw new IllegalArgumentException("Das Alter muss größer als 18 sein.");
|
|
||||||
}
|
|
||||||
this.age = age;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
//view
|
|
||||||
public class Person_GUI {
|
|
||||||
private JFrame frame;
|
|
||||||
private JTextField nameTextField;
|
|
||||||
private JButton updateButton;
|
|
||||||
private JLabel nameLabel;
|
|
||||||
private JLabel ageLabel;
|
|
||||||
|
|
||||||
public Person_GUI() {
|
|
||||||
// Setup des Frames
|
|
||||||
frame = new JFrame("Person Details");
|
|
||||||
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
|
|
||||||
frame.setSize(300, 200);
|
|
||||||
frame.setLayout(null);
|
|
||||||
|
|
||||||
// Name Label
|
|
||||||
nameLabel = new JLabel("Name:");
|
|
||||||
nameLabel.setBounds(10, 20, 80, 25);
|
|
||||||
frame.add(nameLabel);
|
|
||||||
|
|
||||||
// Age Label
|
|
||||||
ageLabel = new JLabel("Alter:");
|
|
||||||
ageLabel.setBounds(10, 50, 80, 25);
|
|
||||||
frame.add(ageLabel);
|
|
||||||
|
|
||||||
// Name Textfeld
|
|
||||||
nameTextField = new JTextField(20);
|
|
||||||
nameTextField.setBounds(100, 20, 165, 25);
|
|
||||||
frame.add(nameTextField);
|
|
||||||
|
|
||||||
// Update Button
|
|
||||||
updateButton = new JButton("Name ändern");
|
|
||||||
updateButton.setBounds(100, 80, 165, 25);
|
|
||||||
frame.add(updateButton);
|
|
||||||
|
|
||||||
// Frame sichtbar machen
|
|
||||||
frame.setVisible(true);
|
|
||||||
}
|
|
||||||
|
|
||||||
public String getNameInput() {
|
|
||||||
return nameTextField.getText();
|
|
||||||
}
|
|
||||||
|
|
||||||
public void setPersonDetails(String name, int age) {
|
|
||||||
nameLabel.setText("Name: " + name);
|
|
||||||
ageLabel.setText("Alter: " + age);
|
|
||||||
}
|
|
||||||
|
|
||||||
public void addUpdateButtonListener(ActionListener listener) {
|
|
||||||
updateButton.addActionListener(listener);
|
|
||||||
}
|
|
||||||
|
|
||||||
public static void main(String[] args) {
|
|
||||||
|
|
||||||
// Erstellen des Modells
|
|
||||||
Person model = new Person("Max Mustermann", 20);
|
|
||||||
|
|
||||||
// Erstellen der Ansicht
|
|
||||||
Person_GUI view = new MVC_Desighn.Person_GUI();
|
|
||||||
|
|
||||||
// Erstellen des Controllers
|
|
||||||
PersonController controller = new PersonController(model, view);
|
|
||||||
|
|
||||||
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
class PersonController {
|
|
||||||
private Person model;
|
|
||||||
private Person_GUI view;
|
|
||||||
|
|
||||||
public PersonController(Person model, Person_GUI view) {
|
|
||||||
this.model = model;
|
|
||||||
this.view = view;
|
|
||||||
|
|
||||||
// Initialisieren der View mit den aktuellen Modelldaten
|
|
||||||
this.view.setPersonDetails(model.getName(), model.getAge());
|
|
||||||
|
|
||||||
// Hinzufügen eines ActionListeners zum Button
|
|
||||||
this.view.addUpdateButtonListener(new ActionListener() {
|
|
||||||
@Override
|
|
||||||
public void actionPerformed(ActionEvent e) {
|
|
||||||
String newName = view.getNameInput();
|
|
||||||
setPersonName(newName);
|
|
||||||
updateView();
|
|
||||||
}
|
|
||||||
});
|
|
||||||
}
|
|
||||||
|
|
||||||
public void setPersonName(String name) {
|
|
||||||
model.setName(name);
|
|
||||||
}
|
|
||||||
|
|
||||||
public String getPersonName() {
|
|
||||||
return model.getName();
|
|
||||||
}
|
|
||||||
|
|
||||||
public void setPersonAge(int age) {
|
|
||||||
model.setAge(age);
|
|
||||||
}
|
|
||||||
|
|
||||||
public int getPersonAge() {
|
|
||||||
return model.getAge();
|
|
||||||
}
|
|
||||||
|
|
||||||
public void updateView() {
|
|
||||||
view.setPersonDetails(model.getName(), model.getAge());
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
@ -1,22 +0,0 @@
|
||||||
package Teste;
|
|
||||||
|
|
||||||
public class kopieArray {
|
|
||||||
|
|
||||||
public static void main(String[] args) {
|
|
||||||
/*
|
|
||||||
* das ein falsches Verfahren, um ein Array in einem anderen Array
|
|
||||||
* zu koopieren, in dem Fall kopieArray ist ein RefrenzVariable, die auf das selbe Array zeigt
|
|
||||||
* also wir haben nur ein Array und auf diese Array zeigen zwei RefrenzVariable
|
|
||||||
*/
|
|
||||||
int[] orgArray = {1,2,3,4,5};
|
|
||||||
int[] kopieArray = orgArray;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Richtige Kopie von Array
|
|
||||||
*/
|
|
||||||
int[] richtigeKopieArray = new int[orgArray.length];
|
|
||||||
for (int i = 0; i <orgArray.length; i++)
|
|
||||||
richtigeKopieArray[i] = orgArray[i];
|
|
||||||
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
@ -1,11 +0,0 @@
|
||||||
/**
|
|
||||||
*
|
|
||||||
*/
|
|
||||||
/**
|
|
||||||
*
|
|
||||||
*/
|
|
||||||
module Programmierung2 {
|
|
||||||
requires java.desktop;
|
|
||||||
requires org.junit.jupiter.api;
|
|
||||||
requires junit;
|
|
||||||
}
|
|
||||||
|
|
@ -1,45 +0,0 @@
|
||||||
package oop.Abstraction;
|
|
||||||
|
|
||||||
public abstract class Abstraction {
|
|
||||||
|
|
||||||
/*Was ist abstraction:Das Verbergen der internen Implementierung der (Methode, Funktion)
|
|
||||||
* und das Zeigen nur der Funktionalität für die Benutzer.
|
|
||||||
*
|
|
||||||
*
|
|
||||||
* wie errecihen wir die Abstraktion?
|
|
||||||
*
|
|
||||||
* 1. Abstract Class => not fully Abstraction
|
|
||||||
* 2. Interface => fully Abstraction
|
|
||||||
*
|
|
||||||
* -----------------------------------------
|
|
||||||
*
|
|
||||||
* Die abstrakte Klasse:
|
|
||||||
*
|
|
||||||
* Deklaration als abstract: Eine abstrakte Klasse muss mit dem Schlüsselwort abstract deklariert werden
|
|
||||||
* abstrakte Klassen in Java müssen vererbt werden, damit ihre abstrakten Methoden implementiert werden können
|
|
||||||
* Da abstrakte Klassen nicht instanziiert werden können (man kann also keine Objekte direkt von ihnen erstellen)
|
|
||||||
* Die Abstrakte klasse kann eine Abstrakte methode haben aber soll nicht
|
|
||||||
* Die Abstrakte klasse können final methods haben
|
|
||||||
* Die Abstrakte klasse können constructors und static methods haben
|
|
||||||
* Setter und getter sind gültig
|
|
||||||
*
|
|
||||||
* - Die Unterklasse:
|
|
||||||
* die nicht abstrakte Unterklassen muss alle abstrakte methoden implementieren!
|
|
||||||
* die abstrakte Unterklassen muss nicht alle abstrakte methoden implementieren!
|
|
||||||
*----------------------------------------
|
|
||||||
*
|
|
||||||
*Die abstrakte Methode:
|
|
||||||
*warum Abstrakte Methods? damit jede Unterklasse diese Methoden implementiert
|
|
||||||
*wenn wir eine abstrakte Methode erzeugen, soll ihre Klasse auch Abstrakt sein.
|
|
||||||
*Abstrakte Methoden können von der abstrakten Klasse nicht implemntiert werden.
|
|
||||||
*Abstrakte Methoden können nur von Unterklassen mit @Override implementiert werden.
|
|
||||||
*Abstrakte Methoden können ohne und mit Rückabe wert sein.
|
|
||||||
*Statiche und private Methodes können nicht abstrakt sein warum?
|
|
||||||
*weil satatic und private gehören nur der Klasse
|
|
||||||
*/
|
|
||||||
|
|
||||||
protected abstract void fahre();
|
|
||||||
public abstract int count();
|
|
||||||
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
@ -1,25 +0,0 @@
|
||||||
package oop.Abstraction;
|
|
||||||
|
|
||||||
public abstract class Auto {
|
|
||||||
|
|
||||||
double höhe;
|
|
||||||
double gewicht;
|
|
||||||
int anzahlDerRäder;
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
public Auto(double höhe, double gewicht, int anzahlDerRäder) {
|
|
||||||
this.höhe = höhe;
|
|
||||||
this.gewicht = gewicht;
|
|
||||||
this.anzahlDerRäder = anzahlDerRäder;
|
|
||||||
}
|
|
||||||
|
|
||||||
abstract void autopilot(); // automatischen Fahren
|
|
||||||
|
|
||||||
abstract void streamingService();
|
|
||||||
|
|
||||||
abstract void parkingSensors();
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
@ -1,19 +0,0 @@
|
||||||
package oop.Abstraction;
|
|
||||||
|
|
||||||
|
|
||||||
public class Auto2 {
|
|
||||||
|
|
||||||
class Test{
|
|
||||||
|
|
||||||
|
|
||||||
}
|
|
||||||
@FunctionalInterface
|
|
||||||
public interface Test2{
|
|
||||||
int berechne(int a, int b);
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
@ -1,29 +0,0 @@
|
||||||
package oop.Abstraction;
|
|
||||||
|
|
||||||
public class Hatchback extends Auto {
|
|
||||||
|
|
||||||
|
|
||||||
public Hatchback(double höhe, double gewicht, int anzahlDerRäder) {
|
|
||||||
super(höhe, gewicht, anzahlDerRäder);
|
|
||||||
}
|
|
||||||
|
|
||||||
@Override
|
|
||||||
void autopilot() {
|
|
||||||
System.out.println(" Hatchback : autopilot");
|
|
||||||
}
|
|
||||||
|
|
||||||
@Override
|
|
||||||
void streamingService() {
|
|
||||||
System.out.println("Hatchback : streamingService");
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
@Override
|
|
||||||
void parkingSensors() {
|
|
||||||
System.out.println(" Hatchback : parkingSensors");
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
@ -1,6 +0,0 @@
|
||||||
package oop.Abstraction;
|
|
||||||
|
|
||||||
public class MarkerInterface {
|
|
||||||
// Keine Methoden oder Konstanten
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
@ -1,14 +0,0 @@
|
||||||
package oop.Abstraction;
|
|
||||||
|
|
||||||
public interface NestedInterface {
|
|
||||||
void test();
|
|
||||||
|
|
||||||
interface InnerInterface {
|
|
||||||
default void test2() {
|
|
||||||
|
|
||||||
System.out.print("Innerinterface");
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
@ -1,29 +0,0 @@
|
||||||
package oop.Abstraction;
|
|
||||||
|
|
||||||
public class SUV extends Auto {
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
public SUV(double höhe, double gewicht, int anzahlDerRäder) {
|
|
||||||
super(höhe, gewicht, anzahlDerRäder);
|
|
||||||
}
|
|
||||||
|
|
||||||
@Override
|
|
||||||
void autopilot() {
|
|
||||||
System.out.println(" SUV : autopilot");
|
|
||||||
}
|
|
||||||
|
|
||||||
@Override
|
|
||||||
void streamingService() {
|
|
||||||
System.out.println(" SUV : streamingService");
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
@Override
|
|
||||||
void parkingSensors() {
|
|
||||||
System.out.println("SUV : parkingSensors");
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
@ -1,12 +0,0 @@
|
||||||
package oop.Abstraction;
|
|
||||||
|
|
||||||
public class Test {
|
|
||||||
|
|
||||||
public static void main(String[] args) {
|
|
||||||
|
|
||||||
// Auto SUV1 = new Auto(); Verboten da die Auto Klasse Abstrakt ist!
|
|
||||||
// Auto SUV1 = new SUV(); das ist gültig
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
@ -1,27 +0,0 @@
|
||||||
package oop.AnonymousInnerClass;
|
|
||||||
|
|
||||||
public class AnonymousInnerClass {
|
|
||||||
/*
|
|
||||||
* - ist ohne Name definiert und werden direkt in der Instanziierung (manin Methode) erstellt.
|
|
||||||
* - Verwendung: Sie werden verwendet,um Schnittstellen oder abstrakte Klassen zu implementieren
|
|
||||||
* und deren Methoden zu überschreiben, ohne eine separate, benannte Klasse zu erstellen.
|
|
||||||
* - kann entweder extends klasse oder implements interface aber (nicht beids gleichzeitig)
|
|
||||||
* - ist für methoden und Konstruktoren
|
|
||||||
* - Anonymous Inner Class können kein Konstruktoren haben, weil sie ohne Name sind!
|
|
||||||
* - Anonymous kann mehreren Methoden überschreiben
|
|
||||||
* - können über definiert werden, wo Klasseninstanzen benötigt werden
|
|
||||||
* - die Methoden und die Variablen innerhalb der Anonymous sind nur innerhalb Anonymous sichtbar
|
|
||||||
* oder ich muss z.b anstatt (Konstruktor test = new Konstruktor()) => var test = new Konstruktor()
|
|
||||||
* das ermöglicht mir die methoden und die Variable die in Anonymous in außen zu verweden
|
|
||||||
* - anonyme innere Klassen können verschachtelt werden also in anonyme ein anonyme
|
|
||||||
* - können keine statischen Variablen oder Methoden haben, das sie keinen Name haben
|
|
||||||
* - Private Elemente sind erlaubt aber sind nur innerhalb der anonyme innere Klassen sichtbar
|
|
||||||
*
|
|
||||||
* Warum benötigen wir sowas?
|
|
||||||
* für Einmalige Verwendung: Sie sind ideal für einmalige Implementierungen,
|
|
||||||
* wie z.B. Event-Handler, Callbacks oder Threads.
|
|
||||||
*
|
|
||||||
*
|
|
||||||
*/
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
@ -1,40 +0,0 @@
|
||||||
package oop.AnonymousInnerClass;
|
|
||||||
|
|
||||||
public class Interface {
|
|
||||||
|
|
||||||
public interface Showable{
|
|
||||||
|
|
||||||
void print();
|
|
||||||
}
|
|
||||||
|
|
||||||
// methode übernimmt ein Interface
|
|
||||||
static void display(Showable s) {
|
|
||||||
|
|
||||||
s.print();
|
|
||||||
}
|
|
||||||
|
|
||||||
public static void main (String[] args) {
|
|
||||||
// Anonymous Inner Class mit methode
|
|
||||||
display(new Showable() {
|
|
||||||
|
|
||||||
@Override
|
|
||||||
public void print() {
|
|
||||||
System.out.print("von der Methode");
|
|
||||||
}
|
|
||||||
});
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
// Anonymous Inner Class mit interface
|
|
||||||
Showable showable = new Showable() {
|
|
||||||
|
|
||||||
@Override
|
|
||||||
public void print() {
|
|
||||||
|
|
||||||
System.out.println("Hallo welt");
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
showable.print();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
@ -1,83 +0,0 @@
|
||||||
package oop.AnonymousInnerClass;
|
|
||||||
|
|
||||||
public class Konstruktor {
|
|
||||||
|
|
||||||
public Konstruktor() {
|
|
||||||
System.out.println("das ist Konstruktor");
|
|
||||||
}
|
|
||||||
|
|
||||||
// Methode enthält Anonymous Inner Class
|
|
||||||
public static void main() {
|
|
||||||
new Konstruktor() {
|
|
||||||
|
|
||||||
public static void print() {
|
|
||||||
System.out.println("main methode");
|
|
||||||
}
|
|
||||||
|
|
||||||
int x = 5;
|
|
||||||
@Override
|
|
||||||
public void testMethod() {
|
|
||||||
|
|
||||||
System.out.println("main methode");
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
};
|
|
||||||
}
|
|
||||||
|
|
||||||
public void testMethod() {
|
|
||||||
|
|
||||||
System.out.println("Das ist in der klasse");
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
int x = 2;
|
|
||||||
|
|
||||||
public static void main(String[] str) {
|
|
||||||
|
|
||||||
// Konstruktor wird aufgerufen und aussgegeben
|
|
||||||
Konstruktor test = new Konstruktor() {
|
|
||||||
|
|
||||||
public void print() {
|
|
||||||
System.out.println("extra methode");
|
|
||||||
//x = 3; Änderung ist verboten
|
|
||||||
}
|
|
||||||
|
|
||||||
int x = 5;
|
|
||||||
@Override
|
|
||||||
public void testMethod() {
|
|
||||||
|
|
||||||
System.out.println("Das ist in der main" + x);
|
|
||||||
print();// innere Methode
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
};
|
|
||||||
|
|
||||||
test.testMethod();
|
|
||||||
|
|
||||||
// Konstruktor wird aufgerufen und aussgegeben
|
|
||||||
var test2 = new Konstruktor() {
|
|
||||||
|
|
||||||
public static void print() {
|
|
||||||
System.out.println("extra methode");
|
|
||||||
}
|
|
||||||
|
|
||||||
int x = 5;
|
|
||||||
@Override
|
|
||||||
public void testMethod() {
|
|
||||||
|
|
||||||
System.out.println("Das ist in der main" + x);
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
};
|
|
||||||
// aufruf der innere methode
|
|
||||||
//test2.print();
|
|
||||||
test2.main();
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
@ -1,10 +0,0 @@
|
||||||
package oop.AnonymousInnerClass;
|
|
||||||
|
|
||||||
public class RewardClass {
|
|
||||||
public void rewardMethode() {
|
|
||||||
|
|
||||||
System.out.println("Deine Belohnung ist 10€.");
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
@ -1,35 +0,0 @@
|
||||||
package oop.AnonymousInnerClass;
|
|
||||||
|
|
||||||
public class Test {
|
|
||||||
|
|
||||||
public static void main(String[] args) {
|
|
||||||
|
|
||||||
RewardClass mietarebiter1 = new RewardClass();
|
|
||||||
RewardClass mietarebiter2 = new RewardClass();
|
|
||||||
RewardClass mietarebiter3 = new RewardClass()
|
|
||||||
// Anonymous Inner Class
|
|
||||||
{
|
|
||||||
|
|
||||||
@Override
|
|
||||||
public void rewardMethode() {
|
|
||||||
|
|
||||||
System.out.println("Deine Belohnung ist 20€.");
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
mietarebiter1.rewardMethode();//Belohnung ist 10€
|
|
||||||
mietarebiter2.rewardMethode();//Belohnung ist 10€
|
|
||||||
|
|
||||||
mietarebiter3.rewardMethode();//Belohnung ist 20€
|
|
||||||
|
|
||||||
/* wenn ich für den dritten mietarebiter3 20€ statt 10€ geben möchte!
|
|
||||||
* dann habe ich 2 möglichkeiten
|
|
||||||
*
|
|
||||||
* 1. erben: ich kann eine Klasse erstellen die meine (RewardClass) erbt
|
|
||||||
* und ihre Methode mit 20€ überschreibt!
|
|
||||||
*
|
|
||||||
* 2.Anonymous Inner Class
|
|
||||||
*/
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
@ -1,65 +0,0 @@
|
||||||
package oop.Aufgaben;
|
|
||||||
|
|
||||||
public class BankKonto {
|
|
||||||
|
|
||||||
private String name;
|
|
||||||
private double amount;
|
|
||||||
private int kontoNummer;
|
|
||||||
private static int counter = 1;
|
|
||||||
|
|
||||||
public BankKonto() {
|
|
||||||
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
public BankKonto( String name,double amount) {
|
|
||||||
this.kontoNummer = counter;
|
|
||||||
this.name = name;
|
|
||||||
this.amount = amount;
|
|
||||||
counter++;
|
|
||||||
bounus();
|
|
||||||
willkommen(this.name);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
public static void willkommen(String n) {
|
|
||||||
|
|
||||||
BankKonto b1 = new BankKonto();
|
|
||||||
b1.name = n;
|
|
||||||
System.out.println("Willkommen: " + b1.name);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
public double bounus() {
|
|
||||||
|
|
||||||
|
|
||||||
return this.amount += 5;
|
|
||||||
}
|
|
||||||
|
|
||||||
public void einzahlung(double wert) {
|
|
||||||
|
|
||||||
this.amount += wert;
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
public void auszahlung(double wert) {
|
|
||||||
|
|
||||||
if (wert <= this.amount)
|
|
||||||
this.amount -= wert;
|
|
||||||
else
|
|
||||||
System.out.println("Das Geld reicht nicht aus!");
|
|
||||||
}
|
|
||||||
|
|
||||||
public void checkKonto() {
|
|
||||||
|
|
||||||
System.out.println("Ihre Stand ist: " + this.amount);
|
|
||||||
}
|
|
||||||
|
|
||||||
public String toString() {
|
|
||||||
|
|
||||||
return "Kontoname = " + this.name + " nummer = " + kontoNummer + " Satand = " + this.amount;
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
@ -1,59 +0,0 @@
|
||||||
package oop.Aufgaben;
|
|
||||||
|
|
||||||
public class Kreis {
|
|
||||||
|
|
||||||
private double radius;
|
|
||||||
private String color;
|
|
||||||
|
|
||||||
|
|
||||||
// Konstruktor mit zwei Parametern
|
|
||||||
public Kreis(double radius, String color) {
|
|
||||||
this.radius = radius;
|
|
||||||
this.color = color;
|
|
||||||
}
|
|
||||||
|
|
||||||
// Konstruktor mit einem Parameter (radius), Standardfarbe wird zugewiesen
|
|
||||||
public Kreis(double radius) {
|
|
||||||
this.radius = radius; // Standardfarbe ist "weiß"
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
public void setRadius(double radius) {
|
|
||||||
|
|
||||||
this.radius =radius ;//this (unterscheidet zwishcne Parameter und Attribute)
|
|
||||||
}
|
|
||||||
|
|
||||||
public double getRadius() {
|
|
||||||
|
|
||||||
return radius;
|
|
||||||
}
|
|
||||||
|
|
||||||
public void setColor(String color) {
|
|
||||||
|
|
||||||
this.color = color; // this (unterscheidet zwishcne Parameter und Attribute)
|
|
||||||
}
|
|
||||||
|
|
||||||
public String getColor() {
|
|
||||||
|
|
||||||
return color;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
public double getFlaeche() {
|
|
||||||
|
|
||||||
return radius * radius * Math.PI;
|
|
||||||
}
|
|
||||||
|
|
||||||
public double getUmfang() {
|
|
||||||
|
|
||||||
return 2 * radius * Math.PI;
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
public String toString() {
|
|
||||||
|
|
||||||
return "Kreis:" + getFlaeche() + " " + getUmfang() ;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
@ -1,38 +0,0 @@
|
||||||
package oop.Aufgaben;
|
|
||||||
|
|
||||||
public class Mitarbeiter {
|
|
||||||
|
|
||||||
|
|
||||||
private static int id = 0;
|
|
||||||
protected int idMitarbeiter;
|
|
||||||
protected String name;
|
|
||||||
|
|
||||||
|
|
||||||
public Mitarbeiter() {
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
public Mitarbeiter(String name) {
|
|
||||||
this.idMitarbeiter = ++id;
|
|
||||||
this.name = name;
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
public void setName(String name) {
|
|
||||||
|
|
||||||
this.name = name;
|
|
||||||
}
|
|
||||||
|
|
||||||
public String getName() {
|
|
||||||
|
|
||||||
return this.name;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
public String toString() {
|
|
||||||
|
|
||||||
return "ID: " + id + " Name: " + this.name;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
@ -1,32 +0,0 @@
|
||||||
package oop.Aufgaben;
|
|
||||||
|
|
||||||
import java.util.ArrayList;
|
|
||||||
|
|
||||||
public class Personalverwaltung {
|
|
||||||
|
|
||||||
ArrayList<Mitarbeiter> mitarbeiterliste = new ArrayList<Mitarbeiter>();
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
public void add(Mitarbeiter mitarbeiter) {
|
|
||||||
|
|
||||||
mitarbeiterliste.add(mitarbeiter);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
public void remove(Mitarbeiter mitarbeiter) {
|
|
||||||
|
|
||||||
mitarbeiterliste.remove(mitarbeiter);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
public void listMitarbeiter(){
|
|
||||||
|
|
||||||
for (Mitarbeiter mitarbeiter : mitarbeiterliste) {
|
|
||||||
System.out.println(mitarbeiter);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
@ -1,31 +0,0 @@
|
||||||
package oop.Einführung;
|
|
||||||
|
|
||||||
public class Einführung {
|
|
||||||
|
|
||||||
String name;
|
|
||||||
int maxSpeed;
|
|
||||||
double price;
|
|
||||||
int model;
|
|
||||||
|
|
||||||
|
|
||||||
void setName(String n) {
|
|
||||||
name = n;
|
|
||||||
}
|
|
||||||
|
|
||||||
String getName() {
|
|
||||||
|
|
||||||
return name;
|
|
||||||
}
|
|
||||||
|
|
||||||
void setModel(int mod) {
|
|
||||||
if (mod >= 2016)
|
|
||||||
model = mod;
|
|
||||||
else
|
|
||||||
System.out.println("Nei geht nicht!");
|
|
||||||
}
|
|
||||||
|
|
||||||
int getModel() {
|
|
||||||
|
|
||||||
return model;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
@ -1,65 +0,0 @@
|
||||||
package oop.Enumeration;
|
|
||||||
import java.util.EnumSet;
|
|
||||||
|
|
||||||
public enum EnumMethods {
|
|
||||||
MONTAG, DIENSTAG, MITTWOCH, DONNERSTAG, FREITAG, SAMSTAG, SONNTAG;
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
public static void main(String[] args) {
|
|
||||||
// gibt mir die Index meiner Konstante zurück
|
|
||||||
System.out.println(EnumMethods.DIENSTAG.ordinal());
|
|
||||||
|
|
||||||
//vergleicht zwei enum-Konstanten basierend auf ihrer Reihenfolge
|
|
||||||
System.out.println(EnumMethods.DIENSTAG.compareTo(EnumMethods.DONNERSTAG));
|
|
||||||
|
|
||||||
// gibt true oder false zurück
|
|
||||||
System.out.println(EnumMethods.DIENSTAG.toString() == "DIENSTAG");
|
|
||||||
|
|
||||||
// gibt true oder false zurück
|
|
||||||
System.out.println(EnumMethods.DIENSTAG.name() == "DIENSTAG");
|
|
||||||
|
|
||||||
// gibt der Name der Kosntant zurück
|
|
||||||
System.out.println(EnumMethods.valueOf("DONNERSTAG"));
|
|
||||||
|
|
||||||
// gibt mir alle Konstante zurück
|
|
||||||
for (EnumMethods test: EnumMethods.values()) {
|
|
||||||
System.out.print(test + " ");
|
|
||||||
if (test == EnumMethods.DIENSTAG)
|
|
||||||
System.out.print(EnumMethods.values() + " ");
|
|
||||||
}
|
|
||||||
System.out.println(EnumMethods.values()[0] + "Einzelene Konstant");
|
|
||||||
|
|
||||||
System.out.println();
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Enumset::
|
|
||||||
*/
|
|
||||||
|
|
||||||
// gibt alle Werte die enums aus
|
|
||||||
EnumSet<EnumMethods> days = EnumSet.allOf(EnumMethods.class);
|
|
||||||
System.out.println(days);
|
|
||||||
|
|
||||||
// gibt nur Werte ,die ich eingebe
|
|
||||||
EnumSet<EnumMethods> day = EnumSet.of(EnumMethods.DIENSTAG, EnumMethods.FREITAG);
|
|
||||||
System.out.println(day);
|
|
||||||
|
|
||||||
// gibt nur einmal Diesntag aus!
|
|
||||||
EnumSet<EnumMethods> day1 = EnumSet.of(EnumMethods.DIENSTAG, EnumMethods.DIENSTAG);
|
|
||||||
System.out.println(day);
|
|
||||||
|
|
||||||
// gibt mir von Konstante to Kosntnate zurück!
|
|
||||||
EnumSet<EnumMethods> range = EnumSet.range(EnumMethods.DIENSTAG, EnumMethods.FREITAG);
|
|
||||||
System.out.println(range);
|
|
||||||
|
|
||||||
|
|
||||||
EnumSet<EnumMethods> noneOf = EnumSet.noneOf(EnumMethods.class);
|
|
||||||
noneOf.add(DIENSTAG);
|
|
||||||
noneOf.addAll(noneOf);
|
|
||||||
noneOf.remove(DIENSTAG);
|
|
||||||
noneOf.removeAll(noneOf);
|
|
||||||
System.out.println(noneOf);
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
@ -1,23 +0,0 @@
|
||||||
package oop.Enumeration;
|
|
||||||
|
|
||||||
public class Enumeration {
|
|
||||||
|
|
||||||
/*Enum was ist?
|
|
||||||
* - repräsentiert eine Gruppe von Konstanten
|
|
||||||
* ,die public, static und final sind und die immer großegeschrieben werden sollen
|
|
||||||
* - Deklariert mit dem Schlüsselwort enum z.b(public enum klassenname)
|
|
||||||
* - Jede Konstante wird durch Kommas getrennt und am Ende optional mit einem Semikolon abgeschlossen.
|
|
||||||
* - kann als Datentyp verwendet werden
|
|
||||||
* - Kann in switch-Anweisungen verwendet werden.
|
|
||||||
* - kann Felder, Konstruktoren (ohne public) und Methoden enthalten.
|
|
||||||
* - Konstruktoren sind immer privat oder paketprivat (d.h. sie können nicht public sein)
|
|
||||||
* ,die Dienen zur Initialisierung der Felder.
|
|
||||||
* - Enums können abstrakte Methoden enthalten, aber es sollen alle Kosntanten sie implementieren (siehe Wochentage class).
|
|
||||||
* - Enums können Interfaces implementieren.
|
|
||||||
* - Enums können eigene Methoden und Überschreibungen von toString(), equals(), hashCode(), etc. enthalten.
|
|
||||||
* - Enums können keine anderen Klassen erweitern und auch nicht von anderen Klassen erben
|
|
||||||
* - Enums können interface implementieren
|
|
||||||
*
|
|
||||||
*/
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
@ -1,28 +0,0 @@
|
||||||
package oop.Enumeration;
|
|
||||||
|
|
||||||
public enum Numbers{
|
|
||||||
|
|
||||||
ONE,TWO,THREE; // Semikolon ist optional
|
|
||||||
|
|
||||||
/*
|
|
||||||
* ONE TOW THREE sind Objekte in die unten stehenden Klassen
|
|
||||||
* Konstante ONE wir präsentiert durch:
|
|
||||||
* Class Numbers{
|
|
||||||
* public static final Numbers ONE = new Numbers();
|
|
||||||
* }
|
|
||||||
*
|
|
||||||
* und TWO auch so..
|
|
||||||
* Class Numbers{
|
|
||||||
* public static final Numbers TWO = new Numbers();
|
|
||||||
* }
|
|
||||||
* und THREE auch so..
|
|
||||||
*
|
|
||||||
*/
|
|
||||||
|
|
||||||
|
|
||||||
public void print() {
|
|
||||||
|
|
||||||
System.out.println("dasd");
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
@ -1,37 +0,0 @@
|
||||||
package oop.Enumeration;
|
|
||||||
|
|
||||||
public class Order {
|
|
||||||
|
|
||||||
public enum OrderStatus{
|
|
||||||
|
|
||||||
PENDING,
|
|
||||||
PREPARING,
|
|
||||||
COMPLETED,
|
|
||||||
DELIVERING,
|
|
||||||
CANCELED;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
// Attribute mit enum Objekt
|
|
||||||
private OrderStatus status;
|
|
||||||
|
|
||||||
public boolean check() {
|
|
||||||
|
|
||||||
if (getStatus() == status.COMPLETED)
|
|
||||||
return true;
|
|
||||||
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
|
|
||||||
public OrderStatus getStatus() {
|
|
||||||
return status;
|
|
||||||
}
|
|
||||||
|
|
||||||
public void setStatus(OrderStatus status) {
|
|
||||||
this.status = status;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
@ -1,17 +0,0 @@
|
||||||
package oop.Enumeration;
|
|
||||||
|
|
||||||
public class OrderTest {
|
|
||||||
|
|
||||||
public static void main(String[] args) {
|
|
||||||
//ordinal globale methode gibt mir die Index meiner enum Konstanten
|
|
||||||
System.out.println(Order.OrderStatus.CANCELED.ordinal());
|
|
||||||
|
|
||||||
Order order1 = new Order();
|
|
||||||
order1.setStatus(Order.OrderStatus.DELIVERING);
|
|
||||||
System.out.println(order1.check());
|
|
||||||
// z.b für Tracking der bestellung
|
|
||||||
System.out.print(order1.getStatus());
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
@ -1,35 +0,0 @@
|
||||||
package oop.Enumeration;
|
|
||||||
|
|
||||||
public class Test {
|
|
||||||
|
|
||||||
public static void main(String[] args) {
|
|
||||||
// Numbers val1 = new Numbers(); verboten da enum Konstruktoren private ist
|
|
||||||
// und ONE automatisch static ist
|
|
||||||
Numbers val1 = Numbers.ONE; // TWO ist ein Objekt
|
|
||||||
|
|
||||||
switch (val1) {
|
|
||||||
|
|
||||||
case ONE: System.out.println("1");
|
|
||||||
break;
|
|
||||||
|
|
||||||
case TWO: System.out.println("2");
|
|
||||||
break;
|
|
||||||
|
|
||||||
case THREE: System.out.println("3");
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
|
|
||||||
val1.print();
|
|
||||||
|
|
||||||
System.out.println(Wochentage.MONTAG.getStatus());
|
|
||||||
Wochentage.MONTAG.testmethode();
|
|
||||||
System.out.println(Wochentage.DIENSTAG.getStatus());
|
|
||||||
Wochentage.DIENSTAG.testmethode();
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
@ -1,41 +0,0 @@
|
||||||
package oop.Enumeration;
|
|
||||||
|
|
||||||
public enum Wochentage {// erbt von abstract class (enum)
|
|
||||||
// wenn eine Konstante einen Konstruktor hat, dann sollen Alle Konstaten sollen einen Konstruktor haben
|
|
||||||
/*
|
|
||||||
* MONTAG("Arbeitstag"),
|
|
||||||
* DIENSTAG("Arbeitstag");
|
|
||||||
*/
|
|
||||||
|
|
||||||
// Alle Konstanten sollen die abstrakte Methoden implementieren
|
|
||||||
MONTAG ("Konstruktor: Montag") {
|
|
||||||
@Override
|
|
||||||
public void testmethode() {
|
|
||||||
System.out.println("Montag");
|
|
||||||
}
|
|
||||||
|
|
||||||
},
|
|
||||||
DIENSTAG ("Konstruktor: Diesnstag"){
|
|
||||||
@Override
|
|
||||||
public void testmethode() {
|
|
||||||
System.out.println("Diesnstag");
|
|
||||||
}
|
|
||||||
};
|
|
||||||
String status;
|
|
||||||
|
|
||||||
Wochentage(String status){
|
|
||||||
this.status = status;
|
|
||||||
}
|
|
||||||
|
|
||||||
public String getStatus() {
|
|
||||||
return status;
|
|
||||||
}
|
|
||||||
|
|
||||||
public void setStatus(String status) {
|
|
||||||
this.status = status;
|
|
||||||
}
|
|
||||||
|
|
||||||
public abstract void testmethode();
|
|
||||||
|
|
||||||
|
|
||||||
}
|
|
||||||
Binary file not shown.
|
Before Width: | Height: | Size: 270 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 305 KiB |
|
|
@ -1,78 +0,0 @@
|
||||||
package oop.ExceptionHandling;
|
|
||||||
|
|
||||||
import java.io.FileNotFoundException;
|
|
||||||
import java.io.FileReader;
|
|
||||||
import java.io.IOException;
|
|
||||||
|
|
||||||
public class CheckedException {
|
|
||||||
|
|
||||||
public static void main(String[] args) {
|
|
||||||
readFile("D:\\Test.txt");
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
static void readFile(String filePath) {
|
|
||||||
FileReader reader = null;
|
|
||||||
// hier der Compiler zeigt mir eine Error und zwingt micht eine try-catch Block zu erstellen
|
|
||||||
try {
|
|
||||||
reader = new FileReader(filePath);// resource
|
|
||||||
System.out.println("File Inhalt: ");
|
|
||||||
|
|
||||||
int r = 0;
|
|
||||||
while((r = reader.read()) != -1) {
|
|
||||||
System.out.print((char) r);
|
|
||||||
}
|
|
||||||
}catch(FileNotFoundException e) {
|
|
||||||
|
|
||||||
System.out.println(e);
|
|
||||||
|
|
||||||
}catch(IOException e) {
|
|
||||||
System.out.println(e);
|
|
||||||
}finally {
|
|
||||||
try {
|
|
||||||
reader.close();
|
|
||||||
} catch (IOException e) {
|
|
||||||
e.printStackTrace();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// try() mit resources, hier benötigt man finally block nicht
|
|
||||||
static void readFile2(String filePath) {
|
|
||||||
try (FileReader reader = new FileReader(filePath);) {
|
|
||||||
System.out.println("File Inhalt: ");
|
|
||||||
|
|
||||||
int r = 0;
|
|
||||||
while((r = reader.read()) != -1) {
|
|
||||||
System.out.print((char) r);
|
|
||||||
}
|
|
||||||
}catch(FileNotFoundException e) {
|
|
||||||
|
|
||||||
System.out.println(e);
|
|
||||||
|
|
||||||
}catch(IOException e) {
|
|
||||||
System.out.println(e);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
// try() mit mehrere resources, hier benötigt man auch finally block nicht
|
|
||||||
static void readFile3(String filePath) {
|
|
||||||
try (FileReader reader = new FileReader(filePath); FileReader reader2 = new FileReader(filePath)) {
|
|
||||||
System.out.println("File Inhalt: ");
|
|
||||||
|
|
||||||
int r = 0;
|
|
||||||
while((r = reader.read()) != -1) {
|
|
||||||
System.out.print((char) r);
|
|
||||||
}
|
|
||||||
}catch(FileNotFoundException e) {
|
|
||||||
|
|
||||||
System.out.println(e);
|
|
||||||
|
|
||||||
}catch(IOException e) {
|
|
||||||
System.out.println(e);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
@ -1,102 +0,0 @@
|
||||||
package oop.ExceptionHandling;
|
|
||||||
|
|
||||||
public class ExceptionHandling {
|
|
||||||
|
|
||||||
/*Was ist das?
|
|
||||||
* - Hauptidee ist, dass falls der Programmer oder der User einen Fehler gemacht hat, läuft das Programm trotzdem weiter!
|
|
||||||
* - An exception ist ein unerwünschtes oder unerwartetes Ereignis
|
|
||||||
* ,das während der Ausführung eines Programms zur Laufzeit auftritt.
|
|
||||||
*
|
|
||||||
* - wenn man nicht weiß, was der Fehler ist, kann man dan die Basis Klasse aufrufen (Exception)
|
|
||||||
* aber das wird langsamer als wenn ich den Fehler direkt schreibe
|
|
||||||
*
|
|
||||||
* - unterstützt keine Methoden und Klasse
|
|
||||||
* - kann nicht als Parameter innerhalb einer Methode verwendet werden
|
|
||||||
* - kann aber innerhalb ale arten von Methoden geschrieben werden
|
|
||||||
*
|
|
||||||
* was sid die checked und unchecked Exceptions?
|
|
||||||
* - checked: Compiler zwingt mich ein try-catch Block zu erstellen und Sie erben von der Klasse Exception, aber nicht von RuntimeException.
|
|
||||||
* wie z.b(IOException, SQLException, FileNotFoundException)
|
|
||||||
* - unchecked: Compiler zwingt mich nicht try-catch Block zu erstllen und Sie erben nur von RuntimeException.
|
|
||||||
* wie z.b (ullPointerException, ArrayIndexOutOfBoundsException, ArithmeticException)
|
|
||||||
*
|
|
||||||
* welche Arten haben wir?
|
|
||||||
* 1. NullPointerException: Zugriff auf null-Referenz.
|
|
||||||
* 2. ArrayIndexOutOfBoundsException: Ungültiger Array-Indexzugriff.
|
|
||||||
* 3. ClassCastException: Ungültige Typumwandlung
|
|
||||||
* 4. ArithmeticException: Fehler in arithmetischer Operation (z.B. Division durch null).
|
|
||||||
* 5. NumberFormatException: Fehlerhafte Zahlumwandlung.
|
|
||||||
* 6. IOException: Eingabe-/Ausgabefehler.
|
|
||||||
* 7. FileNotFoundException: Datei nicht gefunden.
|
|
||||||
* 8. SQLException: Fehler in der Datenbankoperation.
|
|
||||||
* 9. IllegalArgumentException: Ungültiges Argument übergeben.
|
|
||||||
* etc...
|
|
||||||
*/
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Try-catch block:
|
|
||||||
*
|
|
||||||
* try{
|
|
||||||
* - m try-Block wird der Code geschrieben,
|
|
||||||
* der möglicherweise einen Fehler verursachen könnte.
|
|
||||||
*
|
|
||||||
* }catch(Exception e){
|
|
||||||
* - Was passieren soll, wenn ein Fehler auftritt?
|
|
||||||
* - Exception:ist die Basisklasse für alle Ausnahmen, die das Programm möglicherweise behandeln sollte.
|
|
||||||
* wie z.b(IOException),SQLException,NullPointerException sind unterklasse von Exception
|
|
||||||
* - e: ist ist ein belibeger Name eines Objektes
|
|
||||||
*
|
|
||||||
* - man kann try in ein try erzeugen
|
|
||||||
* }
|
|
||||||
*/
|
|
||||||
public static void main(String[] args) {
|
|
||||||
|
|
||||||
//Try-catch block beispiel
|
|
||||||
try {
|
|
||||||
int[] arr = new int[] {1,2,3};
|
|
||||||
System.out.println(arr[4]);
|
|
||||||
}catch(Exception e) {
|
|
||||||
//entweder
|
|
||||||
System.out.println("das ist ungültig");
|
|
||||||
//oder
|
|
||||||
System.out.println(e);
|
|
||||||
//oder
|
|
||||||
System.out.println(e + "das ist ungültig");
|
|
||||||
}
|
|
||||||
// trotz des Fehlers läuft das Programm weiter, da ich try catch habe
|
|
||||||
System.out.println("1");
|
|
||||||
|
|
||||||
|
|
||||||
//Try-catch block mit NullPointerException (ist eine klasse) beispiel
|
|
||||||
//also Objekt ist leer!
|
|
||||||
try {
|
|
||||||
int[] arr = null;
|
|
||||||
System.out.println(arr[4]);
|
|
||||||
}catch(Exception e) {
|
|
||||||
|
|
||||||
System.out.println(e.toString());
|
|
||||||
}
|
|
||||||
// trotz des Fehlers läuft das Programm weiter, da ich try catch habe
|
|
||||||
System.out.println("1");
|
|
||||||
|
|
||||||
|
|
||||||
//Try-catch block mit NumberForamtEception (ist eine klasse) beispiel
|
|
||||||
try {
|
|
||||||
System.out.println("haöö");// die wird ausgegeben
|
|
||||||
int val = Integer.parseInt("String23");
|
|
||||||
System.out.println(val);
|
|
||||||
System.out.println("haöö");// die wird nicht ausgegeben
|
|
||||||
}catch(Exception e) {
|
|
||||||
|
|
||||||
System.out.println(e.toString());
|
|
||||||
}
|
|
||||||
// trotz des Fehlers läuft das Programm weiter, da ich try catch habe
|
|
||||||
System.out.println("1");
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
@ -1,58 +0,0 @@
|
||||||
package oop.ExceptionHandling;
|
|
||||||
|
|
||||||
public class Finally {
|
|
||||||
|
|
||||||
public static void main(String[] args) {
|
|
||||||
/*
|
|
||||||
* Wenn ein Programmfehler auftaucht, springe in catch Block gib den Fehler aus und laufe nicht weiter
|
|
||||||
* und am Ende gib finally Block aus!
|
|
||||||
*/
|
|
||||||
try {
|
|
||||||
int arr[] = new int[5];
|
|
||||||
arr[7] = 5;
|
|
||||||
|
|
||||||
}catch(Exception e) {
|
|
||||||
|
|
||||||
System.out.println(e);
|
|
||||||
return;
|
|
||||||
|
|
||||||
}finally {
|
|
||||||
System.out.println("finally");
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
* wegen System.exit in catch wird finally Block nicht ausgegenen
|
|
||||||
*/
|
|
||||||
try {
|
|
||||||
int arr[] = new int[5];
|
|
||||||
arr[7] = 5;
|
|
||||||
|
|
||||||
}catch(Exception e) {
|
|
||||||
|
|
||||||
System.out.println(e);
|
|
||||||
System.exit(0);
|
|
||||||
|
|
||||||
}finally {
|
|
||||||
System.out.println("finally");
|
|
||||||
}
|
|
||||||
//System.out.println(getNumber(3));
|
|
||||||
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
// hier wir die 3 ausgegben, weil finally soll ausgegeben werden
|
|
||||||
public static int getNumber(int x) {
|
|
||||||
|
|
||||||
try {
|
|
||||||
if (x == 3)
|
|
||||||
return 1;
|
|
||||||
|
|
||||||
}catch (Exception e){
|
|
||||||
return 2;
|
|
||||||
|
|
||||||
}finally {
|
|
||||||
return 3;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
@ -1,16 +0,0 @@
|
||||||
package oop.ExceptionHandling;
|
|
||||||
|
|
||||||
public class MultiCatchBlocks {
|
|
||||||
|
|
||||||
public static void main(String[] args) {
|
|
||||||
try {
|
|
||||||
int arr[] = new int[5];
|
|
||||||
arr[10] = 7/0;
|
|
||||||
}
|
|
||||||
catch(ArrayIndexOutOfBoundsException|java.lang.ArithmeticException ex) {
|
|
||||||
System.out.println(ex);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
@ -1,44 +0,0 @@
|
||||||
package oop.ExceptionHandling;
|
|
||||||
|
|
||||||
public class Throwkeyword {
|
|
||||||
|
|
||||||
public static void main(String[] args) {
|
|
||||||
// hier try und catch sind optional
|
|
||||||
try {
|
|
||||||
number(-1);
|
|
||||||
}catch (Exception e){
|
|
||||||
System.out.println("die Zahl ist negativ");
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* in diesem try verfachen hier, wird das Block finally
|
|
||||||
* erst ausgeführt, before das Block catch mit throw
|
|
||||||
*/
|
|
||||||
try {
|
|
||||||
int x = 5/0;
|
|
||||||
|
|
||||||
}catch(Exception e) {
|
|
||||||
throw new ArithmeticException("neu throw");
|
|
||||||
|
|
||||||
}finally{
|
|
||||||
System.out.println("finally Block");
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
//throws Exception ist hier optional
|
|
||||||
static void number(int number) throws Exception {
|
|
||||||
|
|
||||||
if (number <= 0) {
|
|
||||||
//throw new ArithmeticException();Oder
|
|
||||||
//throw new ArithmeticException("das geht nicht");oder
|
|
||||||
ArithmeticException message = new ArithmeticException("die Zahl geht nicht");
|
|
||||||
throw message;
|
|
||||||
}
|
|
||||||
|
|
||||||
else
|
|
||||||
System.out.println("Die Zahl ist richtig");
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
@ -1,39 +0,0 @@
|
||||||
package oop.ExceptionHandling;
|
|
||||||
|
|
||||||
import java.io.FileNotFoundException;
|
|
||||||
import java.io.FileReader;
|
|
||||||
import java.io.IOException;
|
|
||||||
|
|
||||||
public class ThrowsKeyword {
|
|
||||||
/*
|
|
||||||
* - Wenn der Programmiere weiß, wie er mit den Fehlern umgehen kann.
|
|
||||||
* - zwingt jeder, der solche Methoden implementiert, throws zu behandeln
|
|
||||||
*/
|
|
||||||
public static void main(String[] args) {
|
|
||||||
/*
|
|
||||||
* da ich in readFile Methode throws verwendet habe
|
|
||||||
* ,soll ich hier z.b try catch erzeugen
|
|
||||||
*/
|
|
||||||
try {
|
|
||||||
readFile("D:\\Test.txt");
|
|
||||||
} catch (FileNotFoundException e) {
|
|
||||||
// TODO Auto-generated catch block
|
|
||||||
e.printStackTrace();
|
|
||||||
} catch (IOException e) {
|
|
||||||
// TODO Auto-generated catch block
|
|
||||||
e.printStackTrace();
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
public static void readFile(String File) throws FileNotFoundException, IOException{
|
|
||||||
FileReader reader = new FileReader(File);// resource
|
|
||||||
System.out.println("File Inhalt: ");
|
|
||||||
|
|
||||||
int r = 0;
|
|
||||||
while((r = reader.read()) != -1) {
|
|
||||||
System.out.print((char) r);
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
@ -1,23 +0,0 @@
|
||||||
package oop.ExceptionHandling;
|
|
||||||
|
|
||||||
public class UnCheckedException {
|
|
||||||
|
|
||||||
public static void main(String[] args) {
|
|
||||||
/*
|
|
||||||
* - Solche Errors kann man nicht mit try und Catch behandeln also sie sind keine gute Praxis
|
|
||||||
* - try und catch werden den Error nicht lösen
|
|
||||||
*/
|
|
||||||
try {
|
|
||||||
f();
|
|
||||||
}catch (Error e) {
|
|
||||||
System.out.println(e);//java.lang.StackOverflowError
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
// Die Methode ruft sich bis unendlich
|
|
||||||
static void f() {
|
|
||||||
System.out.println("f()");
|
|
||||||
f();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
Binary file not shown.
Binary file not shown.
|
Before Width: | Height: | Size: 299 KiB |
|
|
@ -1,57 +0,0 @@
|
||||||
package oop.FileHandling.ByteKlassen;
|
|
||||||
|
|
||||||
import java.io.File;
|
|
||||||
import java.io.FileInputStream;
|
|
||||||
import java.io.IOException;
|
|
||||||
//also ich habe daten auf meinm File und ich will diese Datein lesen oder importieren
|
|
||||||
// man kann heir mit Text bearbeiten aber es ist nicht dafür richtig alternative Möglichkeit (die abstrakte klasse reader und Writer)
|
|
||||||
public class Fileinputstream {
|
|
||||||
|
|
||||||
/*read() Methode:
|
|
||||||
* - fis.read liest aus dem File nur ein Byte aus und gibt ein Integer zurück
|
|
||||||
* - z.b a liest als (97) lösung als (char) casting
|
|
||||||
* - wenn die Methode keinen Byte lesen kann, gibt -1 zurück
|
|
||||||
*
|
|
||||||
*read(byte [] b) Method:
|
|
||||||
* - die übernimmt array vom type byte
|
|
||||||
*/
|
|
||||||
|
|
||||||
public static void main(String[] args) throws IOException {
|
|
||||||
FileInputStream fis = null;
|
|
||||||
fis = new FileInputStream("C:\\Users\\obaya\\eclipse-workspace\\OOP\\src\\oop\\FileHandling\\Test");
|
|
||||||
{
|
|
||||||
// das ist falsch, weil ich die Aufruf der Methode ist falsch
|
|
||||||
while (fis.read() != -1)
|
|
||||||
System.out.print((char)fis.read());
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
//richtig!!
|
|
||||||
int data;
|
|
||||||
while((data = fis.read()) != -1)// wenn kein mehr chars gibt, ist -1
|
|
||||||
System.out.print((char)data);
|
|
||||||
|
|
||||||
{
|
|
||||||
// read() übernimmt ein byte array
|
|
||||||
byte[] b = new byte[3]; // byte array
|
|
||||||
fis.read(b);// methode übernimmt byte array
|
|
||||||
String s = new String(b);//mit diesem Konstruktor gebe ich alle Inhalt aus ohne Loop
|
|
||||||
System.out.println(s);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
{
|
|
||||||
// read() übernimmt ein byte array mit dynamischen size für array
|
|
||||||
File f = new File("C:\\Users\\obaya\\eclipse-workspace\\OOP\\src\\oop\\FileHandling\\Test");
|
|
||||||
FileInputStream f2 = new FileInputStream(f);
|
|
||||||
byte[] b = new byte[(int) f.length()]; //Methode gibt long zurück size soll aber int sein
|
|
||||||
fis.read(b);// methode übernimmt byte array
|
|
||||||
String s = new String(b);//mit diesem Konstruktor gebe ich alle Inhalte aus (ohne Loop)
|
|
||||||
System.out.println(s);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
@ -1,33 +0,0 @@
|
||||||
package oop.FileHandling.ByteKlassen;
|
|
||||||
|
|
||||||
import java.io.FileInputStream;
|
|
||||||
import java.io.FileOutputStream;
|
|
||||||
import java.io.IOException;
|
|
||||||
|
|
||||||
//also ich habe datein in meine Programm und ich will diese Datein zu meinem File schicken also (schreiben)
|
|
||||||
//man kann heir mit Text bearbeiten aber es ist nicht dafür richtig alternative Möglichkeit (die abstrakte klasse reader und Writer)
|
|
||||||
|
|
||||||
public class Filoutputstream {
|
|
||||||
|
|
||||||
/*write() methode:
|
|
||||||
* - die übernimmt nur (integer) zahlen
|
|
||||||
* - kann Strings mit Hilfe von byte array aufnehmen
|
|
||||||
* z.b fSchreiben.write("ABF".getBytes());
|
|
||||||
* - fSchreiben.write("arabische sprache".getBytes()("UTF-8")); um andere Sprachen aufzunehmen
|
|
||||||
* - fSchreiben.flush(); stellt sicher, dass die Datein richtig geschrieben werden
|
|
||||||
*
|
|
||||||
*/
|
|
||||||
public static void main(String[] args) throws IOException {
|
|
||||||
// hier wenn er den File (Test2) nicht findet, erzeugt er File mit dem Name Test2 automatisch
|
|
||||||
FileOutputStream fSchreiben = new FileOutputStream("C:\\Users\\obaya\\eclipse-workspace\\OOP\\src\\oop\\FileHandling\\Test2");
|
|
||||||
//fSchreiben.write(10);
|
|
||||||
fSchreiben.write("ä".getBytes());
|
|
||||||
fSchreiben.flush();
|
|
||||||
|
|
||||||
//lesen der Datei
|
|
||||||
FileInputStream fLesen = new FileInputStream("C:\\Users\\obaya\\eclipse-workspace\\OOP\\src\\oop\\FileHandling\\Test2");
|
|
||||||
System.out.println((char)fLesen.read());
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
@ -1,33 +0,0 @@
|
||||||
package oop.FileHandling.ByteKlassen;
|
|
||||||
import java.io.File;
|
|
||||||
import java.io.FileInputStream;
|
|
||||||
import java.io.FileOutputStream;
|
|
||||||
import java.io.IOException;
|
|
||||||
public class LeseEinBild {
|
|
||||||
|
|
||||||
public static void main(String[] args) throws IOException {
|
|
||||||
//gibt mit die gesamte size vom byte meine Bildes
|
|
||||||
File file = new File("C:\\Users\\obaya\\eclipse-workspace\\OOP\\src\\oop\\FileHandling");
|
|
||||||
|
|
||||||
FileInputStream fin = new FileInputStream(file);
|
|
||||||
byte b[] = new byte[(int) file.length()];
|
|
||||||
fin.read(b);
|
|
||||||
|
|
||||||
//Optional loop
|
|
||||||
for (int i = 0; i < b.length; i++)
|
|
||||||
System.out.print(b[i]);
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
* - erstellt mir eine neues Bild mit dem Name (neues Bild)
|
|
||||||
* - dieses Verfahren kann mit allen Arten von Byts verwendet werden
|
|
||||||
*/
|
|
||||||
FileOutputStream fos = new FileOutputStream("C:\\Users\\obaya\\eclipse-workspace\\OOP\\src\\oop\\neues Bild.png");
|
|
||||||
fos.write(b);
|
|
||||||
fos.flush();
|
|
||||||
fos.close();
|
|
||||||
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
@ -1 +0,0 @@
|
||||||
abc
|
|
||||||
|
|
@ -1 +0,0 @@
|
||||||
ä
|
|
||||||
Binary file not shown.
|
Before Width: | Height: | Size: 299 KiB |
|
|
@ -1,39 +0,0 @@
|
||||||
package oop.FileHandling;
|
|
||||||
|
|
||||||
public class FileHandling {
|
|
||||||
/*
|
|
||||||
* - bezieht sich auf das Arbeiten mit Dateien und Verzeichnissen, einschließlich Erstellen, Lesen,
|
|
||||||
* Schreiben, Bearbeiten und Löschen.
|
|
||||||
* - die Kommunikation zwischen File und Programm heißt (stream)
|
|
||||||
* - Programm liest (Read) aus dem File (Input stream)
|
|
||||||
* - Programm schreibt (Write) oder (speichert) auf dem File (output Stream)
|
|
||||||
* - Es gibt ein eingine Stream für Lesen
|
|
||||||
* - Es gibt ein eingine Stream für schreiben
|
|
||||||
* - man kann das easy in Konstruktor als parameter und methode als parameter machen oder drin
|
|
||||||
*
|
|
||||||
* - FileInputStream und FileOutPutStream sind für File Texte nicht geeignet,
|
|
||||||
* alternativ möglichkeit die abstrakte Klassen Reader und Writer
|
|
||||||
* - Hinweis: Die abstrakte Klasse Reader liest Zeichen für Zeichen und ruft die Methode read() jedes Mal auf, wenn ein neues Zeichen gelesen wird.
|
|
||||||
* Wenn wir z.B. 10 Zeichen lesen möchten, wird die Methode read() 10 Mal aufgerufen.
|
|
||||||
*
|
|
||||||
* Alternative Möglichkeit: Die Klasse BufferedReader kann verwendet werden, um ganze Zeilen oder größere Blöcke von Zeichen auf einmal zu lesen,
|
|
||||||
* was effizienter sein kann, da sie den Lesevorgang puffert und somit weniger oft auf die zugrunde liegende Datenquelle zugreift.
|
|
||||||
* - printWriter ist für alle Datentyps gut geeinigt (kann nur schreiben auf dem File)
|
|
||||||
* - Scanner ist für alle Datentyps gut geeinigt (kann nur lesen auf dem File)
|
|
||||||
* - flush() soll aufgerufen werden
|
|
||||||
* - BufferReader ist besser als Scanner
|
|
||||||
*
|
|
||||||
* Objekte einer Klasse können auch auf dem File gelesen und geschriben werden:
|
|
||||||
*
|
|
||||||
* - Serialization: ist eine (marker) lerre interface Klasse, die implemntiert werden soll
|
|
||||||
* , wenn wir das Objekt auf einem File schreiben möchten
|
|
||||||
*
|
|
||||||
* 1. Serialization (Objekt schreiben): Ist ein Mechanismus zur Umwandlung eines Objekts in einen Byte-Stream,
|
|
||||||
* der dann in einer Datei gespeichert werden kann. Dies wird durch die Klasse ObjectOutputStream ermöglicht.
|
|
||||||
*
|
|
||||||
* 2. Deserialization (Objekt lesen): Ist ein Mechanismus zur Umwandlung eines Byte-Streams zurück in ein Objekt.
|
|
||||||
* Dies wird durch die Klasse ObjectInputStream ermöglicht.
|
|
||||||
*/
|
|
||||||
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
@ -1,64 +0,0 @@
|
||||||
package oop.FileHandling;
|
|
||||||
import java.io.File;
|
|
||||||
import java.io.IOException;
|
|
||||||
// Hauptfunktion verwaltet Files
|
|
||||||
public class FileKlasse {
|
|
||||||
|
|
||||||
/*Was macht diese Kalsse?
|
|
||||||
* - abstrakte Darstellungen von Dateipfaden und Verzeichnissen zu bieten und verschiedene Operationen darauf zu ermöglichen
|
|
||||||
* - sie befindet sich im Paket java.io
|
|
||||||
* - stellt keine Methode zum direkten Lesen oder Schreiben von Daten bereit.
|
|
||||||
* - Stattdessen bietet sie Funktionen zur Dateiverwaltung.
|
|
||||||
*/
|
|
||||||
public static void main(String[] args) {
|
|
||||||
File file = new File("C:\\Users\\obaya\\eclipse-workspace\\OOP\\src\\oop\\FileHandling\\Test");
|
|
||||||
|
|
||||||
if (file.exists()) {
|
|
||||||
System.out.println("Datei existiert: " + file.getName());
|
|
||||||
System.out.println("Pfad: " + file.getPath());
|
|
||||||
System.out.println("Absoluter Pfad: " + file.getAbsolutePath());
|
|
||||||
System.out.println("Schreibbar: " + file.canWrite());//ob der ich in der File schreiben kann
|
|
||||||
System.out.println("Lesbar: " + file.canRead()); //ob der ich in File lesen kann
|
|
||||||
System.out.println("Größe: " + file.length() + " Bytes");
|
|
||||||
System.out.println("kann ausführen = " + file.canExecute()); //kann ich diesen Fiel bearbeiten (ja/nein)
|
|
||||||
|
|
||||||
}
|
|
||||||
// test3 File existiert nicht im Pfad also wird einen neuen Pfeil erstellt
|
|
||||||
File file2 = new File("C:\\Users\\obaya\\eclipse-workspace\\OOP\\src\\oop\\FileHandling\\Test3");
|
|
||||||
// try catch sollen erzuegt werden
|
|
||||||
try {
|
|
||||||
if (file.createNewFile()) // createNewFile() gibt boolean zurück,ob der File ergolgreich erstellt wurde oder nicht
|
|
||||||
System.out.println("Datei erstellt: " + file.getName()); // der File muss im Pfad nicht existieren, damit es erstellt wurde
|
|
||||||
else
|
|
||||||
System.out.println("Fehler beim Erstellen der Datei.");
|
|
||||||
|
|
||||||
} catch (IOException e) {
|
|
||||||
e.printStackTrace();
|
|
||||||
}
|
|
||||||
|
|
||||||
// erstelle ein Verzeichnes
|
|
||||||
File folder = new File("C:\\Users\\obaya\\eclipse-workspace\\OOP\\src\\oop\\FileHandling\\TestFolder");
|
|
||||||
if (!folder.exists()) {
|
|
||||||
if (folder.mkdir())
|
|
||||||
System.out.println("Verzeichnis erstellt: " + folder.getName());
|
|
||||||
else
|
|
||||||
System.out.println("Fehler beim Erstellen des Verzeichnisses.");
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
// gibt die Inhalt eines Folders zurück
|
|
||||||
File dir2 = new File("C:\\Users\\obaya\\eclipse-workspace\\OOP\\src\\oop\\FileHandling\\TestFolder");
|
|
||||||
|
|
||||||
// Auflisten der Inhalte des Verzeichnisses mit Hilfe eines String arrays
|
|
||||||
String[] fileList = dir2.list();
|
|
||||||
if (fileList != null) {
|
|
||||||
System.out.println("Inhalte des Verzeichnisses:");
|
|
||||||
for (String fileName : fileList)
|
|
||||||
System.out.println(fileName);
|
|
||||||
|
|
||||||
} else
|
|
||||||
System.out.println("Das Verzeichnis ist leer oder konnte nicht aufgelistet werden.");
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
Binary file not shown.
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue