Ich nehme derzeit an einer Akademie zum Java Fullstack Software Engineer teil. In den kommenden Wochen möchte ich hier meine Mitschrift, so gut es geht, aufzeichnen und mitteilen. Hier ist das, was ich vom vierten Tag in Block 3 gelernt und behalten habe:

Speicher

Wenn ein Programm läuft, kann man mit dem Tool "jconsole" Javaprozsse sehen. Dadurch, dass ich im Hintergrund ein Java-Programm (Kreisrechner-Utility, wartet auf Eingabe) gestartet habe, laufen bei mir vier Java Prozesse. Ich verbinde mich mit der App:

Hier ist eine Gesamt-Übersicht:

Der Heapspeicher ist der, wo die Objekte erzeugt werden.

Es gibt auch das Tool VisualVM (https://visualvm.github.io/):

Dort kann man auch die Threads sehen:

Im Stack werden Referenzzeiger gemacht.
Im Heap stehen die Objekte und Attribute.

Innere Klassen

Wir bauen ein Heizkraftwerk:

Brennkammer ist eine innere Klasse

Eine Komposition (in der Brennkammer mit dem "Plus-Pfeil" symbolisiert) ist dann sinnvoll, wenn Objekte abhängig von anderen Objekten sind (z.B. Rechnungspositionen von einer Rechnung):

Im Target-Ordner hat der Klassen-Name ein $:

IntelliJ zeigt es so an:

Anonyme Klassen

Beispiel: Fenster liegen übereinander. Die Helpfunktionen haben alle Listener, die Events abfangen. Der Listener ist zwar überall gleich, aber die Event-Methoden sind unterschiedlich.
Listener ist ein Object, auf dass alle Help-Klassen zeigen. Die Methode Event wird beim Vererben überschrieben.

Es macht aber keinen Sinn, das Objekt der obersten Klasse zur Startzeit zu bauen, sondern erst im Kontext der "Hilfe-"Buttons. Das Objekt wird nur bei Gebrauch gebaut und erhält keinen Namen, wodurch es auch von außen nicht erreichbar ist. Es existiert noch so lange, wie der aktuelle Kontext existiert.

Nur innere Klassen können anonym sein.

Das Objekt Person wird ohne Attribut erzeugt und existiert nur für den Augenblick:

Anonyme Klassen habe ein $1 bzw. $n im Namen:

Reflection

In der Main Applikation steht nur noch der Aufruf des Controlers:

package de.firma;
import de.firma.ofen.OfenController;
import de.firma.ofen.OfenControllerImpl;

/**
 * Diese Startklasse dient dem Test des Ofen-Modells.
 * <p>
 * Um das Simulationsprogramm JMain von unterschiedlichen Ofen-
 * Implementierungen zu entkoppeln, wurde eine einheitliche Steuerung, 
 * der OfenController eingef hrt. Der OfenController erzeugt den Ofen,
 * erm glicht die dynamische Generierung von Brennelemnten und befeuert
 * den Ofen.
 * 
 * @version KRG + HP Dez.2005
 */
public class JMain {

	/**
	 * Starte Simulation
	 */
	public static void main(String[] args) {
		System.out.println("Projekt Heizkraftwerk Version hkw03");
		OfenController oc = new OfenControllerImpl();
		oc.start("auto");
	}
}

Der Gag ist folgende Hashtable in OfenCOntrollerImpl.java. Dort wird definiert, zu welchem String, welches Objekt gehört:

Wir laden die Klassen zur Laufzeit und haben keine Bindung mehr zur Compiler-Zeit.

Reflection bedeutet, man kan Objekte elegant dynamisch zur Laufzeit erzeugen.

File Access

Bei der Serialisierung werden Daten, wie beim Beamen, in Ihre Bytes zerlegt, übertragen und nachher wieder zu Objekten zusammen gebaut.

Die Klasse File representiert sowohl eine Datei als auch ein Verzeichnis.

Achtung: Java nutzt die Unix-Konvention. Würde man die Datei "C:\temp" nennen, würde aus \t ein Tabulator und die Datei könnte nicht angelegt werden.

Hier in diesem Beispiel wird der relative Pfad genutzt. Dateien liegen dann im Projekt:

package de.firma.fileaccess;

import java.io.File;
import java.io.IOException;

public class FileInfo {
    public static void main(String[] args) {
        File verzX = new File("./temp/");
        if (!verzX.exists()) {
            verzX.mkdir();
            System.out.println("Verzeichnis  " + verzX.getPath() + "  angelegt: " + verzX.exists());
        }
        File file = new File("./temp/test.dat");
        if (!file.exists()) {
            try {
                file.createNewFile();
            } catch (IOException _uh) {
            }
            System.out.println("Datei  " + file.getName() + "  angelegt: " + file.exists());
        }
        if (file.isFile())
            System.out.println(file.getName() + " ist eine Datei ");
        else
            System.out.println(file.getName() + " ist keine Datei ");
        if (file.isDirectory())
            System.out.println(file.getName() + " ist ein Verzeichnis ");
        else
            System.out.println(file.getName() + " ist kein Verzeichnis ");
        System.out.println("Parent: " + file.getParent());
        System.out.println("Parentfile: " + file.getParentFile());
        System.out.println("Pfad: " + file.getPath());
        System.out.println("absoluter Pfad: " + file.getAbsolutePath());
        System.out.println("Dateiattribute:");
        System.out.println("lesen erlaubt: " + file.canRead());
        System.out.println("schreiben erlaubt: " + file.canWrite());
        System.out.println("versteckt: " + file.isHidden());
    }
}

Systemvariablen

Man kann beim Starten von der Java-App Argumente übergeben:

Edit configuration und Argumente eingeben:

System Properties

Siehe dort: https://howtodoinjava.com/java/basics/java-system-properties/

Über run… und edit config, kann man sich die Systemproperties anschauen:

Oder via Code:

Setzen der System Parameter (VM Options) geht so:

Ergebnis:

Hier ist der Code:

package de.firma.systemaccess;

import java.util.*;

// Aufruf:  C:\opt\jdk-11.0.6\bin\java.exe      de.firma.systemaccess.SystemProperties -DDeveloper=Achimmertens
//  Menü: Run -> Run... -> Edit Configuration  -> Modify Options -> Add VM Parameter -> -DDeveloper=Achimmertens

public class SystemProperties {
    public static void main(String[] args) {

        System.out.println("SystemProperties");
        System.out.println("-----------------------");
        System.out.println("Java-Version:  "+System.getProperty("java.version"));
        System.out.println("Developer:  "+System.getProperty("Developer"));
        System.out.println("-----------------------");
        // List all System properties
        Properties pros = System.getProperties();
        pros.list(System.out);

        Enumeration<?> props = System.getProperties().propertyNames();
        List<String> keys = new ArrayList<String>();
        while (props.hasMoreElements()) {
            String prop = props.nextElement().toString();
            keys.add(prop);
        }
        Collections.sort(keys);
        for(String key : keys) {
            System.out.printf("%-70s  :   %-50s \n", key,System.getProperty(key));
        }
    }
}

——————

Disclaimer

Alles was ich mitschrieb und verstanden habe ist ohne Gewähr.

Besten Dank an unseren

Trainer: Hans-Joachim Blanke blanke@4point.de

Mehr dazu im nächsten Blog von mir.

Gruß, Achim Mertens

Topics