From 33613a85afc4b1481367fbe92a17ee59c240250b Mon Sep 17 00:00:00 2001 From: Sven Eisenhauer Date: Fri, 10 Nov 2023 15:11:48 +0100 Subject: add new repo --- .../hjp5/html/k100084.html | 494 +++++++++++++++++++++ 1 file changed, 494 insertions(+) create mode 100644 Master/Reference Architectures and Patterns/hjp5/html/k100084.html (limited to 'Master/Reference Architectures and Patterns/hjp5/html/k100084.html') diff --git a/Master/Reference Architectures and Patterns/hjp5/html/k100084.html b/Master/Reference Architectures and Patterns/hjp5/html/k100084.html new file mode 100644 index 0000000..ef0c737 --- /dev/null +++ b/Master/Reference Architectures and Patterns/hjp5/html/k100084.html @@ -0,0 +1,494 @@ + + + +Handbuch der Java-Programmierung, 5. Auflage + + + + + + + + + +
 Titel  + Inhalt  + Suchen  + Index  + DOC  +Handbuch der Java-Programmierung, 5. Auflage +
 <<  +  <   +  >   + >>  + API  +Kapitel 13 - Strukturierung von Java-Programmen +
+
+ + + + +

13.1 Programmelemente

+
+ +
+ +

+Wie in jeder Programmiersprache kann man auch in Java Strukturen erkennen, +die auf den unterschiedlichen Abstraktionsebenen die Bestandteile +eines Programms bilden. Die Kenntnis und Bezeichnung dieser Strukturen +ist hilfreich für das Verständnis der entwickelten Programme +und für die Kommunikation mit anderen Programmierern. + +

+Wir wollen uns dazu in diesem Kapitel die folgenden Programmelemente +ansehen: +

+ + + + +

13.1.1 Anweisungen

+ +

+Anweisungen gehören zu den elementarsten ausführbaren Programmelementen +in Java. Eine Anweisung kann eine Deklaration enthalten, einen Ausdruck +auswerten oder den Programmablauf steuern. Wir wollen Anweisungen +an dieser Stelle als die kleinsten Bausteine von Java betrachten, +und alle anderen Elemente sollen darauf aufbauen. + + + + +

13.1.2 Blöcke

+ +

+Ein Block ist eine Kollektion von Anweisungen, die nacheinander ausgeführt +werden. Anders als eine einfache Anweisung kann ein Block eigene Variablen +definieren, die nur innerhalb des Blocks sichtbar sind. Sie werden +angelegt, wenn der Block aufgerufen wird, und zerstört, wenn +er wieder verlassen wird. + +

+Interessant ist ein Block vor allem deshalb, weil er selbst eine Anweisung +ist. Während er in seiner Zusammensetzung aus vielen verschiedenen +Anweisungen bestehen kann, stellt sich ein Block nach außen +hin als eine einzige Anweisung dar. Die ganze Semantik einer blockstrukturierten +Sprache ist darauf ausgelegt, dass ein Block für die Anweisungen, +die ihn verwenden, wie eine homogene Einzelanweisung aussieht. + +

+Rekursive Konstruktionsschemata, wie das hier beschriebene, treten +an vielen verschiedenen Stellen und in vielen verschiedenen Erscheinungsformen +bei der Programmentwicklung auf. Es gibt Methoden, die sich selbst +aufrufen, Strukturvariablen, die andere Variablen enthalten, oder +eben Blöcke, die Anweisungen enthalten und Anweisungen +sind. Grundlage von rekursiven Part-of-Beziehungen ist +immer der Umstand, dass die Kollektion selbst vom Typ der darin enthaltenen +Elemente ist. + +

+Die Sichtbarkeit und Lebensdauer von Blöcken +in Java entspricht den üblichen Regeln, die auch in anderen Programmiersprachen +gültig sind. Lokale Variablen werden angelegt, wenn die Ausführung +des Blocks beginnt, und wieder zerstört, wenn der Block verlassen +wird. Innerhalb eines Blocks sind die lokalen Variablen des Blocks +und die lokalen Variablen der umgebenden Blöcke bzw. der umgebenden +Methode sichtbar. Zusätzlich sind die Variablen der Klasse sichtbar, +in der die den Block umschließende Methode enthalten ist. +

+ + + + + + + + + + + +
+ +

+Lokale Variablen verdecken gleichnamige Instanz- oder Klassenvariablen. +Durch Voranstellen des this-Zeigers +kann trotzdem auf sie zugegriffen werden. Dies wird in Java oft ausgenutzt, +um im Konstruktor einer Methode Membervariablen zu initialisieren, +die denselben Namen wie formale Parameter haben: + + +

+ + + + +
+ +
+001 class Point
+002 {
+003   private int x, y;
+004   public Point(int x, int y)
+005   {
+006     this.x = x;
+007     this.y = y;
+008   }
+009 }
+ +
+ +Listing 13.1: Zugriff auf verdeckte Membervariablen

+		 + + + + +
 Tipp 
+
+ +

+Diese Vorgehensweise hat den Vorteil, dass man sich für die formalen +Parameter nicht extra Namen ausdenken muss, nur damit sie sich von +den zugehörigen Membervariablen unterscheiden. +

+ + + + + + + + + + + +
+ +

+Sie hat aber auch den Nachteil, dass Membervariablen versehentlich +durch lokale Variablen verdeckt werden können. Das folgende Beispiel +zeigt einen typischen Fehler dieser Art: + + +

+ + + + + +
+ +
+001 /* Listing1302.java */
+002 
+003 public class Listing1302
+004 {
+005   private int cnt = 0;
+006 
+007   public void printNext()
+008   {
+009     int value = cnt;
+010     System.out.println("value = " + value);
+011     int cnt = value + 1; 
+012   }
+013 
+014   public static void main(String[] args)
+015   {
+016     Listing1302 obj = new Listing1302();
+017     obj.printNext();
+018     obj.printNext();
+019     obj.printNext();
+020   }
+021 }
+ +		 +Listing1302.java
+ +Listing 13.2: Versehentliches Verdecken einer Membervariable

+ +

+Auf den ersten Blick würde man erwarten, dass nacheinander die +Werte 0, 1 und 2 ausgegeben werden. Dem ist aber nicht so, denn in +Zeile 011 wird der um eins +erhöhte Wert nicht der Membervariablen cnt +zugewiesen, sondern der lokalen Variablen gleichen Namens. Dieser +Fehler ist recht tückisch und kann bei unübersichtlichem +Programmcode leicht entstehen. Die hier vorgestellte Variante passiert +vor allem dann leicht, wenn eine ehemals lokale Variable zu einer +Membervariable umfunktioniert wurde und der Programmierer nicht daran +gedacht hat, den Typnamen zu entfernen.

 + + + + +
 Warnung 
+
+

+ + + + + + + + + +
+ +

+Im Gegensatz zu den meisten anderen Programmiersprachen gibt es in +Java die Regel, dass lokale Variablen sich nicht gegenseitig +verdecken dürfen. Es ist also nicht erlaubt, innerhalb eines +Blocks eine lokale Variable zu deklarieren, die unter demselben Namen +bereits als lokale Variable sichtbar ist. Weitere Details zu Blöcken +sind in Kapitel 6 zu +finden.

 + + + + +
 Hinweis 
+
+ + + + +

13.1.3 Methoden

+ +

+Methoden sind wie Blöcke Kollektionen, die Deklarationen und +Anweisungen enthalten können. Genaugenommen enthalten sie neben +dem Funktionskopf genau einen Block, der alle anderen Elemente +enthält. Sie unterscheiden sich von Blöcken folgendermaßen: +

+

+ + + + + + + + + +
+ +

+Methoden werden in Java immer lokal zu einer Klasse definiert. +Klassenlose Funktionen, wie sie beispielsweise in C++ zur Verfügung +stehen, gibt es in Java nicht. In diesem Sinne ist Java eine wirklich +objektorientierte Programmiersprache, denn die Methoden operieren +immer auf den Daten eines bestimmten Objekts, zu dem sie aufgerufen +werden.

 + + + + +
 Hinweis 
+
+ +

+Allerdings gibt es noch die Klassenmethoden. +Sie werden zwar auch innerhalb einer Klasse definiert, benötigen +aber später kein Objekt zur Ausführung. Statt dessen entsprechen +Klassenmethoden eher den globalen Funktionen anderer Programmiersprachen +und haben somit keinen Zugriff auf die Membervariablen eines Objekts. +Im Unterschied zu gewöhnlichen Funktionen werden Klassenmethoden +aber innerhalb einer Klasse definiert und besitzen damit einen eigenen +Namensraum, der sich über die Methoden der aktuellen Klasse erstreckt. +Der Zugriff auf eine Klassenmethode erfordert immer die Verwendung +eines qualifizierten Namens, der sich aus dem Klassennamen, einem +Punkt und dem eigentlichen Methodennamen zusammensetzt. + + + + +

13.1.4 Klassen

+ +

+Klassen sind das wichtigste Strukturierungsmittel objektorientierter +Sprachen. Eine Klasse enthält eine Menge von Variablen, die den +Zustand von Objekten dieser Klasse beschreiben, und eine Menge +von Methoden, die das Verhalten der Objekte festlegen. + +

+Klassen sind insofern schachtelbar, als ihre Instanzvariablen vom +Typ einer Klasse sein können. Dabei ist es insbesondere erlaubt, +dass die Membervariablen von demselben Typ wie die zu definierende +Klasse sind. Da in Java alle Objekte als Referenzen abgelegt werden, +können auf diese Weise rekursive Datentypen erzeugt und zur Konstruktion +von dynamischen Datenstrukturen verwendet +werden. + + + + +

13.1.5 Pakete

+ +

+In großen Programmsystemen reichen Klassen als Strukturelemente +alleine nicht aus. Deshalb bietet Java mit den Packages (oder +Paketen) oberhalb der Ebene der Klassen eine weitere Kollektion für +Programmelemente an. + +

+Ein Paket ist eine Sammlung von Klassen, die einen gemeinsamen Zweck +verfolgen oder aus anderen Gründen zusammengefasst werden sollen. +Jede Klasse in Java ist Bestandteil genau eines Pakets. Paketnamen +können aus mehreren Teilen bestehen und beliebig tiefe Hierarchien +ausdrücken. + +

+Der Name einer Methode oder einer Variablen besteht damit grundsätzlich +aus drei Elementen: +

+ +

+Ein Beispiel für einen Methodennamen ist java.lang.Math.sqrt. +Wir werden später Mechanismen kennenlernen, mit denen es möglich +ist, die Namen bei ihrer Verwendung abzukürzen. + + + + +

13.1.6 Applikationen

+ +

+Applikationen bilden eigenständige Programme in Java. Sie benötigen +keinen Browser zur Ausführung, sondern nur den Java-Interpreter +und die .class-Files der verwendeten +Klassen. + +

+Technisch betrachtet ist eine Applikation nicht mehr als eine einzelne +Klasse, in der eine Methode vom Typ public +static void main definiert wurde. +Jede Klasse, die eine solche Methode enthält, kann als Applikation +verwendet werden. +

+ + + + + + + + + + + +
+ +

+Durch einfaches Hinzufügen einer Methode public +static void main kann also jede beliebige Klasse sehr +leicht in eine Applikation verwandelt und vom Java-Interpreter aufgerufen +werden. Dies kann beispielsweise nützlich sein, um in Low-Level-Klassen, +die eigentlich nur als Dienstleister auftreten, eigenständig +ausführbaren Testcode unterzubringen, oder um eine solche Klasse +mit Benutzungshinweisen auszustatten, die der Entwickler durch einfaches +Starten der Klasse als Applikation abrufen kann.

 + + + + +
 Tipp 
+
+ + + + +

13.1.7 Applets

+ +

+Applets sind ebenfalls lauffähige Java-Programme. Anders als +Applikationen, werden sie aus einer HTML-Seite heraus aufgerufen und +benötigen zur Ausführung einen Web-Browser (oder ein Hilfsprogramm +wie den Appletviewer, das sich in gewissem +Sinne wie ein Web-Browser verhält). +

+ + + + + + + + + +
+ +

+Applets werden nicht durch die Methode public +static void main gestartet, sondern müssen aus der +Klasse Applet +abgeleitet und nach deren Architekturmerkmalen konstruiert werden. +Zum Starten des Programms erzeugt der Browser eine Instanz der abgeleiteten +Klasse und ruft nacheinander eine Reihe vordefinierter Callback-Methoden +auf. Callback-Methoden sind Methoden, die von der abgeleiteten Klasse +zur Verfügung gestellt und vom Browser oder AppletViewer aufgerufen +werden. Weitere Details zur Applet-Programmierung finden sich in Kapitel 39 +und Kapitel 40.

 + + + + +
 Hinweis 
+
+

+ + + +
 Titel  + Inhalt  + Suchen  + Index  + DOC  +Handbuch der Java-Programmierung, 5. Auflage, Addison +Wesley, Version 5.0.1 +
 <<  +  <   +  >   + >>  + API  +© 1998, 2007 Guido Krüger & Thomas +Stark, http://www.javabuch.de +
+ + + -- cgit v1.2.3