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:
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.
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:
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:
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 {
/**
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.
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());
}
}
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=Achimmertenspublic 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)); } }}
——————
Alles was ich mitschrieb und verstanden habe ist ohne Gewähr.
Besten Dank an unseren
Mehr dazu im nächsten Blog von mir.
Gruß, Achim Mertens
