Build tools
* gradle
* maven
* ant
[[http://javaeditor.org]]
manifest.mf
Main-Class: Main
Class-Path: MyProg.jar
javac *.java // create class files
jar -cmvf manifest.mf MyProg.jar *.class // create .jar, add all class files and the manifest
java -jar MyProg.jar
java -cp .;MyProg.jar Prog // use .jar Library in combination with another jar file
[[https://blog.idrsolutions.com/2015/07/an-introduction-to-javafx-panes-with-code-examples/|JavaFX Panes]]
=====Klassen=====
public class Main {
public static void main(String[] args) {
System.out.println("Hello world");
}
}
=====JFrame=====
import javax.swing.*;
import java.awt.event.*;
public class Main extends JFrame {
public Main() {
initComponents();
}
private void initComponents() {
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
JPanel panel = new JPanel();
JButton button = new JButton("Button");
button.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
System.out.println("Button clicked");
}
});
panel.add(button);
add(panel);
pack();
setVisible(true);
}
public static void main(String args[]) {
java.awt.EventQueue.invokeLater(new Runnable() {
public void run() {
new Main().setVisible(true);
}
});
}
}
=====Layouts=====
In Java wird das Erstellen von Layouts üblicherweise mit Hilfe von sogenannten Layout-Managern (Layout Managers) erreicht. Layout-Manager sind Klassen, die dabei helfen, die Positionierung und Größenanpassung von Komponenten in einem Container zu verwalten. Sie ermöglichen es, dass die Benutzeroberfläche flexibel und automatisch angepasst wird, wenn sich die Größe des Fensters ändert oder Komponenten hinzugefügt oder entfernt werden. Es gibt verschiedene Layout-Manager, die in Java verwendet werden können, wie zum Beispiel:
* BorderLayout: Dieser Layout-Manager teilt den Container in fünf Bereiche (Norden, Süden, Osten, Westen, Zentrum) auf und platziert die Komponenten entsprechend in diesen Bereichen.
* FlowLayout: Dieser Layout-Manager platziert die Komponenten in der Reihenfolge, in der sie hinzugefügt werden, von links nach rechts. Wenn der verfügbare Platz nicht ausreicht, werden die Komponenten automatisch in die nächste Zeile umgebrochen.
* GridLayout: Dieser Layout-Manager platziert die Komponenten in einem gleichmäßigen Raster mit einer festen Anzahl von Zeilen und Spalten.
* GridBagLayout: Dieser Layout-Manager bietet eine flexible und leistungsfähige Möglichkeit, Komponenten zu positionieren. Es ermöglicht die Platzierung von Komponenten in Zellen eines Gitters und erlaubt die Kontrolle über die Positionierung, Größe und Ausrichtung der Komponenten.
====BorderLayout====
import javax.swing.*;
import java.awt.*;
public class Main {
public static void main(String[] args) {
// Erstellen des Hauptfensters (JFrame)
JFrame frame = new JFrame("Layout Example");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
// Erstellen der Komponenten
JButton button1 = new JButton("Button 1");
JButton button2 = new JButton("Button 2");
JLabel label = new JLabel("Label");
// BorderLayout verwenden
frame.setLayout(new BorderLayout());
// Komponenten dem BorderLayout hinzufügen
frame.add(button1, BorderLayout.NORTH);
frame.add(button2, BorderLayout.SOUTH);
frame.add(label, BorderLayout.CENTER);
// FlowLayout für einen JPanel verwenden
JPanel panel = new JPanel(new FlowLayout());
panel.add(new JButton("Button 3"));
panel.add(new JButton("Button 4"));
// JPanel dem BorderLayout hinzufügen
frame.add(panel, BorderLayout.WEST);
// Größe des Fensters anpassen und sichtbar machen
frame.pack();
frame.setVisible(true);
}
}
====FlowLayout====
import javax.swing.*;
import java.awt.*;
public class Main {
public static void main(String[] args) {
// Erstellen des Hauptfensters (JFrame)
JFrame frame = new JFrame("FlowLayout Example");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
// Erstellen des Panels mit FlowLayout
JPanel panel = new JPanel(new FlowLayout());
// Hinzufügen von Komponenten zum Panel
panel.add(new JButton("Button 1"));
panel.add(new JButton("Button 2"));
panel.add(new JButton("Button 3"));
// JPanel dem JFrame hinzufügen
frame.add(panel);
// Größe des Fensters anpassen und sichtbar machen
frame.pack();
frame.setVisible(true);
}
}
====GridLayout====
import javax.swing.*;
import java.awt.*;
public class Main {
public static void main(String[] args) {
// Erstellen des Hauptfensters (JFrame)
JFrame frame = new JFrame("GridLayout Example");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
// Erstellen des Panels mit GridLayout
JPanel panel = new JPanel(new GridLayout(3, 3)); // 3 Zeilen, 3 Spalten
// Hinzufügen von Komponenten zum Panel
panel.add(new JButton("Button 1"));
panel.add(new JButton("Button 2"));
panel.add(new JButton("Button 3"));
panel.add(new JButton("Button 4"));
panel.add(new JButton("Button 5"));
panel.add(new JButton("Button 6"));
panel.add(new JButton("Button 7"));
panel.add(new JButton("Button 8"));
panel.add(new JButton("Button 9"));
// JPanel dem JFrame hinzufügen
frame.add(panel);
// Größe des Fensters anpassen und sichtbar machen
frame.pack();
frame.setVisible(true);
}
}
====GridBagLayout====
import javax.swing.*;
import java.awt.*;
public class Main {
public static void main(String[] args) {
// Erstellen des Hauptfensters (JFrame)
JFrame frame = new JFrame("GridBagLayout Example");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
// Erstellen des Panels mit GridBagLayout
JPanel panel = new JPanel(new GridBagLayout());
GridBagConstraints gbc = new GridBagConstraints();
// Hinzufügen von Komponenten zum Panel
gbc.gridx = 0;
gbc.gridy = 0;
gbc.insets = new Insets(5, 5, 5, 5); // Abstand um die Komponenten
panel.add(new JButton("Button 1"), gbc);
gbc.gridx = 1;
gbc.gridy = 0;
panel.add(new JButton("Button 2"), gbc);
gbc.gridx = 0;
gbc.gridy = 1;
gbc.gridwidth = 2; // Komponente erstreckt sich über zwei Spalten
panel.add(new JButton("Button 3"), gbc);
gbc.gridx = 0;
gbc.gridy = 2;
gbc.gridwidth = 1; // Zurücksetzen auf Standard
panel.add(new JButton("Button 4"), gbc);
gbc.gridx = 1;
gbc.gridy = 2;
panel.add(new JButton("Button 5"), gbc);
// JPanel dem JFrame hinzufügen
frame.add(panel);
// Größe des Fensters anpassen und sichtbar machen
frame.pack();
frame.setVisible(true);
}
}
=====Threads=====
Threads ermöglichen die gleichzeitige oder nebenläufige Ausführung von Aufgaben und verbessern so die Leistung und Reaktionsfähigkeit von Programmen. Sie können verwendet werden, um mehrere Operationen gleichzeitig auszuführen, um langwierige Aufgaben im Hintergrund zu erledigen oder um auf Ereignisse zu reagieren, während die Hauptausführung fortgesetzt wird.
In Java können Threads auf zwei Arten erstellt werden:
* Durch Vererbung der Klasse Thread: Man erstellt eine eigene Klasse, die von der Klasse Thread erbt und die run()-Methode überschreibt. Die run()-Methode enthält den Code, der im Thread ausgeführt werden soll. Anschließend kann man eine Instanz dieser Klasse erstellen und den Thread mit der Methode start() starten.
* Durch Implementierung des Runnable-Interfaces: Man erstellt eine Klasse, die das Runnable-Interface implementiert und die run()-Methode implementiert. Diese Klasse wird dann in einen Thread eingekapselt, indem man sie als Parameter an den Konstruktor der Klasse Thread übergibt. Der Thread wird dann mit der Methode start() gestartet.
Threads in Java bieten verschiedene Funktionen zur Synchronisation und Koordination, wie beispielsweise das Warten auf bestimmte Bedingungen mit der Methode wait(), das Benachrichtigen anderer Threads mit der Methode notify() oder notifyAll(), und das Synchronisieren des Zugriffs auf gemeinsam genutzte Ressourcen mit dem synchronized-Schlüsselwort.
public class MyThread extends Thread {
@Override
public void run() {
// Code, der im Thread ausgeführt werden soll
for (int i = 1; i <= 10; i++) {
System.out.println("Thread: " + i);
try {
Thread.sleep(1000); // Pause für 1 Sekunde
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) {
MyThread myThread = new MyThread();
myThread.start();
// Code, der parallel zum Thread ausgeführt wird
for (int i = 1; i <= 5; i++) {
System.out.println("Main: " + i);
try {
Thread.sleep(1000); // Pause für 1 Sekunde
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
=====Runnable=====
Ein Runnable ist eine abstrakte Darstellung einer ausführbaren Aufgabe, die in einem Thread ausgeführt werden kann. Es definiert die Methode run(), die den Code enthält, der im Thread ausgeführt werden soll.
class MyRunnable implements Runnable {
public void run() {
while(true) {
int i = 1;
}
}
}
public class Main {
public static void main(String[] args) {
// Erstelle ein Runnable-Objekt
Runnable myRunnable = new MyRunnable();
// Erstelle einen neuen Thread mit dem Runnable-Objekt
Thread thread = new Thread(myRunnable);
// Starte den Thread
thread.start();
}
}
=====Code=====
Server
import java.io.*;
import java.net.*;
import java.*;
import javax.swing.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Iterator;
public class Server extends Thread implements Runnable {
public ClientThread clients[];
public ServerSocket server = null;
public Thread thread = null;
public int clientCount = 0;
public int port;
public Server(int port) {
this.port = port;
int maxclients = 100;
clients = new ClientThread[maxclients];
try{
server = new ServerSocket(port);
start();
} catch(IOException ioe) { }
}
public void run() {
while (thread != null){
try {
addThread(server.accept());
} catch(Exception ioe){ }
}
if (thread == null){
thread = new Thread(this);
thread.start();
}
}
public void stopen() {
for(int i = 0; i < clientCount; i++) try { clients[i].close(); } catch(IOException ioe) {}
try { server.close(); } catch(IOException ioe) { ioe.printStackTrace(); }
}
private void addThread(Socket socket) {
if (clientCount < clients.length) {
clients[clientCount] = new ClientThread(this, socket);
try{
clients[clientCount].open();
clients[clientCount].start();
clientCount++;
} catch(IOException ioe) { }
} else { }
}
public synchronized void handle(int ID, String msg) {
System.out.println(msg);
}
public void Announce(int ID, String content) {
for(int i = 0; i < clientCount; i++){
if (clients[i].ID != ID){
clients[i].send(content);
}
}
}
private int findClient(int ID) {
for (int i = 0; i < clientCount; i++){
if (clients[i].ID == ID) return i;
}
return -1;
}
public ClientThread findUserThread(String usr) {
for(int i = 0; i < clientCount; i++) {
//if(clients[i].username.equals(usr)) { return clients[i]; }
}
return null;
}
@SuppressWarnings("deprecation")
public synchronized void remove(int ID) {
int pos = findClient(ID);
if (pos >= 0){
ClientThread toTerminate = clients[pos];
if (pos < clientCount-1) {
for (int i = pos+1; i < clientCount; i++) {
clients[i-1] = clients[i];
}
}
clientCount--;
try {
toTerminate.close();
} catch(IOException ioe) {
}
toTerminate.stop();
}
}
}
class ClientThread extends Thread {
public Server server = null;
public Socket socket = null;
public int ID = -1;
public BufferedReader r = null;
public PrintWriter w = null;
public ClientThread(Server _server, Socket _socket) {
super();
server = _server;
socket = _socket;
ID = socket.getPort();
}
@SuppressWarnings("deprecation")
public void run() {
while (true){
try {
server.handle(ID, r.readLine());
} catch(Exception ioe) {
server.remove(ID);
stop();
}
}
}
public void open() throws IOException {
r = new BufferedReader(new InputStreamReader(socket.getInputStream()));
w = new PrintWriter(socket.getOutputStream());
w.flush();
}
public void close() throws IOException {
if (socket != null) socket.close();
if (r != null) r.close();
if (w != null) w.close();
}
public void send(String msg) {
w.write(msg);
w.flush();
}
}