+Handbuch der Java-Programmierung, 5. Auflage +

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/k100275.html | 329 +++++++++++++++++++++ 1 file changed, 329 insertions(+) create mode 100644 Master/Reference Architectures and Patterns/hjp5/html/k100275.html (limited to 'Master/Reference Architectures and Patterns/hjp5/html/k100275.html') diff --git a/Master/Reference Architectures and Patterns/hjp5/html/k100275.html b/Master/Reference Architectures and Patterns/hjp5/html/k100275.html new file mode 100644 index 0000000..c588d11 --- /dev/null +++ b/Master/Reference Architectures and Patterns/hjp5/html/k100275.html @@ -0,0 +1,329 @@ + + + +Handbuch der Java-Programmierung, 5. Auflage + + + + + + + + + +

Titel +	Inhalt +	Suchen +	Index +	DOC +	Handbuch der Java-Programmierung, 5. Auflage +
<< +	< +	> +	>> +	API +	Kapitel 43 - Reflection +

+ + + + +

43.4 Zugriff auf Membervariablen

43.4 Zugriff auf Membervariablen +

+ +

+Nachdem wir uns in den vorangegangenen Abschnitten die beiden Reflection-Aspekte +Instanzierung und Methodenaufruf angesehen haben, wollen +wir uns nun mit dem Zugriff auf Membervariablen (also auf die »Felder« +eines Objekts) mit Hilfe von Reflection beschäftigen. Prinzipiell +gibt es keine großen Unterschiede gegenüber dem Zugriff +auf eine Methode oder einen Konstruktor: +

Zunächst wird ein Klassenobjekt für das zu bearbeitende +Objekt beschafft. +
Dann wird eine Methode aufgerufen, um ein Bearbeitungsobjekt für +eine ganz bestimmte oder eine Liste aller Membervariablen zu beschaffen. +
Das Bearbeitungsobjekt wird verwendet, um die Membervariable zu +lesen, zu verändern oder andere Eigenschaften abzufragen. +

+ +

+Der erste Schritt erfolgt wie gewohnt durch Aufruf von getClass +oder die .class-Notation. Die +im zweiten Schritt benötigten Bearbeitungsobjekte sind vom Typ +Field, +sie können auf dem Klassenobjekt durch Aufruf einer der folgenden +Methoden beschafft werden: +

+ + + + + +
+ +
+Field getField(String name) +Field[] getFields() + +Field getDeclaredField(String name) +Field[] getDeclaredFields() +
+ + +java.lang.Class
+ +

+Mit getField +wird die Membervariable mit dem angegebenen Namen beschafft, und getFields +liefert ein Array mit Field-Objekten +zu allen öffentlichen Membervariablen. Die beiden Methoden getDeclaredField +und getDeclaredFields +liefern darüber hinaus auch nicht-öffentliche Membervariablen. + +

+Die Klasse Field +besitzt Methoden zum Zugriff auf die Membervariable: +

+ + + + + +
+ +
+Class getType() + +Object get(Object obj) + +void set(Object obj, Object value) +
+ + +java.lang.reflect.Field
+ +

+Mit getType +kann der Typ der Membervariable bestimmt werden. Das zurückgegebene +Klassenobjekt beschreibt ihn in derselben Weise wie beispielsweise +das Parameterobjekt von getMethod. +Mit get +kann auf den Wert zugegriffen werden, den die Membervariable in dem +als Argument übergebenen Objekt hat. Handelt es sich um einen +primitiven Typ, wird dieser automatisch in die passende Wrapper-Klasse +verpackt und als Objekt zurückgegeben. Referenztypen werden unverändert +zurückgegeben. Mit Hilfe der Methode set +kann der Wert einer Membervariable verändert werden. Das erste +Argument repräsentiert das zu veränderende Objekt und das +zweite den neuen Wert der Membervariable. Soll ein primitiver Typ +verändert werden, muss er vor der Übergabe in die passende +Wrapper-Klasse verpackt werden. +

+ + + + + + + + + + + +
+ +
+Neben den generischen get- +und set-Methoden +gibt es diese auch in typisierter Form. So dient beispielsweise getInt +dazu, ein int-Feld +abzufragen, mit getDouble +kann auf ein double +zugegriffen werden usw. Das Gegenstück dazu sind die Methoden +setInt, +setDouble +usw., mit denen die Membervariablen typisiert verändert werden +können.
+ + + + +
Tipp
+
+ +

+Wir wollen als Beispiel eine Klasse PrintableObject +erstellen, die direkt aus Object +abgeleitet ist und die Methode toString +überlagert. Im Gegensatz zur Implementierung von Object +soll unsere Variante von toString +in der Lage sein, die Namen und Inhalte aller Membervariablen des +zugehörigen Objekts auszugeben: + + +

+ + + + + +
+ +
+001 /* PrintableObject.java */ +002 +003 import java.lang.reflect.*; +004 +005 public class PrintableObject +006 { +007 public String toString() +008 { +009 StringBuffer sb = new StringBuffer(200); +010 Class clazz = getClass(); +011 while (clazz != null) { +012 Field[] fields = clazz.getDeclaredFields(); +013 for (int i = 0; i < fields.length; ++i) { +014 sb.append(fields[i].getName() + " = "); +015 try { +016 Object obj = fields[i].get(this); +017 if (obj.getClass().isArray()) { +018 Object[] ar = (Object[])obj; +019 for (int j = 0; j < ar.length; ++j) { +020 sb.append(ar[j].toString() + " "); +021 } +022 sb.append("\n"); +023 } else { +024 sb.append(obj.toString() + "\n"); +025 } +026 } catch (IllegalAccessException e) { +027 sb.append(e.toString() + "\n"); +028 } +029 } +030 clazz = clazz.getSuperclass(); +031 } +032 return sb.toString(); +033 } +034 +035 public static void main(String[] args) +036 { +037 JavaProgrammer jim = new JavaProgrammer(); +038 jim.name = "Jim Miller"; +039 jim.department = "Operating Systems"; +040 jim.age = 32; +041 String[] langs = {"C", "Pascal", "PERL", "Java"}; +042 jim.languages = langs; +043 jim.linesofcode = 55000; +044 jim.jdk12 = true; +045 jim.swing = false; +046 System.out.println(jim); +047 } +048 } +049 +050 class Employee +051 extends PrintableObject +052 { +053 public String name; +054 public String department; +055 public int age; +056 } +057 +058 class Programmer +059 extends Employee +060 { +061 public String[] languages; +062 public int linesofcode; +063 } +064 +065 class JavaProgrammer +066 extends Programmer +067 { +068 public boolean jdk12; +069 public boolean swing; +070 }
+ + +PrintableObject.java
+ +Listing 43.7: Die Klasse PrintableObject

+ +

+toString +besorgt zunächst ein Klassenobjekt zum aktuellen Objekt. Mit +getDeclaredFields +wird dann eine Liste aller Felder (nicht nur der öffentlichen) +dieser Klasse besorgt und jeweils mit getName +sein Name und mit get +sein Wert ausgegeben. Wir machen uns dabei die Fähigkeit zunutze, +dass alle Objekte (auch die Wrapper-Klassen der primitiven Typen) +eine Methode toString +haben, die ihren Wert als String liefert. Ist die Membervariable ein +Array, durchläuft das Programm zusätzlich seine Elemente +und gibt sie einzeln aus. + +

+Da eine Klasse Membervariablen aus ihren Vaterklassen erbt, ist es +notwendig, die Vererbungshierarchie von unten nach oben zu durchlaufen, +denn getDeclaredFields +liefert nur die Membervariablen der aktuellen Klasse. Der Aufruf von +getSuperClass +am Ende der Schleife liefert zur aktuellen Klasse die Vaterklasse. +Ist der Rückgabewert null, +so ist das Ende der Vererbungshierarchie erreicht (clazz +repräsentiert dann die Klasse Object) +und die Schleife wird beendet. + +

+Die Klassen Employee, Programmer +und JavaProgrammer zeigen beispielhaft +die Anwendung von PrintableObject. +Employee ist aus PrintableObject +abgeleitet und erbt die modifizierte Methode toString. +Programmer ist aus Employee +abgeleitet und JavaProgrammer +aus Programmer. Das Hauptprogramm +erzeugt ein Objekt des Typs JavaProgrammer +und weist seinen eigenen und den geerbten Membervariablen Werte zu, +die durch den anschließenden Aufruf von toString +auf dem Bildschirm ausgegeben werden. Die Ausgabe des Programms ist: + +

+jdk12 = true
+swing = false
+languages = C Pascal PERL Java
+linesofcode = 55000
+name = Jim Miller
+department = Operating Systems
+age = 32
+

+ +

+ + + +

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