Persönlich sind die sogenannten Klassen in der Programmierung das gleiche Konzept wie die Klassen in der realen Welt, die Objekte klassifizieren, sie werden jedoch in der Programmierung geliehen. Klassen repräsentieren Dinge, die eine Reihe von Gemeinsamkeiten und dieselben Operationen oder Aktionen haben, bei denen es sich um abstrakte Datentypen in der Programmierung handelt. Jede spezifische Person (in der realen Welt) und Instanzvariablen (für die Programmierung) sind Objekte.
Eine Klasse ist eine Darstellung gemeinsamer Merkmale (Attribute und Operationen) bestimmter Objekte in der realen Welt, und ein Objekt ist eine Instanz einer Klasse.
Klassenattribute: Ist die Abkürzung der statischen Attribute einer Klasse, die sich auf verschiedene Daten bezieht, die in der Klasse enthalten sind, z. B. Variablen oder andere Klassenobjekte;
Ein Klassendienst: wird als Mitgliedsfunktion oder Methode bezeichnet.
¨
Die Definitionsform einer Klasse in Java lautet wie folgt:
[Modifikator] Klasse Klassenname [Erweitert übergeordnete Klasse] [Implementiert Schnittstellenname] {Klassenmitglied Variable Deklaration Class -Methode Deklaration}Sprechen wir im Detail über jeden Teil davon:
Vor dem Schlüsselwort der Klasse sind die Klassenmodifikatoren im Allgemeinen in drei Typen unterteilt: Zugriff auf Modifikatoren öffentliche Klasse, endgültiger Modifikator (endgültiger Klassenspezifizierer) und abstrakter Modifikator (Abstract -Klassenspezifizier)
Unter ihnen kann der Erlaubnismodifikator nur öffentlich oder standardmäßig sein (d. H. Leer, nichts, was darauf hinweist, dass er als freundlich definiert ist), und öffentlich bedeutet, dass die Klasse verwendet werden kann und überall (sofern das Programm den Ort der Klasse finden kann), sei es im selben Paket oder in verschiedenen Paketen. Beachten Sie, dass sich dies von C ++ unterscheidet. C ++ verfügt nicht über einen Modifikator, um das Zugriffsrechte auf den Unterrichtsrechten einzuschränken, sondern Zugriffsrechte für Erbschaftsbeziehungen zwischen Klassen. Darüber hinaus haben sie alle Zugriffsrechte für Klassenattribute und -methoden. Die Standard -Zugriffsberechtigung (d. H. Als freundlich definiert) bedeutet, dass sie nur von Klassen im selben Paket verwiesen und nicht durch Klassen in anderen Paketen zugegriffen werden kann, selbst wenn sie importiert werden.
Es wird auch später erwähnt: Wenn der Standardmodifikator eines Klassenattributs und einer Methode verwendet wird, wird auch ausgedrückt, dass nur von Klassen im selben Paket verwiesen und zugegriffen werden kann.
In Java ist nicht mehrerer Vererbung zulässig, was sich von C ++ unterscheidet. Um diesen Mangel auszugleichen, hat Java das Konzept der Schnittstelle vorgestellt.
In der Definition der obigen Klasse enthält der Klassenkörper hauptsächlich den spezifischen Inhalt der Klasse, einschließlich der Attribute der Klasse und der Methoden der Klasse. Die Eigenschaften einer Klasse können einfache Variablen oder Instanzen bestimmter Klassen sein. Wenn es sich um eine Instanz einer Klasse handelt, kann sie wie folgt definiert werden:
[Modifier] Klassenname Objektname = neuer Klassenname (Parameterliste);
Wenn Sie Objekte und komplexe Variablen deklarieren, können Sie die Erstellung während der Erklärungen nicht verwenden, können jedoch in zukünftigen Konstruktoren erstellt werden.
Die in einer Klasse definierten Methoden spielen normalerweise zwei Rollen: Eine besteht darin, verschiedene Operationen um die Attribute der Klasse auszuführen; Das andere besteht darin, Datenaustausch, Nachrichtenzustellung und andere Vorgänge mit anderen Klassen oder Objekten durchzuführen.
Die Syntax für die Deklaration von Methoden in Java lautet wie folgt:
[Modifikator] Rückgabewerttypmethodenname (Parameterliste) löst Ausnahmename 1, Ausnahmenname 2,… {Methode Körper: Lokale Variablendeklaration; Anweisung Sequenz;}Klassenmethoden, auch als Mitgliedsfunktionen bezeichnet, werden verwendet, um Operationen in Klassenattributen anzugeben und interne Funktionen von Klassen zu implementieren. Sie sind auch ein wichtiges Fenster für Klassen, um mit der Außenwelt zu interagieren.
Java-Programmierer konzentrieren sich auf das Erstellen von benutzerdefinierten Typen, die als Klassen bezeichnet werden. Klassen werden auch als Programmierer definierte Typen bezeichnet. Jede Klasse enthält Daten und eine Reihe von Methoden zum Manipulieren von Daten. Der Datenteil in der Klasse heißt Instanzvariablen. Eine Instanz eines benutzerdefinierten Typs (d. H. Eine Klasse) wird als Objekt bezeichnet.
Ein Objekt ist eine Instanz einer Klasse. Eine Klasse ist eine Abstraktion desselben Objekttyps und eine Vorlage zum Erstellen eines Objekts. Das Erstellen eines Objekts im Programm öffnet einen Speicherplatz, einschließlich der Eigenschaften und Methoden des Objekts. Erstellen Sie ein Objekt mit dem Keyword -Operator neu.
Konstruktor (kann mit C ++ verglichen werden, was fast gleich ist wie C ++)
Erstellen Sie Ihren eigenen Konstruktor
• Der Name des Konstruktors und der Name der Klasse sind gleich. Bei der Erstellung eines Objekts der Mitarbeiterklasse wird dieser Konstruktor gestartet und dem Instanzfeld wird ein Anfangswert zugewiesen. In Java sind Definition und Initialisierung einheitlich - beide sind unverzichtbar.
Zum Beispiel beim Erstellen einer Instanz der Mitarbeiterklasse mit dem folgenden Code,
New Employee ("James Bond", 100000.1950,1,1);
Die Eigenschaften des Konstruktors sind:
(1) Der Konstruktor und die Klasse haben den gleichen Namen.
(2) Eine Klasse kann mehrere Konstruktoren haben.
(3) Der Konstruktor kann 0, 1 oder mehr Parameter haben.
(4) Der Konstruktor hat keinen Rückgabewert.
(5) Der Konstruktor wird immer mit dem neuen Bediener aufgerufen.
Die Rolle des Konstruktors
(1) Objektinitialisierung
(2) Einführung mehr Flexibilität (variable Zuordnung oder komplexere Operationen)
(3) Der Konstruktor kann in Java nicht definiert werden
Ein Konstruktor kann in Java nicht definiert werden, und das System generiert automatisch einen Standardkonstruktor für das System. Der Name dieses Konstruktors entspricht dem Klassennamen, er hat keine formalen Parameter und führt keine Operationen aus.
Methodenübersicht
Ein Java -Programm besteht aus Klassendefinitionen und die Klasse hat zwei Teile: Eigenschaften und Methoden. Was ist eine Attributbeschreibungsklasse und was ist eine Methode Beschreibung Klasse? Jedes Objekt verfügt über einen unabhängigen Speicher, um seine Eigenschaften zu speichern. Alle Objekte der Klasse teilen die im Speicher gespeicherte Methode.
Mit anderen Worten: Methoden sind die Hauptkomponente der Klasse. In einer Klasse spiegelt sich die Rolle eines Programms in der Methode wider.
Die Methode besteht darin, eine benannte Unterroutine durch Java zu erstellen. Eine Hauptmethode und mehrere Sub-Methoden. Die Hauptmethode ruft andere Methoden auf, und andere Methoden können ebenfalls aufgerufen werden, und dieselbe Methode kann jederzeit von einer oder mehreren Methoden aufgerufen werden.
Das Definieren einer anderen Methode in einer Methode erzeugt einen Syntaxfehler.
(1) Es ist am besten, lokale Variablen "Masken" -Sinstanzvariablen zu vermeiden. Dies kann ohne die gleichnamige Bezeichnung in einer Klasse erfolgen. Parameter in Methodenaufrufen werden zum Übergeben numerischer Werte und Referenzen verwendet, und Methoden können auch verschachtelt und rekursiv aufgerufen werden.
(2) Wenn in der Method-Körperschaft ein Nicht-Void-Rückgabewerttyp angegeben ist, muss die Methode eine Rückgabeerklärung enthalten, um sicherzustellen, dass in jedem Fall ein Rückgabewert vorliegt, und die Rückgabeerklärung kann kein Ausdruck folgen.
Die Grundstruktur von Java -Programmen lautet wie folgt:
Java -Klassenbibliothek vorstellen; Definieren Sie die Benutzerklasse 1 {Definieren Sie mehrere Variablen oder Objekte der Klasse 1: Definieren Sie die Methode 1 der Klasse 1; Methode 2 der Klasse 1 definieren; … Definieren Sie die Methode M1 der Klasse 1; } Definieren Sie die Benutzerklasse 2 {Definieren Sie mehrere Variablen oder Objekte der Klasse 2: Verfahren 1 der Klasse 2; Methode 2 der Klasse 2 definieren; … Definieren Sie die Methode M2 von Klasse 2}Java hat das Konzept des "Zugriffskontrollmodifikators" eingeführt, mit dem Bibliotheksersteller erklären können, was von Client -Programmierern verwendet werden kann und was nicht verwendet werden kann.
Diese Ebene der Zugriffskontrolle liegt zwischen dem Bereich des "maximalen Zugriffs" und "Mindestzugriff", einschließlich: öffentlich, "Standard" (kein Schlüsselwort), geschützt und privat. Die folgende Liste erläutert die Bedeutung von Zugriffskontrollmodifikatoren:
Öffentlicher Zugangskontrollcharakter
Für Klassen:
Es gibt nur einen Zugriffscontroller für eine Klasse in Java: öffentlich, das heißt, öffentlich. Eine Klasse wird als öffentliche Klasse deklariert, was darauf hinweist, dass sie von allen anderen Klassen zugegriffen und verwiesen werden kann. Zugang und Referenz hier beziehen sich darauf, dass die Klasse als Ganzes sichtbar und verwendbar ist. Andere Teile des Programms können Objekte dieser Klasse erstellen, auf Mitgliedsvariablen zugreifen, die in der Klasse sichtbar sind, und seine sichtbaren Methoden aufrufen.
Eine Klasse ist für andere Teile des Programms als Ganzes sichtbar und zeigt nicht, dass alle Eigenschaften und Methoden in der Klasse auch für andere Teile des Programms sichtbar sind. Ersteres ist nur eine notwendige Bedingung für letztere. Ob auf die Eigenschaften und Methoden der Klasse von allen anderen Klassen zugegriffen werden können, hängt von den Zugriffskontrollzeichen dieser Eigenschaften und Methoden ab.
Wird für Eigenschaften in der Klasse verwendet:
Die mit der Öffentlichkeit geänderten In-Class-Attribute werden als öffentliche Attribute bezeichnet. Wenn diese Klasse eine öffentliche Klasse ist, kann sie von allen anderen Klassen zugreifen.
Standardzugriffskontrolle
Für Klassen verwendet
Wenn eine Klasse keine Zugriffskontrollzeichen hat, bedeutet dies, dass die Standardmerkmale der Zugriffskontrolle aufweist. Diese Standardzugriffskontrolle sieht vor, dass die Klasse nur durch Klassen im selben Paket zugegriffen und nicht von Klassen in anderen Paketen verwendet werden kann. Diese Zugriffsfunktion wird als Paket Accessibility bezeichnet. Durch die Erklärung der Zugriffskontrollzeichen der Klasse kann die gesamte Programmstruktur klar und streng sein, wodurch die möglichen Interferenz und Fehler zwischen den Klassen verringert werden.
Wird für Klassenattribute verwendet
Wenn die Eigenschaften und Methoden innerhalb der Klasse nicht durch Zugriffskontrollsymbole begrenzt sind, weisen sie auch an, dass es sich um eine Paket -Barrierefreiheit handelt.
3 Private Access Control Charakter privat
Attribute oder Methoden, die mit privaten geändert werden, können nur von der Klasse selbst zugegriffen und geändert werden und können nicht von einer anderen Klasse, einschließlich Unterklassen der Klasse, erhalten und verwiesen werden.
1). Private Daten haben beispielsweise drei Instanzfelder, die Daten enthalten, die in einer Instanz der Mitarbeiterklasse betrieben werden.
privater Zeichenfolge Name;
privates Doppelgehalt;
privates Datum Hireday;
Das private Schlüsselwort wird verwendet, um sicherzustellen, dass diese Instanzfelder nur von der Mitarbeiterklasse selbst zugegriffen werden können.
2) .PRivate Methode Bei der Implementierung der Klasse machen wir alle Datenfelder privat, da öffentliche Daten gefährlich sind. Wie ist die Situation mit der Methode? Obwohl die meisten Methoden öffentlich sind, werden auch häufig private Methoden angewendet. Diese Methoden können nur nach derselben Methode getrennt werden.
Kurz gesagt, die private Methode kann in den folgenden Fällen ausgewählt werden:
(1) Die Methoden, die nicht mit dem Benutzer der Klasse zusammenhängen.
(2) Die Methoden, die nicht leicht zu pflegen sind, wenn die Implementierung der Klasse geändert wird.
Geschützter Zugriffskontrollzeichen geschützt
Mit geschützte Mitgliedsvariablen können durch drei Typen verwiesen werden: die Klasse selbst, andere Klassen im selben Paket wie sie und Unterklassen der Klasse in anderen Paketen. Der Hauptzweck der Verwendung des geschützten Modifikators besteht darin, die Unterklassen in anderen Paketen zu ermöglichen, auf bestimmte Eigenschaften der übergeordneten Klasse zuzugreifen.
Das geschützte Keyword führt uns in ein Konzept mit dem Namen "Vererbung" vor, das auf vorhandenen Klassen basiert und neue Mitglieder dazu hinzufügt, ohne vorhandene Klassen zu beeinflussen. Wir nennen diese vorhandene Klasse "Basisklasse" oder "Basisklasse". Es kann auch das Verhalten bestehender Mitglieder dieser Klasse ändern. Für die Vererbung einer vorhandenen Klasse sagen wir, dass unsere neue Klasse die vorhandene Klasse "erweitert"
Privat geschützter Zugangskontrollcharakter privat geschützt
Privat und geschützt werden nacheinander verwendet, um ein vollständiges Zugriffskontrollzeichen zu bilden: Private Protection Access Control -Zeichen. Mit private geschützte Mitgliedervariablen können von zwei Klassen zugegriffen und verwiesen werden, eine ist die Klasse selbst, und das andere ist alle Unterklassen der Klasse, unabhängig davon, ob diese Unterklassen im selben Paket wie die Klasse oder in anderen Paketen enthalten sind.
Im Vergleich zu geschützten privaten geschützten Modifikator schließt sich Nicht-Unterschlüsse innerhalb desselben Pakets aus dem zugänglichen Bereich aus, wodurch die Mitgliedervariablen für Klassen mit expliziten Erbbeziehungen und nicht paketen, die lose gruppiert werden, proprietärer werden.
Statischer Modifikator
Statisch wird als statischer Modifikator bezeichnet, der Eigenschaften und Methoden in einer Klasse verändert.
Mit dem statischen Schlüsselwort kann zwei Anforderungen erfüllen:
(1) Eine Situation ist, dass Sie nur einen Speicherbereich verwenden möchten, um bestimmte Daten zu speichern - unabhängig davon, wie viele Objekte Sie erstellen möchten, erstellen Sie überhaupt keine Objekte. Die durch statischen modifizierten Attribute werden als statische Eigenschaften bezeichnet, und eines der wichtigsten Merkmale dieser Art von Attribut ist, dass sie Attribute einer Klasse sind, nicht spezifische Objekte einer Klasse. Mit anderen Worten, für ein bestimmtes Objekt dieser Klasse ist eine statische Eigenschaft eine gemeinsame Speichereinheit. Wenn ein Objekt einer Klasse darauf zugreift, erhält es den gleichen numerischen Wert. Wenn ein Objekt einer Klasse es ändert, wird auch Operationen auf derselben Speichereinheit ausgeführt.
(2) Eine andere Situation ist, dass wir eine spezielle Methode benötigen, die keinem Objekt dieser Klasse zugeordnet ist. Das heißt, selbst wenn das Objekt nicht erstellt wird, wird eine Methode, die von der Klasse direkt aufgerufen werden kann, benötigt.
Ein wichtiger Zweck von Static ist es, uns zu helfen, diese Methode zu nennen, ohne ein Objekt erstellen zu müssen.
Statische Konstanten
Statische Variablen sind selten. Statische Konstanten sind jedoch häufig. Zum Beispiel wird eine statische Konstante in der Mathematikklasse definiert:
Mathematik der öffentlichen Klasse
{… Public static Final Double Pi = 3.1.4159265358979323846;…} Eine statische Methode erklärt, dass eine statische Methode mindestens drei Bedeutungen hat:
(1) Bei Verwendung dieser Methode sollte der Klassenname eher als Präfix als als bestimmter Objektnamen verwendet werden.
(2) Nichtstatische Methoden sind Methoden, die zu einem Objekt gehören. Wenn dieses Objekt erstellt wird, hat die Methode des Objekts ein eigenes Code -Segment im Speicher. Während die statische Methode zur gesamten Klasse gehört und ihr Codesegment im Speicher gemäß der Definition der Klasse zugewiesen und geladen wird und keinem Objekt ausschließlich ausgeht;
(3) Da die statische Methode zur gesamten Klasse gehört, kann sie Mitgliedsvariablen, die zu einem bestimmten Objekt gehören, nicht manipulieren und verarbeiten, aber nur Mitgliedsvariablen zur gesamten Klasse verarbeiten können.
5 Hauptmethode
Die Hauptmethode wendet keine Operationen auf ein Objekt an. In der Tat existieren noch keine Objekte, wenn das Programm ausgeführt wird. Die statische Methode wird ausgeführt und die vom Programm erforderlichen Objekte werden konstruiert.
Es fordert, dass jede Klasse eine Hauptmethode haben kann. Dies ist ein sehr bequemer Trick für Unit -Testkurse.
Abstract ist ein abstrakter Modifikator, mit dem Klassen oder Methoden geändert werden können.
Zusammenfassung Klasse
Wenn eine Klasse als abstrakt deklariert wird, wird diese Klasse als abstrakte Klasse bezeichnet. Die sogenannte abstrakte Klasse ist eine Klasse ohne konkrete Instanzobjekte.
Um dieses Problem anzugehen, bietet Java einen Mechanismus, der als "abstrakte Methode" bezeichnet wird. Es gehört zu einer unvollständigen Methode mit nur einer Deklaration und hat keine Methodenkörper. Hier ist die Syntax, die beim Deklarieren abstrakter Methoden verwendet wird:
abstrakte Leere X ();
Zusammenfassung Methoden
Als Klassenmethodenmodifikator deklariert Abstract eine abstrakte Methode, die nur Methodenüberschriften aufweist, aber keine spezifische Methodenkörper- und Betriebsimplementierung.
Es ist ersichtlich, dass die abstrakte Methode nur die Erklärung des Method -Headers aufweist und ein Semikolon verwendet wird, um die Definition der Methodenkörper zu ersetzen: Wie für die spezifische Implementierung der Methodenkörper wird sie in ihren jeweiligen Klassendefinitionen durch verschiedene Unterklassen der aktuellen Klasse abgeschlossen.
Es ist zu beachten, dass alle abstrakten Methoden in abstrakten Klassen existieren müssen
Mitte.
Neben abstrakten Methoden können abstrakte Klassen auch konkrete Daten und Methoden aufweisen.
Abstrakte Methoden sind sehr wichtige Konzepte in der Java -Programmiersprache. Sie werden es in der Schnittstelle auf viele Arten verwenden.
Hinweis: Hier müssen wir die Schnittstelle vergleichen und auswendig lernen. Die Methoden in der Schnittstelle sind alle abstrakten Methoden. Natürlich gibt es auch Attribute in der Schnittstelle, und ihre spezifischen Eigenschaften werden später ausführlich beschrieben.
Endklasse, Endattribut, endgültige Methode und Finalizer (es gibt keinen endgültigen Modifikator in C ++)
Finale ist der endgültige Modifikator, der Klassen, Eigenschaften und Methoden ändert. Darüber hinaus sind die Schlüsselwörter des Terminals dem endgültigen sehr ähnlich und werden gemeinsam eingeführt
Letzte Klasse
Wenn eine Klasse endgültig erklärt wird, bedeutet dies, dass sie keine neuen Unterklassen ableiten kann und als Elternklasse nicht vererbt werden kann. Daher kann eine Klasse nicht sowohl abstrakt als auch endgültig deklariert werden.
Klassen, die als endgültig definiert sind, sind in der Regel einige Klassen mit speziellen Funktionen, die zur Ausführung von Standardfunktionen verwendet werden. Wenn Sie eine Klasse als endgültig definieren, können Sie ihre Inhalte, Attribute und Funktionen beheben und eine stabile Zuordnungsbeziehung mit ihrem Klassennamen bilden, wodurch die implementierten Funktionen, die sich auf diese Klasse beziehen, korrekt sind.
Letzte Attribute
Viele Programmiersprachen haben ihre eigenen Möglichkeiten, dem Compiler mitzuteilen, dass bestimmte Daten eine "Konstante" sind. Konstanten werden hauptsächlich in den folgenden zwei Aspekten verwendet:
(1) Kompilierungsperiode konstant, es wird sich niemals ändern;
(2) Wir möchten keinen Wert, der während der Laufzeit initialisiert wurde, um sich zu ändern.
Ein Instanzfeld kann als endgültig definiert werden (kann nicht geändert werden). Dieses Feld muss initialisiert werden, wenn das Objekt konstruiert ist. Das heißt, es muss sichergestellt werden, dass der Wert vor dem Ende jedes Konstruktors festgelegt wurde. Der Wert des Feldes kann in Zukunft nicht geändert werden
Letzte Methode
Der Grund für die Verwendung der endgültigen Methode kann aus zwei Gründen auf Überlegungen zurückzuführen sein.
Die erste besteht darin, die Methode zu "sperren", um zu verhindern, dass eine Erbschaftsklasse ihre ursprüngliche Bedeutung ändert. Bei der Gestaltung eines Programms kann diese Praxis durchgeführt werden, wenn Sie möchten, dass das Verhalten einer Methode während der Erbschaft unverändert bleibt und nicht überschrieben oder umgeschrieben werden kann.
Der zweite Grund für die Einführung der endgültigen Methode ist die Effizienz der Programmausführung
Terminator
Die Funktion des Terminators ist eine Methode, die beim Abrufen von Objekten ausgeführt wird. Ähnlich wie bei der Methode, die Konstruktoren beim Erstellen von Objekten ausgeführt werden.
Beispiel
protected voidfinalize () {System.out.println (""); }Andere Modifikatoren
flüchtig
Wenn ein Attribut durch ein flüchtiges geändert wird, bedeutet dies, dass dieses Attribut gleichzeitig durch mehrere Threads gesteuert und geändert werden kann.
synchronisiert
Hauptsächlich zur Gewindesynchronisation verwendet
einheimisch
Dies bedeutet, dass die Methode nicht in Java -Sprache geschrieben ist (sie ist in C, C ++ und anderen Sprachen geschrieben)
Einige Informationen online gefunden: - interne Kategorie
Einfach ausgedrückt, interne Klassen sind Klassen in Klassen, zum Beispiel:
Klasse A {private int i; private void m () {} Klasse B {mm (int j) {i = j; m ();}}}Hier ist B die interne Klasse von A, die durch bequemen Zugang zu privaten Methoden und Eigenschaften in externen Klassen gekennzeichnet ist. Zum Beispiel kann B hier direkt auf private Eigenschaften I und private Methoden M () in A. zugreifen
Die wichtigsten Merkmale der objektorientierten Programmierung sind die Einkapselung (auch Abstraktion genannt), Vererbung und Polymorphismus. Als objektorientierte Programmiersprache hat Java in dieser Hinsicht seine eigenen Vorteile:
"Die Vererbung ist eine Form der Wiederverwendung von Software, die bei der Reduzierung der Softwarekomplexität wirksam ist. Die Vererbung ist auch ein Merkmal einer objektorientierten Programmiersprache. Sprachen, die Objekte annehmen, aber keine Vererbung sind, sind objektbasierte Sprachen, aber keine objektorientierten Sprachen. Dies ist der Unterschied zwischen beiden."
Die Vererbungsbeziehung zwischen Klassen ist eine direkte Simulation genetischer Beziehungen in der realen Welt. Es repräsentiert die intrinsische Verbindung zwischen Klassen und die Freigabe von Attributen und Operationen, dh Unterklassen können bestimmten Merkmalen der übergeordneten Klasse (ererbte Klasse) folgen. Natürlich können Unterklassen auch ihre eigenen unabhängigen Eigenschaften und Operationen haben
Vererbung ist eine Form der Software -Wiederverwendung. Neue Klassen werden durch vorhandene Klassen generiert, und neue Attribute und Verhaltensweisen werden hinzugefügt, indem ihre Eigenschaften und Verhaltensweisen beibehalten und die Leistung gemäß den Anforderungen der neuen Klasse geändert werden. Wenn eine untergeordnete Klasse nur von einer übergeordneten Klasse erbt, wird sie als Einzelvererbung bezeichnet. Wenn eine untergeordnete Klasse von mehr als einer übergeordneten Klasse erbt, wird sie als Multi-Ineritanz bezeichnet. Beachten Sie, dass Java nicht mehrfacher Vererbung unterstützt, sondern das Konzept der "Schnittstelle" unterstützt. Mit Schnittstellen ermöglichen es Java, viele Vorteile von mehreren Erbschaft zu erhalten und entsprechende Nachteile aufzugeben. HINWEIS: C ++ unterstützt mehrere Vererbung
Definition der Vererbungsbeziehung:
[Modifikator] Klasse Unterklasse erweitert den Namen der Elternklasse, Name der Elternklasse 2
Der folgende übergeordnete Unterrichtsname erstreckt sich
Das Schlüsselwort wird verwendet, um anzugeben, welche Unterklasse der aktuellen Klasse bereits vorhanden ist, und es gibt eine Erbschaftsbeziehung.
Definieren Sie zwei Unterklassen der Mitarbeiterklasse -Mitarbeiter:
Allgemeine Mitarbeiterkategorie: Common Employeee
Vorgesetzte Kategorie: Manager Mitarbeiter
Es gibt zwei Hauptaspekte der Unterklasse -Vererbung aus der Elternklasse:
(1) Vererbung von Attributen. Zum Beispiel ist ein Unternehmen eine Elternklasse, und ein Unternehmen hat einen Namen, eine Adresse, einen Manager, einen Mitarbeiter usw., die alles strukturelle Aspekte sind.
(2) Vererbung der Methode. Eine übergeordnete Klasse definiert mehrere Operationen, z.
classcommonOlepleponextendends Mitarbeiter // Unterklasse 1: {intm_managerno; // Klassenattribut m_managerno, die Mitarbeiter -Boss -Nummer} ClassManager -Employeextendends Mitarbeiter // Unterklasse 2: {intm_secretaryno; // Klassenattribut m_secretaryno, darstellen, Sekretärnummer} Attributvererbung und Versteck
Obwohl die Mitarbeiterklasse eine übergeordnete Klasse ist, bedeutet dies nicht, dass sie mehr Funktionen hat, nur weil es sich um eine Elternklasse handelt. Im Gegenteil, Unteranaloge haben mehr Funktionen als ihre Elternklassen. Da die Unterklasse eine Erweiterung der übergeordneten Klasse ist, werden die Attribute und Methoden, die die übergeordnete Klasse nicht hat, hinzugefügt (1) Die Unterklasse kann nicht auf das private Mitglied der übergeordneten Klasse zugreifen, aber die Unterklasse kann auf die Öffentlichkeit ihrer übergeordneten Klasse zugreifen.
(2) Der geschützte Zugang ist ein schützender Zwischenstufe zwischen öffentlichem und privatem Zugang.
(3) Da die ererbten Elternklassenmitglieder in der Unterklasse -Erklärung nicht aufgeführt sind, existieren diese Mitglieder in der Unterklasse.
Hier müssen wir zwischen Vererbung, Überschreibung und Überlastung, mehreren verwirrenden Konzepten unterscheiden:
Nur auf der konzeptionellen Ebene der Methode können diese drei Konzepte leicht verwechselt werden:
Vererbung der Methode
Für Unterklassenobjekte können Methoden aus der übergeordneten Klasse verwendet werden. Auch wenn diese Methoden in der Unterklasse nicht klar definiert sind, werden sie automatisch von der übergeordneten Klasse geerbt.
Methodenabdeckung
Vermittlung von Methoden bezieht sich auf: eine Methode, die eine Methode mit demselben Namen definiert, um die übergeordnete Klasse zu überschreiben, bei der eine Implementierung der polymorphen Technologie ist. Wenn die übergeordnete Klassenmethode in der untergeordneten Klasse überschrieben wird, ist es normalerweise die Version der untergeordneten Klassen, die die Version der Elternklassen aufruft und zusätzliche Arbeiten ausführt.
Es gibt viele Dinge zu beachten. Hier erwähne ich dies hauptsächlich und super. Es gibt dies in C ++ (und das Konzept ähnelt dem in Java), aber es gibt keinen Super.
Dies repräsentiert das aktuelle Objekt selbst und repräsentiert einen Verweis auf das aktuelle Objekt. Es kann als ein anderer Name des Objekts verstanden werden. Auf diese Weise können Sie die Methoden und Eigenschaften des aktuellen Objekts aufrufen.
Zum Beispiel: this.getName () und getName () sind in der Klasse gleich.
Super repräsentiert das Objekt der direkten übergeordneten Klasse des aktuellen Objekts und ist die Überlastung der Referenzmethode des übergeordneten Klassenobjekts des aktuellen Objekts.
Definition von Überlast: Die Methode kann mit demselben Methodennamen definiert werden, aber unterschiedliche Parametertabellen (die Nummer, der Typ oder die Reihenfolge der Parameter in der Parametertabelle haben unterschiedliche Werte), die als Methodenüberladung bezeichnet werden.
• Überladung: Überladen tritt auf, wenn mehrere Methoden denselben Namen haben und unterschiedliche Parameter enthalten. Der Compiler muss auswählen, welche Methode aufgerufen werden soll. Es wird die richtige Methode ausgewählt, indem die Parametertypen in verschiedenen Methodenkopfzeilen mit den in bestimmten Methodenaufrufen verwendeten Wertearten verglichen werden.
Der Polymorphismus ermöglicht die Verarbeitung vorhandener Variablen und verwandter Klassen in einem einheitlichen Stil, sodass es einfach ist, neue Funktionen im System hinzuzufügen. Hier kann das Veröffentlichen der Informationen, die Sie online gefunden haben, die Polymorphismen und Erbschaftsprobleme, die besondere Aufmerksamkeit in der Vererbung erfordern, deutlicher klären:
Polymorphismen von Java
Die objektorientierte Programmierung hat drei Eigenschaften, nämlich Einkapselung, Vererbung und Polymorphismus.
Die Kapselung verbirgt den internen Implementierungsmechanismus der Klasse, so dass die interne Struktur der Klasse geändert werden kann, ohne den Benutzer zu beeinflussen, während die Daten geschützt werden.
Die Erbschaft besteht darin, den Code der übergeordneten Klassen wiederzuverwenden und gleichzeitig die Implementierung des Polymorphismus vorzubereiten. Was ist Polymorphismus?
Umschreiben, Überladung und dynamische Verbindung bilden Polymorphismus. Einer der Gründe, warum Java das Konzept des Polymorphismus eingeführt hat, ist, dass es sich von C ++ in Bezug auf die Klassenerbanz unterscheidet. Letzteres ermöglicht eine Vielzahl der Vererbung, die es sehr leistungsstarke Funktionen bringt, aber die komplexe Vererbungsbeziehung bringt C ++ - Entwicklern mehr Probleme. Um Risiken zu vermeiden, ermöglicht Java nur ein einzelnes Vererbung, und es gibt eine IS-A-Beziehung zwischen abgeleiteten Klassen und Basisklassen (d. H. "Katzen" ist ein "Tier"). Obwohl dies die Einfachheit und Klarheit der Erbschaftsbeziehung sicherstellt, wird dies unweigerlich große funktionale Einschränkungen haben. Daher führte Java das Konzept des Polymorphismus ein, um diesen Mangel auszugleichen. Darüber hinaus sind abstrakte Klassen und Schnittstellen auch wichtige Mittel, um die Grenzen der einzelnen Vererbungsvorschriften zu lösen. Gleichzeitig ist Polymorphismus auch die Essenz objektorientierter Programmierung.
Um den Polymorphismus zu verstehen, müssen Sie zunächst wissen, was "Aufwärtstransformation" ist.
Ich habe eine Subklasskatze definiert, die die Tierklasse erbt, und letzteres ist, dass erstere die übergeordnete Klasse ist. Ich kann passieren
Katze c = neuer Cat ();
Das Instanziieren eines Katzenobjekts ist nicht schwer zu verstehen. Aber wenn ich es so definiere:
Tier a = neuer Cat ();
Was bedeutet das?
Es ist einfach, es bedeutet, dass ich einen tierischen Verweis auf ein neu erstelltes Objekt des Katzentyps definiere. Da Katze von seinem Tierklassentier geerbt wird, kann ein Hinweis auf einen Tiertyp auf ein Objekt eines Katzentyps verweisen. Also, was ist der Sinn, dies zu tun? Da Unterklassen eine Verbesserung und Erweiterung der übergeordneten Klasse sind, sind Unterklassen im Allgemeinen leistungsstärker als übergeordnete Klassen in der Funktion, und ihre Attribute sind einzigartiger als übergeordnete Klassen.
Das Definieren eines Verweiss auf einen übergeordneten Klassentyp zeigt auf ein Objekt, das unterklassifiziert ist, kann nicht nur die leistungsstarken Funktionen der Unterklasse verwenden, sondern auch die Gemeinsamkeiten der übergeordneten Klasse extrahieren.
Ein Verweis auf den übergeordneten Klassentyp kann daher alle in der übergeordneten Klasse definierten Eigenschaften und Methoden aufrufen, und es ist hilflos für Methoden, die in der untergeordneten Klasse definiert sind, jedoch nicht in der übergeordneten Klasse.
Gleichzeitig kann eine Methode in der übergeordneten Klasse nur durch eine Bezugnahme auf den übergeordneten Klassentyp aufgerufen werden, wenn sie in der übergeordneten Klasse definiert, aber in der untergeordneten Klasse nicht außer Kraft gesetzt wird.
Bei Methoden, die in der übergeordneten Klasse definiert sind, wird die Verweise auf den übergeordneten Klassentyp diese Methode in der untergeordneten Klasse in der untergeordneten Klasse aufrufen, was eine dynamische Verbindung ist.
Schauen Sie sich das folgende Programm an:
Klasse Vater {public void func1 () {func2 (); } // Dies ist die Func2 () -Methode in der übergeordneten Klasse, da die Methode in der Unterklasse unten überschrieben wird //, wenn in der Referenz des übergeordneten Klassentyps diese Methode nicht mehr gültig ist // die in der Unterklasse öffentliche void func2 () {).Out.out.out.out.Out.Out.Out.Println ("AAA") überschriebene Methode. }} Klasse Child erweitert Vater {// func1 (int i) ist eine Überlastung der Func1 () -Methode // Da diese Methode in der übergeordneten Klasse nicht definiert ist, kann es nicht durch die Referenz des übergeordneten Klassentyps // in der Hauptmethode unter child.func1 (68) aufgerufen werden. } // func2 () schreibt die func2 () -Methode in der übergeordneten Klasse Vaters // neu, wenn die func2 () -Methode in der Verweise auf den übergeordneten Klassentyp aufgerufen wird, muss die Methode in der Unterklasse public void func2 () {System.out.Out.Println ("CCC") sein; }} öffentliche Klasse polymorphismtest {public static void main (String [] args) {father Child = new Child (); Child.func1 (); // Was wird das Druckergebnis sein? }}Das obige Programm ist ein sehr typisches Beispiel für Polymorphismus. Das Kind der Kinderklasse erbt den Vater der Elternklasse, überlastet die Methode der Elternklasse func1 () und überschreibt die Methode der Elternklasse func2 (). Die überlasteten Func1 (int i) und func1 () sind nicht mehr dieselbe Methode. Da in der übergeordneten Klasse kein Func1 (int i) vorhanden ist, kann das Referenzkind des übergeordneten Klassentyps die Func1 (int i) -Methode nicht aufrufen. Wenn die Unterklasse die Methode von Func2 () überschreibt, ruft das Referenzkind des übergeordneten Klassentyps den umgeschriebenen Func2 () in der Unterklasse beim Aufrufen der Methode auf.
Welche Ergebnisse drucken das Programm?
Offensichtlich sollte es "CCC" sein.
Für Polymorphismus kann es zusammengefasst werden als:
(1) Verwenden Sie Referenzen des übergeordneten Klassentyps, um auf das Objekt der Unterklasse (tatsächliches Objekt) zu verweisen.
(2) Diese Referenz kann nur Methoden und Variablen aufrufen, die in der übergeordneten Klasse definiert sind.
(3) Wenn eine Methode in der übergeordneten Klasse in der Unterklasse neu geschrieben wird, wird die Methode in der Unterklasse beim Aufrufen dieser Methode aufgerufen. (Dynamische Verbindung, dynamischer Aufruf)
(4) Variablen können nicht umgeschrieben werden (überschrieben). Das Konzept des "Umschreibens" ist nur für Methoden gedacht. Wenn die Variablen in der übergeordneten Klasse in der Unterklasse "neu schreiben", wird während der Zusammenstellung ein Fehler gemeldet.
Polymorphismus ist durch:
(1) Die Schnittstelle und implementieren Sie die Schnittstelle und überschreiben Sie mehrere verschiedene Klassen, die dieselbe Methode in der Schnittstelle (2) der übergeordneten Klasse und der übergeordneten Klasse und der übergeordneten Klasse abdecken und mehrere verschiedene Unterklassen überschreiben, die dieselbe Methode in der übergeordneten Klasse abdecken.
1. Grundkonzepte
Polymorphismus: Senden Sie eine Nachricht an ein Objekt und lassen Sie das Objekt entscheiden, auf welches Verhalten sie reagieren sollen.
Dynamische Methodenaufrufe werden implementiert, indem Subklass -Objektreferenzen an Objektreferenzvariablen für Superklassen zugewiesen werden.
Dieser Mechanismus von AVA folgt einem Prinzip: Wenn sich ein Superklasse -Objekt auf eine Variable bezieht, die sich auf ein Subklassenobjekt bezieht, bestimmt der Typ des referenzierten Objekts und nicht die Art der referenzierten Variablen, wessen Mitgliedsmethoden aufgerufen werden, aber die aufgerufene Methode muss in der Superklasse definiert werden, dh die von der Unterklasse abgedeckte Methode.
(1) Wenn a ein Verweis auf die Klasse A ist, kann A auf eine Instanz der Klasse A oder auf eine Unterklasse von Klasse A verweisen.
(2) Wenn a ein Verweis auf die Schnittstelle A ist, muss A auf eine Instanz einer Klasse verweisen, die die Schnittstelle A implementiert.
Implementierungsmechanismus des Java -Polymorphismus
Der aktuelle JVM -Implementierungsmechanismus von Sun, die Referenz einer Klasseninstanz ist ein Zeiger auf einen Griff, bei dem es sich um ein Paar Zeiger handelt:
Ein Zeiger zeigt auf eine Tabelle, und tatsächlich hat diese Tabelle auch zwei Zeiger (ein Zeiger zeigt auf eine Methodentabelle, die das Objekt enthält, und der andere Zeiger auf ein Klassenobjekt, der den Typ angibt, zu dem das Objekt gehört);
Ein weiterer Zeiger zeigt auf ein Stück Speicherraum, das aus dem Java -Haufen zugewiesen wurde.
Zusammenfassen
(1) Dynamische Methodenaufrufe werden implementiert, indem Subklass -Objektreferenzen zu Superklassen -Objektreferenzvariablen zugewiesen werden.
Abgeleitetes C2 = neu abgeleitetc (); Basiclass A1 = C2; // Baseclass -Basisklasse, abgeleitetc ist a1.play () von BaseClass geerbt; //play() is defined in BaseClass and DerivedC, that is, the subclass overrides the method
analysieren:
* 为什么子类的类型的对象实例可以覆给超类引用？
自动实现向上转型。通过该语句，编译器自动将子类实例向上移动，成为通用类型BaseClass；
* A. Will play() execute a method defined by the subclass or a parent class?
Unterklasse. During the run time, the corresponding method will be obtained based on the object a reference to the actual type. That's why there is polymorphism. An object reference of a base class is given a different subclass object reference. When executing the method, it will show different behaviors.
在a1=c2的时候，仍然是存在两个句柄，a1和c2，但是a1和c2拥有同一块数据内存块和不同的函数表。
（2）不能把父类对象引用赋给子类对象引用变量
BaseClass a2=new BaseClass(); DerivedC c1=a2;//出错
在java里面，向上转型是自动进行的,但是向下转型却不是，需要我们自己定义强制进行。
c1=(DerivedC)a2; 进行强制转化,也就是向下转型.
（3）记住一个很简单又很复杂的规则，一个类型引用只能引用引用类型自身含有的方法和变量。
你可能说这个规则不对的，因为父类引用指向子类对象的时候，最后执行的是子类的方法的。
其实这并不矛盾，那是因为采用了后期绑定，动态运行的时候又根据型别去调用了子类的方法。而假若子类的这个方法在父类中并没有定义，则会出错。
例如，DerivedC类在继承BaseClass中定义的函数外，还增加了几个函数（例如myFun()）
analysieren:
当你使用父类引用指向子类的时候，其实jvm已经使用了编译器产生的类型信息调整转换了。
这里你可以这样理解，相当于把不是父类中含有的函数从虚拟函数表中设置为不可见的。注意有可能虚拟函数表中有些函数地址由于在子类中已经被改写了，所以对象虚拟函数表中虚拟函数项目地址已经被设置为子类中完成的方法体的地址了。
（4）Java与C++多态性的比较
jvm关于多态性支持解决方法是和c++中几乎一样的，
只是c++中编译器很多是把类型信息和虚拟函数信息都放在一个虚拟函数表中，但是利用某种技术来区别。
Java把类型信息和函数信息分开放。Java中在继承以后，子类会重新设置自己的虚拟函数表，这个虚拟函数表中的项目有由两部分组成。从父类继承的虚拟函数和子类自己的虚拟函数。
虚拟函数调用是经过虚拟函数表间接调用的，所以才得以实现多态的。
Java的所有函数，除了被声明为final的，都是用后期绑定。
1个行为,不同的对象,他们具体体现出来的方式不一样,
比如: 方法重载overloading 以及方法重写(覆盖)override
class Human{ void run(){输出人在跑} } class Man extends Human{ void run(){输出男人在跑} } 这个时候,同是跑,不同的对象,不一样(这个是方法覆盖的例子) class Test{ void out(String str){输出str} void out(int i){输出i} }这个例子是方法重载,方法名相同,参数表不同
ok,明白了这些还不够,还用人在跑举例
Human ahuman=new Man();
这样我等于实例化了一个Man的对象,并声明了一个Human的引用,让它去指向Man这个对象意思是说,把Man这个对象当Human看了.
比如去动物园,你看见了一个动物,不知道它是什么, "这是什么动物? " "这是大熊猫! "
这2句话,就是最好的证明,因为不知道它是大熊猫,但知道它的父类是动物,所以,
这个大熊猫对象,你把它当成其父类动物看,这样子合情合理.
这种方式下要注意new Man();的确实例化了Man对象,所以ahuman.run()这个方法输出的是"男人在跑"
如果在子类Man下你写了一些它独有的方法比如eat(),而Human没有这个方法,
在调用eat方法时,一定要注意强制类型转换((Man)ahuman).eat(),这样才可以...
对接口来说,情况是类似的...
Beispiel:
package domain; //Define superA class superA { int i = 100; void fun(int j) { j = i; System.out.println("This is superA"); } } //Define superA subclass subB class subB extends superA { int m = 1; void fun(int aa) { System.out.println("This is subB"); } } //Define superA subC class subC extends superA { int n = 1; void fun(int cc) { System.out.println("This is subB"); } } //Define superA subC class subC extends superA { int n = 1; void fun(int cc) { System.out.println("This is subC"); } } class Test { public static void main(String[] args) { superA a = new superA(); subB b = new subB(); subC c = new subC(); a = b; a.fun(100); a = c; a.fun(200); }} /*
* 上述代码中subB和subC是超类superA的子类,我们在类Test中声明了3个引用变量a, b,
* c,通过将子类对象引用赋值给超类对象引用变量来实现动态方法调用。也许有人会问：
* "为什么(1)和(2)不输出：This is superA"。
* java的这种机制遵循一个原则：当超类对象引用变量引用子类对象时,
* 被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法,
* 但是这个被调用的方法必须是在超类中定义过的,
* 也就是说被子类覆盖的方法。
* 所以,不要被上例中(1)和(2)所迷惑,虽然写成a.fun(),但是由于(1)中的a被b赋值,
* 指向了子类subB的一个实例,因而(1)所调用的fun()实际上是子类subB的成员方法fun(),
* 它覆盖了超类superA的成员方法fun()；同样(2)调用的是子类subC的成员方法fun()。
* 另外,如果子类继承的超类是一个抽象类,虽然抽象类不能通过new操作符实例化,
* 但是可以创建抽象类的对象引用指向子类对象,以实现运行时多态性。具体的实现方法同上例。
* 不过,抽象类的子类必须覆盖实现超类中的所有的抽象方法,
* 否则子类必须被abstract修饰符修饰,当然也就不能被实例化了
*/
以上大多数是以子类覆盖父类的方法实现多态.下面是另一种实现多态的方法-----------重写父类方法
JAVA里没有多继承，一个类之能有一个父类。而继承的表现就是多态。一个父类可以有多个子类，而在子类里可以重写父类的方法（例如方法print()），这样每个子类里重写的代码不一样，自然表现形式就不一样。这样用父类的变量去引用不同的子类，在调用这个相同的方法print()的时候得到的结果和表现形式就不一样了，这就是多态，相同的消息（也就是调用相同的方法）会有不同的结果。举例说明：
//Premary class public class Father{ //The parent class has a method to hit the child public void hitChild(){ } } //Subclass 1 public class Son1 extends Father{ //Rewrite the method to hit the child public void hitChild(){ System.out.println("Why hit me? What I did wrong!"); } } //Subclass 2 public class Son2 extends Father{ //Rewrite the method to hit the child public void hitChild(){ System.out.println("I know I'm wrong, stop hitting it!"); } } //Subclass 3 public class Son3 extends Father{ //Rewrite the parent class hits the child method public void hitChild(){ System.out.println("I run, you can't hit!"); } } //Test class public class Test{ public static void main(String args[]){ Father father; father = new Son1(); father.hitChild(); father = new Son2(); father.hitChild(); father = new Son3(); father.hitChild(); }}都调用了相同的方法，出现了不同的结果！这就是多态的表现！
import java.io.*;class Super{ Super(){ System.out.println("This is super class!"); } void method(){ System.out.println("Super's method"); }}class Sub extends Super{ Sub(){ super(); System.out.println("/n/t:and here is the child"); } void method(){ System.out.println("child's method"); }}public class Super_Sub{ public static void main(String[] args){ Super sup=new Sub(); sup.method(); Sub child=(Sub)new Super();//这里，实际分配的内存是Super的，但是却用Child来指代它，这就是“向下转型”(父类冒充子类，因为子类在UML中画时是在下的嘛),必经强制类型转换child.method(); }}对于数据来说，继承是否为正确的设计可以用一个简单的规则来判断。“is-a”规则表明子类的每一个对象都是一个超类的对象。例如，每一个经理是一个员工。然而，只有经理类是员工类的子类才是有意义的。很明显，反过来就不行了――并不是每个员工都是经理。
还有一个明确叙述“is-a”规则的方法是替代原则。该原则规定无论何时，如果程序需要一个超类对象，都可以用一个子类对象来代替
动态绑定
理解调用一个对象方法的机制是非常重要的。下面具体介绍：Xf；
（1）编译器检查对象的声明类型和方法名。
(2) Next, the compiler checks the parameter type in the method call. If one of all methods called f has a parameter type whose parameter type best matches the parameter type provided by the call, the method will be selected to call. This process is called overload selection. (statisch)
（3）当程序运行并且使用动态绑定来调用一个方法时，那么虚拟机必须调用同x所指向的对象的实际类型相匹配的方法版本。
...
如果类中没有写构造函数，那么系统会自动为该类提供一个默认构造函数，该构造函数将所有的实例字段初始化为默认值：
...
包用途:
Java允许把多个类收集在一起成为一组，称作包（package）。包便于组织任务，以及使自己的任务和其他人提供的代码库相分离。
标准Java库被分类成许多的包，其中包括java.1ang、java.util和java.net等等。标准Java包是分层次的。就像在硬盘上嵌套有各级子目录一样，可以通过层次嵌套组织包。所有的Java包都在Java和Javax包层次内
创建包
已经看到，已有的库，比如JavaAPI中的类和接口，可以导入到Java程序中。
Java API中的每一个类和接口属于一个特定的包。它包含一组相关联的类和接口，实际是对类和接口进行组织的目录结构。
例如，假定文件名是MyClass.java。它意味着在那个文件有一个、而且只能有一个public类。而且那个类的名字必须是MyClass（包括大小写形式）：
packagemypackage;publicclass MyClass{……}创建可复用的类的步骤简要说明如下：
（1）定义一个public类。如果类不是public，它只能被同一包中的其他类使用。
（2）选择一个包名，并把package语句加到可复用的类的源代码文件中。
（3）编译这个类。这样，它就被放到适当的包目录结构中，以供编译器和解译器使用。
（4）把这个可复用的类导入到需要用它的程序中。现在就可以使用它了。
注意在Java语言中可以出现在类定义的括号外面的仅有两个语句，它们是package和import。
包引用---每个类名前加上完整的包名
例如，给出一个指向此包中的类的快捷方式。一旦使用import（导入）了以后，就不再需要给出完整的包名。
可以引入一个特定的类，也可以引入整个包。import语句要放在源文件的头部（但在所有package语句的下面）。例如，可以通过下面的语句引入在java.util包中的所有的类：
importjava.util.*;
然后，就可以使用
Datetoday=new Date();
而不需要在前面加上包名。也可以引入包中某个特定的类：
importjava.util.Date;
要把类放人一个包中，必须把此包的名字放在源文件头部，并且放在对包中的类进行定义的代码之前。例如，在文件Employee.java的开始部分如下：
packagecom.horstmann.corejava;publicclass Employee{……}把包中的文件放入与此完整的包名相匹配的子目录中。例如，在包com.horstmann.corejava中的所有的类文件都必须放在子目录com/horstmann/core.java（Windows下的com/horstmann/corejava）下。这是最简单的一种方法
类被存储在文件系统的子目录中。类的路径必须与所在包名相匹配。
在前面的例子中，包目录com/horstmann/corejava是程序目录的一个子目录。然而这样安排很不灵活。一般，有多个程序需要访问包文件。为了使包可以在多个程序间共享，需要做以下事情：
1）把类放在一个或多个特定的目录中，比如/home/user/classdir。此目录是包树的基本目录。如果加入了类com.horstmann.corejava.Employee，那么此类文件必须位于子目录/home/user/classdir/com/horstmann/corejava下。
2）设置类路径。类路径是其子目录包含类文件的所有基本目录的集合。classpath
已经接触过public和private访问指示符。
被标记为Public的部件可以被任何类使用，而私有部件只能被定义它们的类使用。如果没有指定public或private，那么部件（即类、方法或变量）可以被同一个包中的所有方法访问。
Java API包
为了简化面向对象的编程过程，Java系统事先设计并实现了一些体现了常用功能的标准类，如用于输入／输出的类，用于数学运算的类，用于图形用户界面设计的类，用于网络处理的类等。这些系统标准类根据实现的功能不同，可以划分成不同的集合，每个集合是一个包，合称为类库。可以引用这些包，也可以创建自己的包。
Java的类库是系统提供的已实现的标准类的集合，是Java编程的API，它可以帮助开发者方便、快捷地开发Java程序
接口主要作用是可以帮助实现类似于类的多重继承的功能。在Java中，出于简化程序结构的考虑，不再支持类间的多重继承而只支持单重继承，即一个类至多只能有一个直接父类。然而在解决实际问题的过程中，仅仅依靠单重继承在很多情况下都不能将问题的复杂性表述完整，需要其他的机制作为辅助。
接口声明
Java中声明接口的语法如下：
[public] interface 接口名[extends 父接口名列表]{ //接口体;//常量域声明[public] [static] [final] 域类型域名=常量值; //抽象方法声明[public] [abstract] 返回值方法名(参数列表) [throw异常列表];}从上面的语法规定可以看出，定义接口与定义类非常相似，实际上完全可以把接口理解成为一种特殊的类，接口是由常量和抽象方法组成的特殊类
（1）接口中的属性都是用final修饰的常量，
（2）接口中的方法都是用abstract修饰的抽象方法，在接口中只能给出这些抽象方法的方法名、返回值和参数列表，而不能定义方法体，即仅仅规定了一组信息交换、传输和处理的“接口”
接口的实现
一个类要实现某个或某几个接口时，有如下的步骤和注意事项：
（1）在类的声明部分，用implements关键字声明该类将要实现哪些接口；
wie folgt:
class类名implements接口{ }（2）如果实现某接口的类不是abstract的抽象类，则在类的定义部分必须实现指定接口的所有抽象方法，即为所有抽象方法定义方法体，而且方法头部分应该与接口中的定义完全一致，即有完全相同的返回值和参数列表；
（3）如果实现某接口的类是abstract的抽象类，则它可以不实现该接口所有的方法。
（4）一个类在实现某接口的抽象方法时，必须使用完全相同的方法头。
（5）接口的抽象方法，其访问限制符都已指定是public，所以类在实现方法时，必须显式地使用public修饰符。
Zusammenfassung:
多重继承是指一个子类继承多个父类。Java不支持多重继承，但Java提供了接口。
子类不能访问父类的private成员，但子类可以访问其父类的public，protected和包访问成员；要访问父类的包访问成员，子类一定要在父类的包内。
子类构造函数总是先调用（显式的或隐式地）其父类的构造函数，以创建和初始化子类的父类成员。
子类的对象可以当作其父类的对象对待，反之则不行（即向上转型）
protected访问是public和private访问之间一个保护性的中间层次。父类方法、子类方法和在同一个包内类的方法都能访问父类的protected成员，但其他方法均不能访问
一个子类对象引用可以隐式地转换成一个父类对象引用。使用显式的类型转换，可以把父类引用转换成子类引用。如果目标不是子类对象，将产生ClassCastException例外处理。