Professionelle Bücher. Auch für Einsteiger.

Inhaltsverzeichnis
Vorwort
1 Java ist auch eine Sprache
2 Sprachbeschreibung
3 Klassen und Objekte
4 Der Umgang mit Zeichenketten
5 Mathematisches
6 Eigene Klassen schreiben
7 Angewandte Objektorientierung
8 Exceptions
9 Die Funktionsbibliothek
10 Threads und nebenläufige Programmierung
11 Raum und Zeit
12 Datenstrukturen und Algorithmen
13 Dateien und Datenströme
14 Die eXtensible Markup Language (XML)
15 Grafische Oberflächen mit Swing
16 Grafikprogrammierung
17 Netzwerkprogrammierung
18 Verteilte Programmierung mit RMI und Web-Services
19 JavaServer Pages und Servlets
20 Applets
21 Midlets und die Java ME
22 Datenbankmanagement mit JDBC
23 Reflection und Annotationen
24 Logging und Monitoring
25 Sicherheitskonzepte
26 Java Native Interface (JNI)
27 Dienstprogramme für die Java-Umgebung
A Die Begleit-DVD
Stichwort
Download: - ZIP, ca. 12,5 MB
Buch bestellen
Ihre Meinung?
<< zurück | Galileo Computing / <openbook> /Java-Insel | vor >>
Java ist auch eine Insel von Christian Ullenboom Programmieren mit der Java Standard Edition Version 6
Java ist auch eine Insel 7., aktualisierte Auflage geb., mit DVD (November 2007) 1.492 S., 49,90 Euro Galileo Computing ISBN 978-3-8362-1146-8 |
| 3 Klassen und Objekte
|  | 3.1 Objektorientierte Programmierung
|  |  | 3.1.1 Warum überhaupt OOP?
|  |  | 3.1.2 Wiederverwertbarkeit
|  | 3.2 Eigenschaften einer Klasse
|  |  | 3.2.1 Die Klasse Point
|  | 3.3 Die UML (Unified Modeling Language)
|  |  | 3.3.1 Hintergrund und Geschichte zur UML
|  |  | 3.3.2 Wichtige Diagrammtypen der UML
|  | 3.4 Neue Objekte erzeugen
|  |  | 3.4.1 Anlegen eines Exemplars einer Klasse mit dem new-Operator
|  |  | 3.4.2 Deklarieren von Referenzvariablen
|  |  | 3.4.3 Zugriff auf Variablen und Methoden mit dem ».«
|  |  | 3.4.4 Konstruktoren nutzen
|  |  | 3.4.5 Die API-Dokumentation
|  | 3.5 Import und Pakete
|  | 3.6 Mit Referenzen arbeiten
|  |  | 3.6.1 Die null-Referenz
|  |  | 3.6.2 Zuweisungen bei Referenzen
|  |  | 3.6.3 Funktionen mit nicht-primitiven Parametern
|  | 3.7 Identität und Gleichheit
|  |  | 3.7.1 Identität von Objekten
|  |  | 3.7.2 Gleichheit und die Methode equals()
|  | 3.8 Wrapper-Klassen und Autoboxing
|  |  | 3.8.1 Die Basisklasse Number für numerische Wrapper-Objekte
|  |  | 3.8.2 Die Klasse Integer
|  |  | 3.8.3 Unterschiedliche Ausgabeformate
|  |  | 3.8.4 Autoboxing: Boxing und Unboxing
|  |  | 3.8.5 Die Boolean-Klasse
|  |  | 3.8.6 Die Klassen Double und Float für Fließkommazahlen
|  | 3.9 Arrays
|  |  | 3.9.1 Deklaration von Arrays
|  |  | 3.9.2 Arrays mit Inhalt
|  |  | 3.9.3 Die Länge eines Arrays über das Attribut length
|  |  | 3.9.4 Zugriff auf die Elemente über den Index
|  |  | 3.9.5 Array-Objekte erzeugen
|  |  | 3.9.6 Fehler bei Arrays
|  |  | 3.9.7 Vorinitialisierte Arrays
|  |  | 3.9.8 Die erweiterte for-Schleife
|  |  | 3.9.9 Arrays mit nicht-primitiven Elementen
|  |  | 3.9.10 Mehrdimensionale Arrays
|  |  | 3.9.11 Die Wahrheit über die Array-Initialisierung
|  |  | 3.9.12 Mehrere Rückgabewerte
|  |  | 3.9.13 Methode mit variabler Argumentanzahl (Vararg)
|  |  | 3.9.14 Klonen kann sich lohnen – Arrays vermehren
|  |  | 3.9.15 Feldinhalte kopieren
|  |  | 3.9.16 Die Klasse Arrays zum Vergleichen, Füllen und Suchen
|  | 3.10 Der Einstiegspunkt für das Laufzeitsystem main()
|  |  | 3.10.1 Kommandozeilen-Argumente verarbeiten
|  |  | 3.10.2 Der Rückgabewert von main() und System.exit()
|  | 3.11 Eigene Pakete schnüren
|  |  | 3.11.1 Die package-Anweisung
|  |  | 3.11.2 Importieren von Klassen mit import
|  |  | 3.11.3 Hierarchische Strukturen und das Default-Package
|  |  | 3.11.4 Paketnamen
|  |  | 3.11.5 Klassen mit gleichen Namen in unterschiedlichen Paketen
|  |  | 3.11.6 Statisches Import
|  |  | 3.11.7 Eine Verzeichnisstruktur für eigene Projekte
|  | 3.12 Zum Weiterlesen
## 3.7 Identität und Gleichheit ### 3.7.1 Identität von Objekten Der Vergleichsoperator == ist für alle Datentypen so definiert, dass er die vollständige Übereinstimmung zweier Werte testet. Bei primitiven Datentypen ist das einfach einzusehen, und bei Referenztypen im Prinzip genauso. Der Operator == testet bei Referenzen, ob diese übereinstimmen, also auf das gleiche Objekt verweisen. Demnach sagt der Test etwas über die Identität der referenzierten Objekte aus, aber nicht, ob zwei verschiedene Objekte möglicherweise den gleichen Inhalt haben. Der Inhalt der Objekte spielt bei == nie eine Rolle.
Beispiel Zwei Objekte mit drei unterschiedlichen Punktvariablen p, q, r und die Bedeutung von ==:
    Point p = new Point( 10, 10 );
    Point q = p;
    Point r = new Point( 10, 10 );
    if ( p == q )    // wahr, da p und q dasselbe Objekt referenzieren
      ...
    if ( p == r )    // falsch, da p und r zwei verschiedene Punkt-Objekte
      ...            // referenzieren, die zufällig dieselben Koordinaten haben
Da p und q auf dasselbe Objekt verweisen, ergibt der Vergleich true. p und r referenzieren unterschiedliche Objekte, die aber zufälligerweise den gleichen Inhalt haben. Doch woher soll der Compiler wissen, wann zwei Punkt-Objekte inhaltlich gleich sind? Weil sich ein Punkt durch die Attribute x und y auszeichnet? Die Laufzeitumgebung könnte voreilig die Belegung jeder Objektvariable vergleichen, doch das entspricht nicht immer einem korrekten Vergleich, so wie wir ihn uns wünschen. Ein Punkt-Objekt könnte etwa zusätzlich die Anzahl der Zugriffe zählen, die jedoch für einen Vergleich, der auf der Lage zweier Punkte basiert, nicht berücksichtigt werden darf. ### 3.7.2 Gleichheit und die Methode equals() Die allgemein gültige Lösung besteht darin, die Klasse festlegen zu lassen, wann Objekte gleich sind. Dazu kann jede Klasse eine Methode equals() implementieren, die Exemplare dieser Klasse mit beliebigen anderen Objekten vergleichen kann. Die Klassen entscheiden immer nach Anwendungsfall, welche Attribute sie für einen Gleichheitstest heranziehen, und equals() liefert true, wenn die gewünschten Zustände (Objektvariablen) übereinstimmen.
Beispiel Zwei inhaltlich gleiche Punkt-Objekte, verglichen mit == und equals().
    Point p = new Point( 10, 10 );
    Point q = new Point( 10, 10 );

    if ( p == q )         // false
      ...
    if ( p.equals(q) )    // true. Da symmetrisch auch q.equals(p)
      ...
Nur equals() testet in diesem Fall die inhaltliche Gleichheit.
Bei den unterschiedlichen Bedeutungen müssen wir demnach die Begriffe »Identität« und »Gleichheit« von Objekten sorgfältig unterscheiden. Daher noch einmal eine Zusammenfassung:
| Getestet mit | Implementierung
Identität der Referenzen | == | Nichts zu tun
Gleichheit der Zustände | equals() | Abhängig von der Klasse
#### Es gibt immer ein equals() Glücklicherweise müssen wir als Programmierer nicht lange darüber nachdenken, ob eine Klasse eine equals()-Methode anbieten soll oder nicht. Jede Klasse besitzt sie, da die universelle Oberklasse Object sie vererbt. Wir greifen hier auf Kapitel 6 vor; der Abschnitt kann aber übersprungen werden. Die Unterklasse Point überschreibt equals(), wie die API-Dokumentation zeigt. Werfen wir einen Blick auf die equals()-Methode aus Point, um eine Vorstellung von der Arbeitsweise zu bekommen:
    public boolean equals( Object obj )
    {
      if ( obj instanceof Point ) {
        Point pt = (Point) obj;
        return (x == pt.x) && (y == pt.y);   // (*)
      }
      return super.equals( obj );
    }
Obwohl bei diesem Beispiel für uns einiges neu ist, erkennen wir den Vergleich in der Zeile (*). Hier vergleicht das Point-Objekt seine eigenen Attribute mit den Attributen des Objekts, das als Argument an equals() übergeben wurde. #### Die Oberklasse Object und ihr equals() Wenn eine Klasse keine equals()-Methode angibt, dann erbt sie eine Implementierung aus der Klasse Object, die wie folgt aussieht:
    public boolean equals( Object obj )
    {
      return ( this == obj );
    }
Wir erkennen, dass hier die Gleichheit auf die Gleichheit der Referenzen abgebildet wird. Ein inhaltlicher Vergleich findet nicht statt.
Hinweis Der Datentyp für den Parameter in der equals()-Funktion ist immer Object und niemals etwas anderes, da sonst die equals()-Funktion nicht überschrieben, sondern überladen wird. Folgendes für eine Klasse K ist also falsch:
    public class K
    {
      private int v;
      public boolean equals( K that ) { return this.v == that.v; }
    }
Im Vokabular der Informatiker gesprochen: Java unterstützt bisher keine kovarianten Typ-parameter, wohl aber seit Java 5 kovariante Rückgabetypen.
### Ihr Kommentar Wie hat Ihnen das <openbook> gefallen? Wir freuen uns immer über Ihre freundlichen und kritischen Rückmeldungen.
Name |
E-Mail |
Ihr Kommentar |
<< zurück | <top> | vor >>

Copyright © Galileo Press 2008
Für Ihren privaten Gebrauch dürfen Sie die Online-Version natürlich ausdrucken. Ansonsten unterliegt das <openbook> denselben Bestimmungen, wie die gebundene Ausgabe: Das Werk einschließlich aller seiner Teile ist urheberrechtlich geschützt. Alle Rechte vorbehalten einschließlich der Vervielfältigung, Übersetzung, Mikroverfilmung sowie Einspeicherung und Verarbeitung in elektronischen Systemen.

[Galileo Computing]
Galileo Press, Rheinwerkallee 4, 53227 Bonn, Tel.: 0228.42150.0, Fax 0228.42150.77, info@galileo-press.de