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