Java Grundinfos – Programmieren lernen

Zusammenfassung der wichtigsten Daten und Befehle
Hier gibt es Grundinfos zur Installation und Programmierung.

Um mit Java zu arbeiten muss JDK installiert werden.

Eine Java Datei endet auf .jar

Ein in Java geschriebenes Programm ist in seinem fertigen Zustand auf dutzenden Plattformen lauffähig,
das heißt ein Java Programm kann unverändert auf verschiedenen Betriebssystemen und
Prozessorarchitekturen ausgeführt werden

Dateiendung .java
Die Einrückung dient ausschließlich der Lesbarkeit und ist für den Java Compiler irrelevant
Java ist case-sensitive.
Wichtig ist, dass wenn die im Quelltext beschriebene öffentliche Klasse Zeiterfassung heißt, auch die Datei die diesen Quelltext enthält Zeiterfassung.java heißen muss (unter Linux sogar unter Beachtung der Groß- und Kleinschreibung) , ansonsten meldet der Compiler einen Fehler.

Ein Minimalprogramm ohne weitere Variablen / Befehle

Jeder Befehl wird mit einem Semikolon abgeschlossen
Kommentare werden durch /* mehrere Zeilen */ oder // gekennzeichnet

Der Compiler in Java erzeugt keinen Maschinencode aus dem Quelltext (Da-
teiendung .java), sondern erzeugt sogenannten Bytecode (Dateiendung .class). Byteco-
de kann man sich als eine Art Maschinencode vorstellen, der einem konkreten Prozessor
unabhängig ist.

Woher bekommt man nun aber den Java Compiler und die Runtime Environment? Für
Windowsbenutzer gilt folgendes: Beides ist unter http://java.sun.com erhältlich. Im Down-
loadbereich muss man hierzu „Java SE“ auswählen. SE steht für Standard Edition. Der
Compiler ist enthalten im Java SE Development Kit, kurz JDK. Hierin ist auch schon die
passende Runtime Environment, kurz JRE, enthalten. Unter Linux hängt es von der Distribution ab. Über den Paketmanager muss es evtl. nach installiert werden. Um die Datei zu kompilieren gibt man in der Konsole javac Dateiname.java ein. Wenn kein Fehler auftritt wird Nichts angezeigt. Sonst kommt eine Fehlermeldung.

Diese vom Compiler erzeugten .class-Dateien enthalten nun das Programm im Bytecode.

Nachdem die Datei kompiliert wurde, kann sie über java Dateiname.java ausgeführt werden.

GUI

Java bietet zwei Bibliotheken für die GUI-Programmierung: AWT und Swing. Die Swing-Bibliotheken sind die bevorzugte Option, da das AWT veraltet ist. Mit den Swing-Bibliotheken können Sie verschiedene GUI-Komponenten erstellen und das GUI-Design anpassen.

Dateiendung ist .java für eine erstellte Datei

Java ist case-sensitive. Das bedeutet, dass in Java die Groß- und Kleinschreibung bei Bezeichnern wie Variablen, Methoden und Klassennamen unterschieden wird. Zum Beispiel:

int myVariable = 5;
int MyVariable = 10;

Einfache bzw. kurze Befehle können in der JavaShell getestet werden

Java Dateien müssen kompiliert werden

Ja, um eine Java-Datei auszuführen, muss sie zuerst kompiliert werden. Der Kompilierungsprozess wandelt den Java-Quellcode (.java-Datei) in Bytecode um, der in einer .class-Datei gespeichert wird. Dieser Bytecode kann dann von der Java Virtual Machine (JVM) ausgeführt werden.

Hier ist ein Beispiel, wie man eine Java-Datei kompiliert und ausführt:

Schreiben Sie den Java-Code in einer Datei:
Erstellen Sie eine Datei mit dem Namen ausgabe.java und schreiben Sie den folgenden Code hinein:

   public class ausgabe {
       public static void main(String[] args) {
           System.out.println("Hello, World!");
       }
   }

Kompilieren Sie die Java-Datei:
Öffnen Sie ein Terminal oder eine Eingabeaufforderung und navigieren Sie zu dem Verzeichnis, in dem sich die HelloWorld.java-Datei befindet. Geben Sie den folgenden Befehl ein:

   javac ausgabe.java

Wenn der Quellcode korrekt ist, wird dieser Befehl eine HelloWorld.class-Datei erstellen.

Führen Sie die kompillierte Datei aus:
Geben Sie den folgenden Befehl ein, um das Programm auszuführen:

   java ausgabe

Sie sollten die Ausgabe Hello, World! sehen.

Der javac-Befehl ist der Java-Compiler, der den Quellcode in Bytecode übersetzt, und der java-Befehl startet die JVM und führt den Bytecode aus.

should be declared in a file named

Kommentare werden mit // und mehrzeilig mit /*kommentar*/ erstellt

Variablen

werden durch den Datentyp und Namen definiert

Klassen in Java

Klassen bilden in der objektorientierten Programmierung die Vorlage, aus der zur Laufzeit des Programms Objekte erzeugt werden. Klassen besitzen Klassen-Variablen, Klassen-Methoden, sowie einen oder mehrere Konstruktor(en).
Definition einer Klasse:

public class Name_der_Klasse { 

                               Objekte der Klasse

}

Klassen Attribute sind Variablen. Über diese werden die Eigenschaften der Klasse fest gelegt. Ein Beispiel:

Infos zu public

public class auto {
    public String farbe;
    public int baujahr;
    public String marke;

    public auto(String farbe, int baujahr, String marke) {
        this.farbe = farbe;
        this.baujahr = baujahr;
        this.marke = marke;
    }

    public static void main(String[] args) {
        auto auto2024 = new auto("blau", 1989, "Ford");
        System.out.println("Marke: " + auto2024.marke + ", Farbe: " + auto2024.farbe + ", Baujahr: " + auto2024.baujahr);
    }
}

Eingaben verarbeiten:

Um in Java Eingaben zu verarbeiten, kannst du die Klasse Scanner aus dem Paket java.util verwenden. Hier sind die wichtigsten Schritte:

Importiere die Scanner-Klasse:

import java.util.Scanner;

Erstelle ein Scanner-Objekt und übergib System.in als Eingabestrom:

Scanner scanner = new Scanner(System.in);

Beispiele für das Auslesen von Werten:

import java.util.Scanner;
  
public class EingabeAusgabe {
    public static void main(String[] args) {
          
        Scanner eingabewert = new Scanner(System.in);
 
        String stringValue = eingabewert.nextLine();
        int intValue = eingabewert.nextInt(); 
        long longValue = eingabewert.nextLong(); 
        double doubleValue = eingabewert.nextDouble();
        char charValue = eingabewert.next().charAt(0);
 
        System.out.println("Long-Wert: " + longValue);
    }
}

Beispiel für eine Zeichenketteneingabe:

System.out.print("Geben Sie Ihren Namen ein: ");
String name = scanner.nextLine(); // Liest die Eingabe als String
System.out.println("Hallo " + name + "!");

Beispiel für eine Zahleneingabe:

System.out.print("Geben Sie zwei Zahlen ein: ");
int zahl1 = scanner.nextInt();
int zahl2 = scanner.nextInt();
int summe = zahl1 + zahl2;
System.out.println("Die Summe ist: " + summe);

import java.util.Scanner;

public class alter1 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("Gib dein Alter ein: ");
        int alter = scanner.nextInt();
        System.out.println("Ok, du bist " + alter + " Jahre alt.");
    }
}

Es ist ratsam, die Eingaben auf Gültigkeit zu überprüfen, z.B. mit hasNextInt() vor nextInt(), um Fehler zu vermeiden.

Die Scanner-Klasse bietet auch Methoden wie hasNext() und hasNextLine(), um zu überprüfen, ob weitere Eingaben vorhanden sind.

If- Schleife

import java.util.Scanner;
public class alter2 {
        public static void main(String[] args){
        Scanner scanner=new Scanner(System.in);
        System.out.print("Wie alt bist du?");
        int alter2 = scanner.nextInt();
if (alter2 >= 18) {
        System.out.print("ok, du bist volljährig");
        }
else
    	{
	System.out.print("Nein, du kannst noch nicht bestellen");
        }
}
}

Um ein Java-Programm einem Benutzer zur Verfügung zu stellen, können Sie eine JAR-Datei (Java Archive) erstellen. Dies ist eine effiziente und plattformunabhängige Methode zur Distribution Ihres Programms. Hier sind die Schritte:

Kompilieren Sie Ihr Java-Programm, um .class-Dateien zu erzeugen.
Erstellen Sie eine JAR-Datei mit dem „jar“ Tool:

jar cvfe programm.jar package.MainClass -C bin .

Hierbei ist:

„programm.jar“ der Name Ihrer JAR-Datei
„package.MainClass“ der vollständige Name der Klasse mit der main-Methode
„bin“ das Verzeichnis mit den .class-Dateien

Die erstellte JAR-Datei kann nun auf jedem System mit einer installierten Java Runtime Environment (JRE) ausgeführt werden:

java -jar programm.jar

Diese Methode bietet mehrere Vorteile:

Einfache Distribution: Nur eine einzige Datei muss verteilt werden.
Plattformunabhängigkeit: Das JAR-File kann auf jedem System mit einer JRE ausgeführt werden.
Kompakt: Alle benötigten Dateien sind in einem Archiv zusammengefasst

Stellen Sie sicher, dass der Benutzer eine kompatible Java-Version installiert hat, um das Programm ausführen zu können.

Um die Dateien typeitin.java und typeitin.class in eine .jar-Datei umzuwandeln, müssen Sie einige Schritte im Terminal ausführen. Hier ist eine Anleitung:

Kompilieren der Java-Datei (falls noch nicht geschehen): javac typeitin.java Dies erzeugt die typeitin.class-Datei. Wenn die typeitin.class-Datei bereits existiert, können Sie diesen Schritt überspringen.
Erstellen einer Manifest-Datei (optional, aber empfohlen, wenn Sie eine ausführbare .jar-Datei erstellen möchten): Erstellen Sie eine Datei namens Manifest.txt mit folgendem Inhalt: Main-Class: typeitin Achten Sie darauf, dass am Ende der Zeile ein Zeilenumbruch steht.
Erstellen der .jar-Datei:
Wenn Sie keine Manifest-Datei benötigen:
sh jar cf typeitin.jar typeitin.class
Wenn Sie eine Manifest-Datei verwenden:
sh jar cfm typeitin.jar Manifest.txt typeitin.class

Hier ist eine detaillierte Erklärung der Befehle:

javac typeitin.java: Kompiliert die typeitin.java-Datei zu typeitin.class.
jar cf typeitin.jar typeitin.class: Erstellt eine .jar-Datei namens typeitin.jar und fügt die typeitin.class-Datei hinzu.
jar cfm typeitin.jar Manifest.txt typeitin.class: Erstellt eine .jar-Datei namens typeitin.jar mit einer Manifest-Datei Manifest.txt und fügt die typeitin.class-Datei hinzu.

Jetzt sollten Sie eine .jar-Datei namens typeitin.jar haben, die Ihre kompilierte Java-Klasse enthält. Wenn Sie die Manifest-Datei verwendet haben und die Hauptklasse richtig angegeben haben, können Sie die .jar-Datei auch ausführen:

java -jar typeitin.jar

Stellen Sie sicher, dass Sie im richtigen Verzeichnis sind, wo sich Ihre .java– und .class-Dateien befinden, oder geben Sie den vollständigen Pfad an.

ein Java-Programm kann mit einem Doppelklick ausgeführt werden, aber es erfordert einige Vorbereitungen:

Erstellen Sie eine ausführbare JAR-Datei aus Ihrem Java-Programm.
Stellen Sie sicher, dass Java auf dem System korrekt installiert ist
Konfigurieren Sie das Betriebssystem, um JAR-Dateien mit Java zu verknüpfen:
- Unter Windows können Sie das Programm „jarfix“ verwenden, um JAR-Dateien automatisch mit Java zu verknüpfen
- Unter Linux (z.B. Ubuntu) können Sie die Dateirechte anpassen und die JAR-Datei mit der Java Runtime verknüpfen
Für Konsolenprogramme kann es hilfreich sein, eine Batch-Datei (Windows) oder ein Shell-Skript (Linux/Mac) zu erstellen, das die JAR-Datei ausführt und das Konsolenfenster offen hält

Beachten Sie, dass bei manchen Systemen oder Konfigurationen zusätzliche Schritte erforderlich sein können, um eine reibungslose Ausführung per Doppelklick zu gewährleisten. In solchen Fällen ist es oft zuverlässiger, das Programm über die Kommandozeile mit dem Befehl „java -jar IhrProgramm.jar“ zu starten

Es gibt mehrere Möglichkeiten, eine Java-Datei in eine .exe-Datei umzuwandeln:

Launch4j: Dieses beliebte Tool ermöglicht die Umwandlung von JAR-Dateien in ausführbare Windows-Dateien. Es erlaubt die Konfiguration der minimalen Java-Version und kann eine gebündelte JRE verwenden oder nach einer spezifischen Java-Installation suchen.
Jar2Exe: Diese Software konvertiert JAR-Dateien in EXE-Dateien mit wenigen Klicks. Sie kann verschiedene Typen von EXE-Dateien erstellen, einschließlich konsolenbasierter Anwendungen, Windows GUI und Windows Services.
JSmooth: Ein weiteres Tool zur Umwandlung von JAR in EXE. Es bietet Anpassungsmöglichkeiten für Einstellungen wie das ausführbare Icon, die JVM-Version und den Fenstertyp.
GraalVM Native Image: Dies ist eine modernere Methode, die Java-Code in eine eigenständige ausführbare Datei umwandelt, die keine separate Java-Installation benötigt.
jpackage: Seit JDK 14 verfügbar, erstellt jpackage ein leicht installierbares Paket inklusive JVM.

Beachten Sie, dass bei den meisten dieser Methoden immer noch eine Java Runtime Environment (JRE) auf dem Zielsystem erforderlich ist, es sei denn, Sie verwenden GraalVM Native Image oder bündeln die JRE mit Ihrer Anwendung.

Es ist wichtig zu beachten, dass die Umwandlung in eine .exe-Datei nicht den Java-Code selbst in nativen Windows-Code konvertiert, sondern in der Regel einen Wrapper um die JAR-Datei erstellt.