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 |
| 6 Eigene Klassen schreiben
|  | 6.1 Eigene Klassen mit Eigenschaften deklarieren
|  |  | 6.1.1 Attribute deklarieren
|  |  | 6.1.2 Methoden deklarieren
|  |  | 6.1.3 Die this-Referenz
|  | 6.2 Privatsphäre und Sichtbarkeit
|  |  | 6.2.1 Für die Öffentlichkeit: public
|  |  | 6.2.2 Paketsichtbar
|  |  | 6.2.3 Kein Public Viewing – Passwörter sind privat
|  |  | 6.2.4 Wieso nicht freie Methoden und Variablen für alle?
|  |  | 6.2.5 Privat ist nicht ganz privat: Es kommt darauf an, wer’s sieht
|  |  | 6.2.6 Zugriffsmethoden für Attribute deklarieren
|  |  | 6.2.7 Setter und Getter nach der JavaBeans-Spezifikation
|  | 6.3 Statische Methoden und statische Attribute
|  |  | 6.3.1 Warum statische Eigenschaften sinnvoll sind
|  |  | 6.3.2 Statische Eigenschaften mit static
|  |  | 6.3.3 Statische Eigenschaften über Referenzen nutzen?
|  |  | 6.3.4 Warum die Groß- und Kleinschreibung wichtig ist
|  |  | 6.3.5 Statische Eigenschaften und Objekteigenschaften
|  |  | 6.3.6 Statische Variablen zum Datenaustausch
|  |  | 6.3.7 Statische Blöcke als Klasseninitialisierer
|  | 6.4 Konstanten und Aufzählungen
|  |  | 6.4.1 Konstanten über öffentliche statische finale Variablen
|  |  | 6.4.2 Eincompilierte Belegungen der Klassenvariablen
|  |  | 6.4.3 Typ(un)sicherere Aufzählungen
|  |  | 6.4.4 Aufzählungen mit enum
|  | 6.5 Objekte anlegen und zerstören
|  |  | 6.5.1 Konstruktoren schreiben
|  |  | 6.5.2 Der Standard-Konstruktor
|  |  | 6.5.3 Parametrisierte und überladene Konstruktoren
|  |  | 6.5.4 Konstruktor nimmt ein Objekt vom eigenen Typ an (Copy-Konstruktor)
|  |  | 6.5.5 Einen anderen Konstruktor der gleichen Klasse aufrufen
|  |  | 6.5.6 Initialisierung der Objekt- und Klassenvariablen
|  |  | 6.5.7 Finale Werte im Konstruktor und in statischen Blöcken setzen
|  |  | 6.5.8 Exemplarinitialisierer (Instanzinitialisierer)
|  |  | 6.5.9 Ihr fehlt uns nicht – der Garbage-Collector
|  |  | 6.5.10 Implizit erzeugte String-Objekte
|  |  | 6.5.11 Private Konstruktoren, Utility-Klassen, Singleton, Fabriken
|  | 6.6 Assoziationen zwischen Objekten
|  |  | 6.6.1 Unidirektionale 1:1-Beziehung
|  |  | 6.6.2 Bidirektionale 1:1-Beziehungen
|  |  | 6.6.3 Unidirektionale 1:n-Beziehung
|  | 6.7 Vererbung
|  |  | 6.7.1 Vererbung in Java
|  |  | 6.7.2 Spielobjekte modelliert
|  |  | 6.7.3 Einfach- und Mehrfachvererbung
|  |  | 6.7.4 Sichtbarkeit protected
|  |  | 6.7.5 Konstruktoren in der Vererbung und super
|  |  | 6.7.6 Automatische und explizite Typanpassung
|  |  | 6.7.7 Das Substitutionsprinzip
|  |  | 6.7.8 Typen mit dem binären Operator instanceof testen
|  |  | 6.7.9 Methoden überschreiben
|  |  | 6.7.10 Mit super an die Eltern
|  |  | 6.7.11 Kovariante Rückgabetypen
|  |  | 6.7.12 Array-Typen und Kovarianz
|  |  | 6.7.13 Zusammenfassung zur Sichtbarkeit
|  | 6.8 Dynamisches Binden
|  |  | 6.8.1 Unpolymorph bei privaten, statischen und finalen Methoden
|  |  | 6.8.2 Polymorphie bei Konstruktoraufrufen
|  |  | 6.8.3 Finale Klassen
|  |  | 6.8.4 Nicht überschreibbare (finale) Methoden
|  | 6.9 Abstrakte Klassen und abstrakte Methoden
|  |  | 6.9.1 Abstrakte Klassen
|  |  | 6.9.2 Abstrakte Methoden
|  | 6.10 Schnittstellen
|  |  | 6.10.1 Deklarieren von Schnittstellen
|  |  | 6.10.2 Implementieren von Schnittstellen
|  |  | 6.10.3 Markierungsschnittstellen
|  |  | 6.10.4 Ein Polymorphie-Beispiel mit Schnittstellen
|  |  | 6.10.5 Die Mehrfachvererbung bei Schnittstellen
|  |  | 6.10.6 Keine Kollisionsgefahr bei Mehrfachvererbung
|  |  | 6.10.7 Erweitern von Interfaces – Subinterfaces
|  |  | 6.10.8 Vererbte Konstanten bei Schnittstellen
|  |  | 6.10.9 Schnittstellenmethoden, die nicht implementiert werden müssen
|  |  | 6.10.10 Abstrakte Klassen und Schnittstellen im Vergleich
|  | 6.11 Geschachtelte (innere) Klassen, Schnittstellen, Aufzählungen
|  |  | 6.11.1 Statische innere Klassen und Schnittstellen
|  |  | 6.11.2 Mitglieds- oder Elementklassen
|  |  | 6.11.3 Lokale Klassen
|  |  | 6.11.4 Anonyme innere Klassen
|  |  | 6.11.5 this und Vererbung
|  | 6.12 Generische Datentypen
|  |  | 6.12.1 Einfache Klassenschablonen
|  |  | 6.12.2 Einfache Methodenschablonen
|  |  | 6.12.3 Umsetzen der Generics, Typlöschung und Raw-Types
|  |  | 6.12.4 Einschränken der Typen
|  |  | 6.12.5 Generics und Vererbung, Invarianz
|  |  | 6.12.6 Wildcards
|  | 6.13 Die Spezial-Oberklasse Enum
|  |  | 6.13.1 Methoden auf Enum-Objekten
|  |  | 6.13.2 enum mit eigenen Konstruktoren und Methoden
|  | 6.14 Dokumentationskommentare mit JavaDoc
|  |  | 6.14.1 Einen Dokumentationskommentar setzen
|  |  | 6.14.2 Mit javadoc eine Dokumentation erstellen
|  |  | 6.14.3 HTML-Tags in Dokumentationskommentaren
|  |  | 6.14.4 Generierte Dateien
|  |  | 6.14.5 Dokumentationskommentare im Überblick
|  |  | 6.14.6 JavaDoc und Doclets
|  |  | 6.14.7 Veraltete (deprecated) Klassen, Konstruktoren und Methoden
## 6.13 Die Spezial-Oberklasse Enum Jedes Aufzählungsobjekt erbt von der Spezialklasse Enum. Nehmen wir erneut die Wochentage:
    public enum Weekday
    {
      MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
    }
Der Compiler übersetzt dies in eine Klasse, die etwa so aussieht:
    class Weekday extends Enum
    {
      public static final Weekday MONDAY  = new Weekday( "MONDAY",   0 );
      public static final Weekday TUESDAY = new Weekday( "TUESDAY ", 1 );
      ...

      private Weekday( String s, int i )
      {
        super( s, i );
      }
### 6.13.1 Methoden auf Enum-Objekten Von der Oberklasse Enum erbt jede Aufzählung einen geschützten parametrisierten Konstruktor, der den Namen der Konstante sowie einen assoziierten Zähler erwartet. So wird aus jedem Element der Aufzählung ein Objekt vom Basistyp Enum, das einen Namen und eine ID, die so genannte Ordinalzahl, speichert. Natürlich kann es auch nach seinem Namen und Zähler gefragt werden. Hier klicken, um das Bild zu vergrößern
    abstract class Enum<E extends Enum<E>>
    implements Comparable<E>, Serializable
final int ordinal() Liefert die zur Konstante gehörige ID. Im Allgemeinen ist diese Ordinalzahl nicht wichtig, aber besondere Datenstrukturen wie EnumSet oder EnumMap nutzen diese eindeutige ID. Die Reihenfolge der Zahlen ist durch die Reihenfolge der Angabe gegeben. final String name() Liefert den Namen der Konstante. Da die Methode – wie viele andere der Klasse – final ist, lässt sich der Name nicht ändern. String toString() Liefert den Namen der Konstante. Die Methode ruft standardisiert name() auf, weil sie aber nicht final ist, kann sie überschrieben werden. final int compareTo( E o ) Da die Enum-Klasse die Schnittstelle Comparable implementiert, gibt es auch die Funktion compareTo(). Sie vergleicht anhand der Ordinalzahlen. Vergleiche sind nur innerhalb eines Enum-Typs erlaubt. static <T extends Enum<T>> T valueOf( Class<T> enumType, String s ) Ermöglicht das Suchen von Enum-Objekten zu einem Konstantennamen und einer Enum-Klasse. Sie liefert das enum-Objekt für die gegebene Zeichenfolge oder löst eine Illegal-ArgumentException aus, wenn dem String kein enum-Objekt zuzuordnen ist. final Class<E> getDeclaringClass() Liefert das Class-Objekt zu einem konkreten Enum.
Beispiel Eine Funktion, die die Ordinalzahl eines Elements der Aufzählung gibt, oder –1, wenn die Konstante nicht existiert: Listing 6.107 WeekdayDemo.java, getOrdinal()
    static int getOrdinal( String name )
    {
      try {
        return Weekday.valueOf( name ).ordinal();
      }
      catch ( IllegalArgumentException e ) {
        return –1;
      }
    }
Damit liefert getOrdinal("MONDAY") == 0 und getOrdinal("FEIERTAG") == –1.
Hinweis Die Methode getDeclaringClass() liefert auf der Enum-Klasse null und nur auf den Elementen der Aufzählung einen sinnvollen Wert:
    System.out.println( Weekday.class.getDeclaringClass() );  // null
    System.out.println( Weekday.MONDAY.getDeclaringClass() );
    // class com.tutego.weekday.Weekday
#### Alle Konstanten der Klasse aufzählen Eine besondere statische Funktion auf jeder Enum-Klasse ist values(). Sie liefert ein Feld von Enum-Objekten. Nützlich ist das für das erweiterte for, das alle Konstanten aufzählen soll. Eine Alternative mit dem gleichen Ergebnis ist die Class-Methode getEnumConstants(). Listing 6.108 WeekdayDemo.java, Ausschnitt main()
    for ( Weekday day : Weekday.values() )  // oder Weekday.class.getEnumConstants()
      System.out.println( "Name=" + day.name() );
Liefert Zeilen mit Name=MONDAY, ... Auch toString() ist so implementiert, dass es den Namen liefert. Das Ergebnis ist also mit name() identisch:
    System.out.println( Weekday.FRIDAY );                 // FRIDAY
#### Vergleiche mit == Wie die Umsetzung der Enum-Typen zeigt, wird für jede Konstante ein Objekt konstruiert, und das sind Singletons. Der Zugriff auf dieses Objekt ist wie ein Zugriff auf eine statische Variable. Der Vergleich zweier Konstanten läuft somit auf den Vergleich von statischen Referenzvariablen hinaus, wofür der Vergleich mit == richtig ist. Ein equals() ist nicht nötig. Die Oberklasse Enum überschreibt equals() mit der Logik wie in Object – also den Vergleich der Referenzen –, um sie final zu markieren. Die Methode clone() ist final protected und kann also weder überschrieben noch von außen aufgerufen werden. So kann es keine Kopien der Enum-Objekte geben, die die Identität gefährden könnten. Nichtsdestotrotz darf clone() aber die this-Referenz liefern. ### 6.13.2 enum mit eigenen Konstruktoren und Methoden Da eine enum-Klasse mit der Klassendeklaration verwandt ist, kann sie ebenso Attribute und Methoden deklarieren: Listing 6.109 Country.java
    import java.util.Locale;

    public enum Country
    {
      GERMANY( Locale.GERMANY ), UK( Locale.UK ), CHINA( Locale.CHINA );

      private Locale country;

      private Country( Locale country )
      {
        this.country = country;
      }

      public String getISO3Country()
      {
        return country.getISO3Country();
      }
    }
Bei der Deklaration der Konstanten wird in runden Klammern ein Argument für den Konstruktor aufgerufen. Der speichert das zugehörige Locale-Objekt in der internen Variable country. Zusätzlich deklariert das Beispiel eine Methode getISO3Country(), die auf den Enum-Objekten aufgerufen werden kann.
    System.out.println( Country.CHINA.getISO3Country() ); // CHN
Da switch auf enum erlaubt ist, können wir schreiben: Listing 6.110 CountryEnumDemo.java, Ausschnitt
    Country meinLand = Country.GERMANY;

    switch ( meinLand )
    {
      case GERMANY:
        System.out.println( "Aha. Ein Krauti" );         // Aha. Ein Krauti
        System.out.println( meinLand.getISO3Country() ); // DEU
        break;
      default:      System.out.println( "Anderes Land" );
    }
#### Enum mit überschriebenen Methoden Würden wir für Monate eine Aufzählung Month deklarieren und eine Methode getDays() für die Anzahl Tage im Monat anbieten, dann hätten wir ein Problem mit dem Februar, weil die Anzahl der Tage bei einem Schaltjahr nicht die gleiche ist. In getDays() würden wir eine Berechnung abhängig vom Jahr benötigen. Im ersten Schritt fügen wir der Aufzählung eine Funktion getDays(int) hinzu, die die Jahreszahl akzeptiert. Die Methode ist zunächst genauso ohne Parameter implementiert wie getDays(). Java erlaubt uns aber, hinter den Konstantennamen eine Art innere anonyme Klasse zu hängen, die dann Methoden überschreiben kann. Listing 6.111 Month.java
    public enum Month
    {
      JAN(31), FEB(28)
      {
        @Override public int getDays( int y )
        {
          return (y & 3) == 0 ? 29 : 28;
        }
      },
      MAR(31), APR(30), MAY(31), JUN(30),
      JUL(31), AUG(31), SEP(30), OCT(31), NOV(30), DEC(31);

      private int days;

      private Month( int days )
      {
        this.days = days;
      }

      public int getDays()
      {
        return days;
      }

      public int getDays( int year )
      {
        return days;
      }
    }
In der Angabe vom Februar überschreiben wir das Verhalten von getDays(int), sodass korrekt ausgegeben wird:
    System.out.println( Month.FEB.getDays(2000) );    // 29
    System.out.println( Month.FEB.getDays(2001) );    // 28
In der Klassendatei bildet der Java-Compiler das wie folgt ab: Es gibt einen Konstruktor mit drei Parametern der Enum-Namen, der Ordinalzahl und der Zahl der Tage:
    Month( String s, int i, int j )
    {
      super( s, i );
      days = j;
    }
Für alle Monate bis auf den Februar kommt dieser Konstruktor zum Zuge. Für den Februar gibt es eine innere anonyme Klasse, die getDays() überschreibt, um das Jahr in die Berechnung mit einzubeziehen. Die übergebene 28 würde eigentlich im Konstruktor nicht mehr gebraucht werden.
    public static final Month JAN = new Month( "JAN", 0, 31 );
    public static final Month FEB = new Month( "FEB", 1, 28 ) {
      private static final _cls1 ENUM$VALUES[];
      public int getDays( int y ) { return (y & 3) != 0 ? 28 : 29; }
    };
    public static final Month MAR = new Month( "MAR", 2, 31 );
    ...
### 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