Java - Kurzanleitung

Die Programmiersprache Java wurde ursprünglich von Sun Microsystems entwickelt, das von James Gosling initiiert und 1995 als Kernkomponente der Java-Plattform von Sun Microsystems (Java 1.0 [J2SE]) veröffentlicht wurde.

Die neueste Version der Java Standard Edition ist Java SE 8. Mit der Weiterentwicklung von Java und seiner weit verbreiteten Beliebtheit wurden mehrere Konfigurationen für verschiedene Arten von Plattformen erstellt. Zum Beispiel: J2EE für Unternehmensanwendungen, J2ME für mobile Anwendungen.

Die neuen J2-Versionen wurden in Java SE, Java EE bzw. Java ME umbenannt. Java ist garantiertWrite Once, Run Anywhere.

Java ist -

• Object Oriented- In Java ist alles ein Objekt. Java kann leicht erweitert werden, da es auf dem Objektmodell basiert.

• Platform Independent- Im Gegensatz zu vielen anderen Programmiersprachen, einschließlich C und C ++, wird Java beim Kompilieren nicht in plattformspezifische Maschinen kompiliert, sondern in plattformunabhängigen Bytecode. Dieser Bytecode wird über das Web verteilt und von der virtuellen Maschine (JVM) auf der Plattform interpretiert, auf der er ausgeführt wird.

• Simple- Java ist so konzipiert, dass es leicht zu erlernen ist. Wenn Sie das Grundkonzept von OOP Java verstehen, ist es leicht zu beherrschen.

• Secure- Mit der sicheren Funktion von Java können virenfreie, manipulationsfreie Systeme entwickelt werden. Authentifizierungstechniken basieren auf der Verschlüsselung mit öffentlichem Schlüssel.

• Architecture-neutral - Der Java-Compiler generiert ein architekturneutrales Objektdateiformat, mit dem der kompilierte Code auf vielen Prozessoren ausgeführt werden kann, wenn ein Java-Laufzeitsystem vorhanden ist.

• Portable- Da es architekturneutral ist und keine implementierungsabhängigen Aspekte der Spezifikation aufweist, ist Java portabel. Der Compiler in Java ist in ANSI C mit einer sauberen Portabilitätsgrenze geschrieben, bei der es sich um eine POSIX-Teilmenge handelt.

• Robust - Java bemüht sich, fehleranfällige Situationen zu beseitigen, indem es sich hauptsächlich auf die Fehlerprüfung zur Kompilierungszeit und die Laufzeitprüfung konzentriert.

• Multithreaded- Mit der Multithread-Funktion von Java können Programme geschrieben werden, die viele Aufgaben gleichzeitig ausführen können. Mit dieser Entwurfsfunktion können Entwickler interaktive Anwendungen erstellen, die reibungslos ausgeführt werden können.

• Interpreted- Java-Bytecode wird im laufenden Betrieb in native Maschinenanweisungen übersetzt und nirgendwo gespeichert. Der Entwicklungsprozess ist schneller und analytischer, da die Verknüpfung ein inkrementeller und leichter Prozess ist.

• High Performance - Durch die Verwendung von Just-In-Time-Compilern ermöglicht Java eine hohe Leistung.

• Distributed - Java ist für die verteilte Umgebung des Internets konzipiert.

• Dynamic- Java gilt als dynamischer als C oder C ++, da es zur Anpassung an eine sich entwickelnde Umgebung entwickelt wurde. Java-Programme können umfangreiche Laufzeitinformationen enthalten, mit denen Zugriffe auf Objekte zur Laufzeit überprüft und aufgelöst werden können.

Geschichte von Java

James Gosling initiierte im Juni 1991 ein Java-Sprachprojekt zur Verwendung in einem seiner vielen Set-Top-Box-Projekte. Die Sprache, die ursprünglich nach einer Eiche, die vor Goslings Büro stand, "Eiche" genannt wurde, wurde auch "Grün" genannt und später aus einer Liste zufälliger Wörter in "Java" umbenannt.

Sun veröffentlichte 1995 die erste öffentliche Implementierung als Java 1.0. Sie versprach es Write Once, Run Anywhere (WORA) bietet kostenlose Laufzeiten auf gängigen Plattformen.

Am 13. November 2006 veröffentlichte Sun einen Großteil von Java als freie und Open-Source-Software unter den Bedingungen der GNU General Public License (GPL).

Am 8. Mai 2007 beendete Sun den Prozess und machte den gesamten Kerncode von Java frei und Open Source, abgesehen von einem kleinen Teil des Codes, für den Sun nicht das Urheberrecht besaß.

Werkzeuge, die Sie benötigen

Für die Durchführung der in diesem Lernprogramm beschriebenen Beispiele benötigen Sie einen Pentium 200-MHz-Computer mit mindestens 64 MB RAM (128 MB RAM empfohlen).

Sie benötigen außerdem die folgende Software:

• Linux 7.1 oder Windows XP / 7/8 Betriebssystem
• Java JDK 8
• Microsoft Notepad oder ein anderer Texteditor

Dieses Tutorial vermittelt die erforderlichen Kenntnisse zum Erstellen von GUI-, Netzwerk- und Webanwendungen mit Java.

Was kommt als nächstes?

Im nächsten Kapitel erfahren Sie, wie Sie Java und seine Dokumentation erhalten. Schließlich erfahren Sie, wie Sie Java installieren und eine Umgebung für die Entwicklung von Java-Anwendungen vorbereiten.

In diesem Kapitel werden die verschiedenen Aspekte der Einrichtung einer kongenialen Umgebung für Java erläutert.

Einrichtung der lokalen Umgebung

Wenn Sie weiterhin bereit sind, Ihre Umgebung für die Programmiersprache Java einzurichten, finden Sie in diesem Abschnitt Anleitungen zum Herunterladen und Einrichten von Java auf Ihrem Computer. Im Folgenden finden Sie die Schritte zum Einrichten der Umgebung.

Java SE ist frei verfügbar über den Link Java herunterladen . Sie können eine Version herunterladen, die auf Ihrem Betriebssystem basiert.

Befolgen Sie die Anweisungen, um Java herunterzuladen und auszuführen .exeum Java auf Ihrem Computer zu installieren. Sobald Sie Java auf Ihrem Computer installiert haben, müssen Sie Umgebungsvariablen festlegen, die auf korrekte Installationsverzeichnisse verweisen.

Einrichten des Pfads für Windows

Angenommen, Sie haben Java im Verzeichnis c: \ Programme \ java \ jdk installiert -

• Klicken Sie mit der rechten Maustaste auf "Arbeitsplatz" und wählen Sie "Eigenschaften".

• Klicken Sie auf der Registerkarte "Erweitert" auf die Schaltfläche "Umgebungsvariablen".

• Ändern Sie nun die Variable 'Path' so, dass sie auch den Pfad zur ausführbaren Java-Datei enthält. Wenn der Pfad derzeit auf "C: \ WINDOWS \ SYSTEM32" festgelegt ist, ändern Sie Ihren Pfad in "C: \ WINDOWS \ SYSTEM32; c: \ Programme \ java \ jdk \ bin".

Einrichten des Pfads für Linux, UNIX, Solaris, FreeBSD

Die Umgebungsvariable PATH sollte so eingestellt sein, dass sie darauf verweist, wo die Java-Binärdateien installiert wurden. Informationen hierzu finden Sie in Ihrer Shell-Dokumentation.

Wenn Sie beispielsweise bash als Shell verwenden, fügen Sie die folgende Zeile am Ende Ihrer '.bashrc: export PATH = / path / to / java: $ PATH' hinzu.

Beliebte Java-Editoren

Zum Schreiben Ihrer Java-Programme benötigen Sie einen Texteditor. Es gibt noch ausgefeiltere IDEs auf dem Markt. Im Moment können Sie jedoch eine der folgenden Möglichkeiten in Betracht ziehen:

• Notepad - Auf einem Windows-Computer können Sie einen einfachen Texteditor wie Notepad (für dieses Lernprogramm empfohlen) und TextPad verwenden.

• Netbeans - Eine Java-IDE, die Open Source und kostenlos ist und von der heruntergeladen werden kann https://www.netbeans.org/index.html.

• Eclipse - Eine Java-IDE, die von der Open-Source-Community von eclipse entwickelt wurde und von heruntergeladen werden kann https://www.eclipse.org/.

Was kommt als nächstes?

Im nächsten Kapitel erfahren Sie, wie Sie Ihr erstes Java-Programm schreiben und ausführen und einige der wichtigen grundlegenden Syntaxen in Java, die für die Entwicklung von Anwendungen erforderlich sind.

Wenn wir ein Java-Programm betrachten, kann es als eine Sammlung von Objekten definiert werden, die über das Aufrufen der Methoden des jeweils anderen kommunizieren. Lassen Sie uns nun kurz untersuchen, was Klassen-, Objekt-, Methoden- und Instanzvariablen bedeuten.

• Object- Objekte haben Zustände und Verhaltensweisen. Beispiel: Ein Hund hat Zustände - Farbe, Name, Rasse sowie Verhalten wie Schwanzwedeln, Bellen, Fressen. Ein Objekt ist eine Instanz einer Klasse.

• Class - Eine Klasse kann als Vorlage / Blaupause definiert werden, die das Verhalten / den Status beschreibt, den das Objekt seines Typs unterstützt.

• Methods- Eine Methode ist im Grunde ein Verhalten. Eine Klasse kann viele Methoden enthalten. Es ist in Methoden, in denen die Logik geschrieben, Daten manipuliert und alle Aktionen ausgeführt werden.

• Instance Variables- Jedes Objekt verfügt über einen eindeutigen Satz von Instanzvariablen. Der Status eines Objekts wird durch die diesen Instanzvariablen zugewiesenen Werte erstellt.

Erstes Java-Programm

Schauen wir uns einen einfachen Code an, der die Wörter druckt Hello World.

Beispiel

public class MyFirstJavaProgram {

   /* This is my first java program.
    * This will print 'Hello World' as the output
    */

   public static void main(String []args) {
      System.out.println("Hello World"); // prints Hello World
   }
}

Schauen wir uns an, wie Sie die Datei speichern, kompilieren und das Programm ausführen. Bitte folgen Sie den nachfolgenden Schritten -

• Öffnen Sie den Editor und fügen Sie den Code wie oben hinzu.

• Speichern Sie die Datei als: MyFirstJavaProgram.java.

• Öffnen Sie ein Eingabeaufforderungsfenster und wechseln Sie in das Verzeichnis, in dem Sie die Klasse gespeichert haben. Angenommen, es ist C: \.

• Geben Sie 'javac MyFirstJavaProgram.java' ein und drücken Sie die Eingabetaste, um Ihren Code zu kompilieren. Wenn Ihr Code keine Fehler enthält, werden Sie an der Eingabeaufforderung zur nächsten Zeile weitergeleitet (Annahme: Die Pfadvariable ist festgelegt).

• Geben Sie nun 'java MyFirstJavaProgram' ein, um Ihr Programm auszuführen.

• Auf dem Fenster wird "Hallo Welt" gedruckt.

Ausgabe

C:\> javac MyFirstJavaProgram.java
C:\> java MyFirstJavaProgram 
Hello World

Grundlegende Syntax

Bei Java-Programmen ist es sehr wichtig, die folgenden Punkte zu beachten.

• Case Sensitivity - Java unterscheidet zwischen Groß- und Kleinschreibung, dh Bezeichner Hello und hello hätte in Java eine andere Bedeutung.

• Class Names- Bei allen Klassennamen sollte der erste Buchstabe in Großbuchstaben geschrieben sein. Wenn mehrere Wörter verwendet werden, um einen Namen für die Klasse zu bilden, sollte der erste Buchstabe jedes inneren Wortes in Großbuchstaben geschrieben sein.

  Example: Klasse MyFirstJavaClass

• Method Names- Alle Methodennamen sollten mit einem Kleinbuchstaben beginnen. Wenn mehrere Wörter verwendet werden, um den Namen der Methode zu bilden, sollte der erste Buchstabe jedes inneren Wortes in Großbuchstaben geschrieben sein.

  Example: public void myMethodName ()

• Program File Name - Der Name der Programmdatei sollte genau mit dem Klassennamen übereinstimmen.

  Wenn Sie die Datei speichern, sollten Sie sie unter Verwendung des Klassennamens speichern (beachten Sie, dass bei Java zwischen Groß- und Kleinschreibung unterschieden wird) und '.java' an das Ende des Namens anhängen (wenn der Dateiname und der Klassenname nicht übereinstimmen, wird Ihr Programm nicht kompiliert ).

  Example:Angenommen, 'MyFirstJavaProgram' ist der Klassenname. Dann sollte die Datei als 'MyFirstJavaProgram.java' gespeichert werden.

• public static void main(String args[]) - Die Java-Programmverarbeitung beginnt mit der main () -Methode, die ein obligatorischer Bestandteil jedes Java-Programms ist.

Java-Bezeichner

Alle Java-Komponenten erfordern Namen. Namen, die für Klassen, Variablen und Methoden verwendet werden, werden aufgerufenidentifiers.

In Java gibt es einige Punkte, die Sie bei Bezeichnern beachten sollten. Sie sind wie folgt -

• Alle Bezeichner sollten mit einem Buchstaben (A bis Z oder a bis z), einem Währungszeichen ($) oder einem Unterstrich (_) beginnen.

• Nach dem ersten Zeichen können Bezeichner eine beliebige Kombination von Zeichen haben.

• Ein Schlüsselwort kann nicht als Kennung verwendet werden.

• Bei Identifikatoren wird vor allem zwischen Groß- und Kleinschreibung unterschieden.

• Beispiele für rechtliche Kennungen: Alter, $ Gehalt, _Wert, __1_Wert.

• Beispiele für illegale Kennungen: 123abc, -salary.

Java-Modifikatoren

Wie in anderen Sprachen ist es möglich, Klassen, Methoden usw. mithilfe von Modifikatoren zu ändern. Es gibt zwei Kategorien von Modifikatoren -

• Access Modifiers - Standard, öffentlich, geschützt, privat

• Non-access Modifiers - endgültig, abstrakt, streng

Wir werden im nächsten Abschnitt weitere Details zu Modifikatoren untersuchen.

Java-Variablen

Im Folgenden sind die Arten von Variablen in Java aufgeführt:

• Lokale Variablen
• Klassenvariablen (statische Variablen)
• Instanzvariablen (nicht statische Variablen)

Java-Arrays

Arrays sind Objekte, in denen mehrere Variablen desselben Typs gespeichert sind. Ein Array selbst ist jedoch ein Objekt auf dem Heap. In den nächsten Kapiteln werden wir untersuchen, wie deklariert, konstruiert und initialisiert wird.

Java Enums

Aufzählungen wurden in Java 5.0 eingeführt. Aufzählungen beschränken eine Variable auf einen von nur wenigen vordefinierten Werten. Die Werte in dieser Aufzählungsliste werden als Aufzählungen bezeichnet.

Durch die Verwendung von Aufzählungen ist es möglich, die Anzahl der Fehler in Ihrem Code zu reduzieren.

Wenn wir beispielsweise eine Anwendung für einen Frischsaftladen in Betracht ziehen, wäre es möglich, die Glasgröße auf klein, mittel und groß zu beschränken. Dies würde sicherstellen, dass niemand eine andere Größe als klein, mittel oder groß bestellen kann.

Beispiel

class FreshJuice {
   enum FreshJuiceSize{ SMALL, MEDIUM, LARGE }
   FreshJuiceSize size;
}

public class FreshJuiceTest {

   public static void main(String args[]) {
      FreshJuice juice = new FreshJuice();
      juice.size = FreshJuice.FreshJuiceSize.MEDIUM ;
      System.out.println("Size: " + juice.size);
   }
}

Das obige Beispiel führt zu folgendem Ergebnis:

Ausgabe

Size: MEDIUM

Note- Aufzählungen können als eigene oder innerhalb einer Klasse deklariert werden. Methoden, Variablen und Konstruktoren können auch in Enums definiert werden.

Java-Schlüsselwörter

Die folgende Liste zeigt die reservierten Wörter in Java. Diese reservierten Wörter dürfen nicht als Konstante, Variable oder andere Bezeichnernamen verwendet werden.

abstrakt	behaupten	Boolescher Wert	Unterbrechung
Byte	Fall	Fang	verkohlen
Klasse	const	fortsetzen	Standard
tun	doppelt	sonst	Aufzählung
erweitert	Finale	schließlich	schweben
zum	gehe zu	wenn	Geräte
importieren	Instanz von	int	Schnittstelle
lange	einheimisch	Neu	Paket
Privat	geschützt	Öffentlichkeit	Rückkehr
kurz	statisch	strictfp	Super
Schalter	synchronisiert	diese	werfen
wirft	vorübergehend	Versuchen	Leere
flüchtig	während

Kommentare in Java

Java unterstützt einzeilige und mehrzeilige Kommentare, die C und C ++ sehr ähnlich sind. Alle in einem Kommentar verfügbaren Zeichen werden vom Java-Compiler ignoriert.

Beispiel

public class MyFirstJavaProgram {

   /* This is my first java program.
    * This will print 'Hello World' as the output
    * This is an example of multi-line comments.
    */

   public static void main(String []args) {
      // This is an example of single line comment
      /* This is also an example of single line comment. */
      System.out.println("Hello World");
   }
}

Ausgabe

Hello World

Leerzeilen verwenden

Eine Zeile, die nur Leerzeichen enthält, möglicherweise mit einem Kommentar, wird als Leerzeile bezeichnet, und Java ignoriert sie vollständig.

Erbe

In Java können Klassen von Klassen abgeleitet werden. Wenn Sie eine neue Klasse erstellen müssen und hier bereits eine Klasse mit dem von Ihnen benötigten Code vorhanden ist, können Sie Ihre neue Klasse grundsätzlich aus dem bereits vorhandenen Code ableiten.

Mit diesem Konzept können Sie die Felder und Methoden der vorhandenen Klasse wiederverwenden, ohne den Code in einer neuen Klasse neu schreiben zu müssen. In diesem Szenario wird die vorhandene Klasse als bezeichnetsuperclass und die abgeleitete Klasse heißt die subclass.

Schnittstellen

In der Java-Sprache kann eine Schnittstelle als Vertrag zwischen Objekten definiert werden, wie miteinander kommuniziert werden soll. Schnittstellen spielen eine wichtige Rolle beim Konzept der Vererbung.

Eine Schnittstelle definiert die Methoden, die eine abgeleitete Klasse (Unterklasse) verwenden soll. Die Implementierung der Methoden liegt jedoch ganz bei der Unterklasse.

Was kommt als nächstes?

Im nächsten Abschnitt werden Objekte und Klassen in der Java-Programmierung erläutert. Am Ende der Sitzung erhalten Sie ein klares Bild davon, was Objekte und was Klassen in Java sind.

Java ist eine objektorientierte Sprache. Als Sprache mit der objektorientierten Funktion unterstützt Java die folgenden grundlegenden Konzepte:

• Polymorphism
• Inheritance
• Encapsulation
• Abstraction
• Classes
• Objects
• Instance
• Method
• Nachrichtenübermittlung

In diesem Kapitel werden wir uns mit den Konzepten befassen - Klassen und Objekte.

• Object- Objekte haben Zustände und Verhaltensweisen. Beispiel: Ein Hund hat Zustände - Farbe, Name, Rasse sowie Verhalten - mit dem Schwanz wedeln, bellen, essen. Ein Objekt ist eine Instanz einer Klasse.

• Class - Eine Klasse kann als Vorlage / Blaupause definiert werden, die das Verhalten / den Status beschreibt, den das Objekt seines Typs unterstützt.

Objekte in Java

Lassen Sie uns nun tief in die Objekte schauen. Wenn wir die reale Welt betrachten, können wir viele Objekte um uns herum finden, Autos, Hunde, Menschen usw. Alle diese Objekte haben einen Zustand und ein Verhalten.

Wenn wir einen Hund betrachten, dann ist sein Zustand - Name, Rasse, Farbe und das Verhalten - bellen, mit dem Schwanz wedeln, rennen.

Wenn Sie das Softwareobjekt mit einem realen Objekt vergleichen, haben sie sehr ähnliche Eigenschaften.

Softwareobjekte haben auch einen Zustand und ein Verhalten. Der Status eines Softwareobjekts wird in Feldern gespeichert und das Verhalten über Methoden angezeigt.

In der Softwareentwicklung arbeiten Methoden also mit dem internen Zustand eines Objekts, und die Objekt-zu-Objekt-Kommunikation erfolgt über Methoden.

Klassen in Java

Eine Klasse ist eine Blaupause, aus der einzelne Objekte erstellt werden.

Es folgt ein Beispiel einer Klasse.

Beispiel

public class Dog {
   String breed;
   int age;
   String color;

   void barking() {
   }

   void hungry() {
   }

   void sleeping() {
   }
}

Eine Klasse kann einen der folgenden Variablentypen enthalten.

• Local variables- Variablen, die in Methoden, Konstruktoren oder Blöcken definiert sind, werden als lokale Variablen bezeichnet. Die Variable wird innerhalb der Methode deklariert und initialisiert, und die Variable wird zerstört, wenn die Methode abgeschlossen ist.

• Instance variables- Instanzvariablen sind Variablen innerhalb einer Klasse, jedoch außerhalb einer Methode. Diese Variablen werden initialisiert, wenn die Klasse instanziiert wird. Auf Instanzvariablen kann innerhalb einer beliebigen Methode, eines Konstruktors oder von Blöcken dieser bestimmten Klasse zugegriffen werden.

• Class variables - Klassenvariablen sind Variablen, die innerhalb einer Klasse außerhalb einer Methode mit dem Schlüsselwort static deklariert werden.

Eine Klasse kann über eine beliebige Anzahl von Methoden verfügen, um auf den Wert verschiedener Arten von Methoden zuzugreifen. Im obigen Beispiel sind Bellen (), Hunger () und Schlafen () Methoden.

Im Folgenden sind einige wichtige Themen aufgeführt, die beim Betrachten von Klassen der Java-Sprache behandelt werden müssen.

Konstruktoren

Eines der wichtigsten Unterthemen bei der Diskussion über Klassen wären Konstruktoren. Jede Klasse hat einen Konstruktor. Wenn wir keinen Konstruktor für eine Klasse explizit schreiben, erstellt der Java-Compiler einen Standardkonstruktor für diese Klasse.

Jedes Mal, wenn ein neues Objekt erstellt wird, wird mindestens ein Konstruktor aufgerufen. Die Hauptregel von Konstruktoren lautet, dass sie denselben Namen wie die Klasse haben sollten. Eine Klasse kann mehr als einen Konstruktor haben.

Das Folgende ist ein Beispiel eines Konstruktors -

Beispiel

public class Puppy {
   public Puppy() {
   }

   public Puppy(String name) {
      // This constructor has one parameter, name.
   }
}

Java unterstützt auch Singleton-Klassen, in denen Sie nur eine Instanz einer Klasse erstellen können.

Note- Wir haben zwei verschiedene Arten von Konstruktoren. Wir werden die Konstruktoren in den folgenden Kapiteln ausführlich besprechen.

Ein Objekt erstellen

Wie bereits erwähnt, stellt eine Klasse die Blaupausen für Objekte bereit. Im Grunde genommen wird ein Objekt aus einer Klasse erstellt. In Java wird das neue Schlüsselwort verwendet, um neue Objekte zu erstellen.

Beim Erstellen eines Objekts aus einer Klasse sind drei Schritte erforderlich:

• Declaration - Eine Variablendeklaration mit einem Variablennamen mit einem Objekttyp.

• Instantiation - Das Schlüsselwort 'new' wird zum Erstellen des Objekts verwendet.

• Initialization- Auf das Schlüsselwort 'new' folgt ein Aufruf eines Konstruktors. Dieser Aufruf initialisiert das neue Objekt.

Das Folgende ist ein Beispiel für das Erstellen eines Objekts -

Beispiel

public class Puppy {
   public Puppy(String name) {
      // This constructor has one parameter, name.
      System.out.println("Passed Name is :" + name );
   }

   public static void main(String []args) {
      // Following statement would create an object myPuppy
      Puppy myPuppy = new Puppy( "tommy" );
   }
}

Wenn wir das obige Programm kompilieren und ausführen, wird das folgende Ergebnis erzielt:

Ausgabe

Passed Name is :tommy

Zugriff auf Instanzvariablen und -methoden

Auf Instanzvariablen und -methoden wird über erstellte Objekte zugegriffen. Um auf eine Instanzvariable zuzugreifen, folgt der vollständig qualifizierte Pfad:

/* First create an object */
ObjectReference = new Constructor();

/* Now call a variable as follows */
ObjectReference.variableName;

/* Now you can call a class method as follows */
ObjectReference.MethodName();

Beispiel

In diesem Beispiel wird erläutert, wie Sie auf Instanzvariablen und Methoden einer Klasse zugreifen.

public class Puppy {
   int puppyAge;

   public Puppy(String name) {
      // This constructor has one parameter, name.
      System.out.println("Name chosen is :" + name );
   }

   public void setAge( int age ) {
      puppyAge = age;
   }

   public int getAge( ) {
      System.out.println("Puppy's age is :" + puppyAge );
      return puppyAge;
   }

   public static void main(String []args) {
      /* Object creation */
      Puppy myPuppy = new Puppy( "tommy" );

      /* Call class method to set puppy's age */
      myPuppy.setAge( 2 );

      /* Call another class method to get puppy's age */
      myPuppy.getAge( );

      /* You can access instance variable as follows as well */
      System.out.println("Variable Value :" + myPuppy.puppyAge );
   }
}

Wenn wir das obige Programm kompilieren und ausführen, wird das folgende Ergebnis erzielt:

Ausgabe

Name chosen is :tommy
Puppy's age is :2
Variable Value :2

Regeln für die Deklaration von Quelldateien

Lassen Sie uns als letzten Teil dieses Abschnitts nun die Deklarationsregeln für Quelldateien untersuchen. Diese Regeln sind wichtig, wenn Klassen, Importanweisungen und Paketanweisungen in einer Quelldatei deklariert werden .

• Es kann nur eine öffentliche Klasse pro Quelldatei geben.

• Eine Quelldatei kann mehrere nicht öffentliche Klassen haben.

• Der Name der öffentlichen Klasse sollte auch der Name der Quelldatei sein, an die angehängt werden soll .javaAm Ende. Beispiel: Der Klassenname lautet public class Employee {}, dann sollte die Quelldatei Employee.java sein.

• Wenn die Klasse in einem Paket definiert ist, sollte die Paketanweisung die erste Anweisung in der Quelldatei sein.

• Wenn Importanweisungen vorhanden sind, müssen sie zwischen der Paketanweisung und der Klassendeklaration geschrieben werden. Wenn keine Paketanweisungen vorhanden sind, sollte die Importanweisung die erste Zeile in der Quelldatei sein.

• Import- und Paketanweisungen beziehen sich auf alle in der Quelldatei vorhandenen Klassen. Es ist nicht möglich, unterschiedliche Import- und / oder Paketanweisungen für verschiedene Klassen in der Quelldatei zu deklarieren.

Klassen haben mehrere Zugriffsebenen und es gibt verschiedene Arten von Klassen. abstrakte Klassen, Abschlussklassen usw. All dies werden wir im Kapitel über Zugriffsmodifikatoren erläutern.

Neben den oben genannten Klassentypen verfügt Java auch über einige spezielle Klassen, die als innere Klassen und anonyme Klassen bezeichnet werden.

Java-Paket

Mit einfachen Worten, es ist eine Möglichkeit, die Klassen und Schnittstellen zu kategorisieren. Bei der Entwicklung von Anwendungen in Java werden Hunderte von Klassen und Schnittstellen geschrieben. Daher ist die Kategorisierung dieser Klassen ein Muss und erleichtert das Leben erheblich.

Anweisungen importieren

Wenn in Java ein vollständig qualifizierter Name angegeben wird, der das Paket und den Klassennamen enthält, kann der Compiler den Quellcode oder die Quellklassen leicht finden. Mit der Import-Anweisung kann der Compiler den richtigen Speicherort angeben, um diese bestimmte Klasse zu finden.

In der folgenden Zeile wird der Compiler beispielsweise aufgefordert, alle im Verzeichnis java_installation / java / io - verfügbaren Klassen zu laden.

import java.io.*;

Eine einfache Fallstudie

Für unsere Fallstudie werden wir zwei Klassen erstellen. Sie sind Employee und EmployeeTest.

Öffnen Sie zuerst den Notizblock und fügen Sie den folgenden Code hinzu. Denken Sie daran, dass dies die Employee-Klasse und die Klasse eine öffentliche Klasse ist. Speichern Sie nun diese Quelldatei unter dem Namen Employee.java.

Die Employee-Klasse verfügt über vier Instanzvariablen - Name, Alter, Bezeichnung und Gehalt. Die Klasse hat einen explizit definierten Konstruktor, der einen Parameter akzeptiert.

Beispiel

import java.io.*;
public class Employee {

   String name;
   int age;
   String designation;
   double salary;

   // This is the constructor of the class Employee
   public Employee(String name) {
      this.name = name;
   }

   // Assign the age of the Employee  to the variable age.
   public void empAge(int empAge) {
      age = empAge;
   }

   /* Assign the designation to the variable designation.*/
   public void empDesignation(String empDesig) {
      designation = empDesig;
   }

   /* Assign the salary to the variable	salary.*/
   public void empSalary(double empSalary) {
      salary = empSalary;
   }

   /* Print the Employee details */
   public void printEmployee() {
      System.out.println("Name:"+ name );
      System.out.println("Age:" + age );
      System.out.println("Designation:" + designation );
      System.out.println("Salary:" + salary);
   }
}

Wie bereits in diesem Lernprogramm erwähnt, beginnt die Verarbeitung mit der Hauptmethode. Damit wir diese Employee-Klasse ausführen können, sollte es eine Hauptmethode geben und Objekte sollten erstellt werden. Wir werden eine separate Klasse für diese Aufgaben erstellen.

Es folgt die EmployeeTest- Klasse, die zwei Instanzen der Klasse Employee erstellt und die Methoden für jedes Objekt aufruft, um Werte für jede Variable zuzuweisen.

Speichern Sie den folgenden Code in der Datei EmployeeTest.java.

import java.io.*;
public class EmployeeTest {

   public static void main(String args[]) {
      /* Create two objects using constructor */
      Employee empOne = new Employee("James Smith");
      Employee empTwo = new Employee("Mary Anne");

      // Invoking methods for each object created
      empOne.empAge(26);
      empOne.empDesignation("Senior Software Engineer");
      empOne.empSalary(1000);
      empOne.printEmployee();

      empTwo.empAge(21);
      empTwo.empDesignation("Software Engineer");
      empTwo.empSalary(500);
      empTwo.printEmployee();
   }
}

Kompilieren Sie nun beide Klassen und führen Sie dann EmployeeTest aus , um das Ergebnis wie folgt anzuzeigen:

Ausgabe

C:\> javac Employee.java
C:\> javac EmployeeTest.java
C:\> java EmployeeTest
Name:James Smith
Age:26
Designation:Senior Software Engineer
Salary:1000.0
Name:Mary Anne
Age:21
Designation:Software Engineer
Salary:500.0

Was kommt als nächstes?

In der nächsten Sitzung werden wir die grundlegenden Datentypen in Java diskutieren und wie sie bei der Entwicklung von Java-Anwendungen verwendet werden können.

Ein Konstruktor initialisiert ein Objekt, wenn es erstellt wird. Es hat den gleichen Namen wie seine Klasse und ähnelt syntaktisch einer Methode. Konstruktoren haben jedoch keinen expliziten Rückgabetyp.

In der Regel verwenden Sie einen Konstruktor, um den von der Klasse definierten Instanzvariablen Anfangswerte zuzuweisen oder andere Startvorgänge auszuführen, die zum Erstellen eines vollständig geformten Objekts erforderlich sind.

Alle Klassen haben Konstruktoren, unabhängig davon, ob Sie einen definieren oder nicht, da Java automatisch einen Standardkonstruktor bereitstellt, der alle Elementvariablen auf Null initialisiert. Sobald Sie jedoch Ihren eigenen Konstruktor definiert haben, wird der Standardkonstruktor nicht mehr verwendet.

Syntax

Es folgt die Syntax eines Konstruktors -

class ClassName {
   ClassName() {
   }
}

Java erlaubt zwei Arten von Konstruktoren, nämlich -

• Kein Argument Konstruktoren
• Parametrisierte Konstruktoren

Kein Argument Konstruktoren

Da der Name angibt, dass keine Argumentkonstruktoren von Java stattdessen keine Parameter akzeptieren, werden mit diesen Konstruktoren die Instanzvariablen einer Methode mit festen Werten für alle Objekte initialisiert.

Beispiel

Public class MyClass {
   Int num;
   MyClass() {
      num = 100;
   }
}

Sie würden den Konstruktor aufrufen, um Objekte wie folgt zu initialisieren

public class ConsDemo {
   public static void main(String args[]) {
      MyClass t1 = new MyClass();
      MyClass t2 = new MyClass();
      System.out.println(t1.num + " " + t2.num);
   }
}

Dies würde das folgende Ergebnis erzeugen

100 100

Parametrisierte Konstruktoren

In den meisten Fällen benötigen Sie einen Konstruktor, der einen oder mehrere Parameter akzeptiert. Parameter werden einem Konstruktor auf die gleiche Weise hinzugefügt, wie sie einer Methode hinzugefügt werden. Deklarieren Sie sie einfach in den Klammern nach dem Namen des Konstruktors.

Beispiel

Hier ist ein einfaches Beispiel, das einen Konstruktor verwendet -

// A simple constructor.
class MyClass {
   int x;
   
   // Following is the constructor
   MyClass(int i ) {
      x = i;
   }
}

Sie würden den Konstruktor aufrufen, um Objekte wie folgt zu initialisieren:

public class ConsDemo {
   public static void main(String args[]) {
      MyClass t1 = new MyClass( 10 );
      MyClass t2 = new MyClass( 20 );
      System.out.println(t1.x + " " + t2.x);
   }
}

Dies würde das folgende Ergebnis erzeugen -

10 20

Variablen sind nichts anderes als reservierte Speicherplätze zum Speichern von Werten. Dies bedeutet, dass Sie beim Erstellen einer Variablen Speicherplatz im Speicher reservieren.

Basierend auf dem Datentyp einer Variablen weist das Betriebssystem Speicher zu und entscheidet, was im reservierten Speicher gespeichert werden kann. Durch Zuweisen verschiedener Datentypen zu Variablen können Sie daher Ganzzahlen, Dezimalstellen oder Zeichen in diesen Variablen speichern.

In Java stehen zwei Datentypen zur Verfügung:

• Primitive Datentypen
• Referenz- / Objektdatentypen

Primitive Datentypen

Es gibt acht primitive Datentypen, die von Java unterstützt werden. Primitive Datentypen werden durch die Sprache vordefiniert und durch ein Schlüsselwort benannt. Lassen Sie uns nun die acht primitiven Datentypen im Detail betrachten.

Byte

• Der Byte-Datentyp ist eine 8-Bit-Zweierkomplement-Ganzzahl mit Vorzeichen

• Der Mindestwert ist -128 (-2 ^ 7)

• Maximalwert ist 127 (einschließlich) (2 ^ 7 -1)

• Der Standardwert ist 0

• Der Byte-Datentyp wird verwendet, um Platz in großen Arrays zu sparen, hauptsächlich anstelle von Ganzzahlen, da ein Byte viermal kleiner als eine Ganzzahl ist.

• Beispiel: Byte a = 100, Byte b = -50

kurz

• Der kurze Datentyp ist eine 16-Bit-Ganzzahl mit vorzeichenbehafteten Zweierkomplementen

• Der Mindestwert beträgt -32.768 (-2 ^ 15)

• Maximalwert ist 32.767 (einschließlich) (2 ^ 15 -1)

• Der kurze Datentyp kann auch verwendet werden, um Speicher als Byte-Datentyp zu speichern. Ein Kurzschluss ist zweimal kleiner als eine Ganzzahl

• Der Standardwert ist 0.

• Beispiel: kurz s = 10000, kurz r = -20000

int

• Der Int-Datentyp ist eine 32-Bit-Zweierkomplement-Ganzzahl mit Vorzeichen.

• Der Mindestwert beträgt - 2.147.483.648 (-2 ^ 31)

• Der Maximalwert beträgt 2.147.483.647 (einschließlich) (2 ^ 31 -1)

• Ganzzahl wird im Allgemeinen als Standarddatentyp für Integralwerte verwendet, sofern keine Bedenken hinsichtlich des Speichers bestehen.

• Der Standardwert ist 0

• Beispiel: int a = 100000, int b = -200000

lange

• Der lange Datentyp ist eine 64-Bit-Ganzzahl mit vorzeichenbehafteten Zweierkomplementen
• Der Mindestwert beträgt -9.223.372.036.854.775.808 (-2 ^ 63)
• Der Maximalwert beträgt 9.223.372.036.854.775.807 (einschließlich) (2 ^ 63 -1)
• Dieser Typ wird verwendet, wenn ein größerer Bereich als int benötigt wird
• Der Standardwert ist 0L
• Beispiel: long a = 100000L, long b = -200000L

schweben

• Der Float-Datentyp ist ein 32-Bit-IEEE 754-Gleitkomma mit einfacher Genauigkeit

• Float wird hauptsächlich verwendet, um Speicher in großen Arrays von Gleitkommazahlen zu sparen

• Der Standardwert ist 0.0f

• Der Float-Datentyp wird niemals für genaue Werte wie Währung verwendet

• Beispiel: float f1 = 234.5f

doppelt

• Der doppelte Datentyp ist ein 64-Bit-IEEE 754-Gleitkomma mit doppelter Genauigkeit

• Dieser Datentyp wird im Allgemeinen als Standarddatentyp für Dezimalwerte verwendet, im Allgemeinen als Standardauswahl

• Der doppelte Datentyp sollte niemals für genaue Werte wie Währung verwendet werden

• Der Standardwert ist 0.0d

• Beispiel: double d1 = 123.4

Boolescher Wert

• Der boolesche Datentyp repräsentiert ein Informationsbit
• Es gibt nur zwei mögliche Werte: wahr und falsch
• Dieser Datentyp wird für einfache Flags verwendet, die True / False-Bedingungen verfolgen
• Der Standardwert ist false
• Beispiel: boolean one = true

verkohlen

• Der Datentyp char ist ein einzelnes 16-Bit-Unicode-Zeichen
• Der Mindestwert ist '\ u0000' (oder 0).
• Der Maximalwert ist '\ uffff' (oder 65.535 einschließlich)
• Der Char-Datentyp wird zum Speichern eines beliebigen Zeichens verwendet
• Beispiel: char letterA = 'A'

Referenzdatentypen

• Referenzvariablen werden mit definierten Konstruktoren der Klassen erstellt. Sie werden verwendet, um auf Objekte zuzugreifen. Diese Variablen werden als von einem bestimmten Typ deklariert, der nicht geändert werden kann. Zum Beispiel Mitarbeiter, Welpe usw.

• Klassenobjekte und verschiedene Arten von Arrayvariablen fallen unter den Referenzdatentyp.

• Der Standardwert einer Referenzvariablen ist null.

• Eine Referenzvariable kann verwendet werden, um auf jedes Objekt des deklarierten Typs oder einen kompatiblen Typ zu verweisen.

• Beispiel: Tier Tier = neues Tier ("Giraffe");

Java-Literale

Ein Literal ist eine Quellcodedarstellung eines festen Werts. Sie werden ohne Berechnung direkt im Code dargestellt.

Literale können jeder primitiven Typvariablen zugewiesen werden. Zum Beispiel -

byte a = 68;
char a = 'A';

Byte, Int, Long und Short können auch in Dezimal- (Basis 10), Hexadezimal- (Basis 16) oder Oktal- (Basis 8) Zahlensystemen ausgedrückt werden.

Das Präfix 0 wird zur Angabe von Oktal verwendet, und das Präfix 0x gibt Hexadezimal an, wenn diese Zahlensysteme für Literale verwendet werden. Zum Beispiel -

int decimal = 100;
int octal = 0144;
int hexa =  0x64;

String-Literale in Java werden wie in den meisten anderen Sprachen angegeben, indem eine Zeichenfolge zwischen zwei Anführungszeichen gesetzt wird. Beispiele für String-Literale sind -

Beispiel

"Hello World"
"two\nlines"
"\"This is in quotes\""

String- und char-Literaltypen können beliebige Unicode-Zeichen enthalten. Zum Beispiel -

char a = '\u0001';
String a = "\u0001";

Die Java-Sprache unterstützt auch einige spezielle Escape-Sequenzen für String- und Char-Literale. Sie sind -

Notation	Zeichen dargestellt
\ n	Newline (0x0a)
\ r	Wagenrücklauf (0x0d)
\ f	Formfeed (0x0c)
\ b	Rücktaste (0x08)
\ s	Leerzeichen (0x20)
\ t	Tab
""	Doppeltes Zitat
\ '	Einfaches Zitat
\\	Backslash
\ ddd	Oktalzeichen (ddd)
\ uxxxx	Hexadezimales UNICODE-Zeichen (xxxx)

Was kommt als nächstes?

In diesem Kapitel wurden die verschiedenen Datentypen erläutert. Im nächsten Thema werden verschiedene Variablentypen und ihre Verwendung erläutert. Auf diese Weise erhalten Sie ein gutes Verständnis dafür, wie sie in Java-Klassen, -Schnittstellen usw. verwendet werden können.

Eine Variable stellt uns einen benannten Speicher zur Verfügung, den unsere Programme bearbeiten können. Jede Variable in Java hat einen bestimmten Typ, der die Größe und das Layout des Speichers der Variablen bestimmt. den Wertebereich, der in diesem Speicher gespeichert werden kann; und die Menge von Operationen, die auf die Variable angewendet werden können.

Sie müssen alle Variablen deklarieren, bevor sie verwendet werden können. Es folgt die Grundform einer Variablendeklaration -

data type variable [ = value][, variable [ = value] ...] ;

Hier Datentyp ist eine der Java - Datentypen und Variable ist der Name der Variablen. Um mehr als eine Variable des angegebenen Typs zu deklarieren, können Sie eine durch Kommas getrennte Liste verwenden.

Im Folgenden finden Sie gültige Beispiele für die Deklaration und Initialisierung von Variablen in Java:

Beispiel

int a, b, c;         // Declares three ints, a, b, and c.
int a = 10, b = 10;  // Example of initialization
byte B = 22;         // initializes a byte type variable B.
double pi = 3.14159; // declares and assigns a value of PI.
char a = 'A';        // the char variable a iis initialized with value 'a'

In diesem Kapitel werden verschiedene in Java Language verfügbare Variablentypen erläutert. In Java gibt es drei Arten von Variablen:

• Lokale Variablen
• Instanzvariablen
• Klassen- / statische Variablen

Lokale Variablen

• Lokale Variablen werden in Methoden, Konstruktoren oder Blöcken deklariert.

• Lokale Variablen werden erstellt, wenn die Methode, der Konstruktor oder der Block eingegeben wird, und die Variable wird zerstört, sobald sie die Methode, den Konstruktor oder den Block beendet.

• Zugriffsmodifikatoren können nicht für lokale Variablen verwendet werden.

• Lokale Variablen sind nur innerhalb der deklarierten Methode, des Konstruktors oder des Blocks sichtbar.

• Lokale Variablen werden intern auf Stapelebene implementiert.

• Es gibt keinen Standardwert für lokale Variablen, daher sollten lokale Variablen deklariert und vor der ersten Verwendung ein Anfangswert zugewiesen werden.

Beispiel

Hier ist das Alter eine lokale Variable. Dies wird in der pupAge () -Methode definiert und ist nur auf diese Methode beschränkt.

public class Test {
   public void pupAge() {
      int age = 0;
      age = age + 7;
      System.out.println("Puppy age is : " + age);
   }

   public static void main(String args[]) {
      Test test = new Test();
      test.pupAge();
   }
}

Dies führt zu folgendem Ergebnis:

Ausgabe

Puppy age is: 7

Beispiel

Im folgenden Beispiel wird age verwendet, ohne es zu initialisieren, sodass beim Kompilieren ein Fehler auftritt.

public class Test {
   public void pupAge() {
      int age;
      age = age + 7;
      System.out.println("Puppy age is : " + age);
   }

   public static void main(String args[]) {
      Test test = new Test();
      test.pupAge();
   }
}

Dies führt beim Kompilieren zu folgendem Fehler:

Ausgabe

Test.java:4:variable number might not have been initialized
age = age + 7;
         ^
1 error

Instanzvariablen

• Instanzvariablen werden in einer Klasse deklariert, jedoch außerhalb einer Methode, eines Konstruktors oder eines beliebigen Blocks.

• Wenn einem Objekt im Heap ein Speicherplatz zugewiesen wird, wird ein Slot für jeden Wert der Instanzvariablen erstellt.

• Instanzvariablen werden erstellt, wenn ein Objekt mit dem Schlüsselwort 'new' erstellt wird, und zerstört, wenn das Objekt zerstört wird.

• Instanzvariablen enthalten Werte, auf die von mehr als einer Methode, einem Konstruktor oder Block verwiesen werden muss, oder wesentliche Teile des Status eines Objekts, die in der gesamten Klasse vorhanden sein müssen.

• Instanzvariablen können vor oder nach der Verwendung auf Klassenebene deklariert werden.

• Zugriffsmodifikatoren können zum Beispiel Variablen angegeben werden.

• Die Instanzvariablen sind für alle Methoden, Konstruktoren und Blöcke in der Klasse sichtbar. Normalerweise wird empfohlen, diese Variablen privat zu machen (Zugriffsebene). Die Sichtbarkeit für Unterklassen kann jedoch für diese Variablen unter Verwendung von Zugriffsmodifikatoren gegeben werden.

• Instanzvariablen haben Standardwerte. Für Zahlen ist der Standardwert 0, für Boolesche Werte ist er falsch und für Objektreferenzen ist er null. Werte können während der Deklaration oder innerhalb des Konstruktors zugewiesen werden.

• Auf Instanzvariablen kann direkt zugegriffen werden, indem der Variablenname innerhalb der Klasse aufgerufen wird. Innerhalb statischer Methoden (wenn Instanzvariablen zugänglich sind) sollten sie jedoch unter Verwendung des vollständig qualifizierten Namens aufgerufen werden. ObjectReference.VariableName .

Beispiel

import java.io.*;
public class Employee {

   // this instance variable is visible for any child class.
   public String name;

   // salary  variable is visible in Employee class only.
   private double salary;

   // The name variable is assigned in the constructor.
   public Employee (String empName) {
      name = empName;
   }

   // The salary variable is assigned a value.
   public void setSalary(double empSal) {
      salary = empSal;
   }

   // This method prints the employee details.
   public void printEmp() {
      System.out.println("name  : " + name );
      System.out.println("salary :" + salary);
   }

   public static void main(String args[]) {
      Employee empOne = new Employee("Ransika");
      empOne.setSalary(1000);
      empOne.printEmp();
   }
}

Dies führt zu folgendem Ergebnis:

Ausgabe

name  : Ransika
salary :1000.0

Klassen- / statische Variablen

• Klassenvariablen, auch als statische Variablen bezeichnet, werden mit dem Schlüsselwort static in einer Klasse deklariert, jedoch außerhalb einer Methode, eines Konstruktors oder eines Blocks.

• Es würde nur eine Kopie jeder Klassenvariablen pro Klasse geben, unabhängig davon, wie viele Objekte daraus erstellt werden.

• Statische Variablen werden nur selten verwendet, außer als Konstanten deklariert zu werden. Konstanten sind Variablen, die als öffentlich / privat, endgültig und statisch deklariert sind. Konstante Variablen ändern sich nie von ihrem Anfangswert.

• Statische Variablen werden im statischen Speicher gespeichert. Es ist selten, andere statische Variablen als deklariert als final zu verwenden und entweder als öffentliche oder private Konstanten zu verwenden.

• Statische Variablen werden beim Starten des Programms erstellt und beim Stoppen des Programms zerstört.

• Die Sichtbarkeit ähnelt Instanzvariablen. Die meisten statischen Variablen werden jedoch als öffentlich deklariert, da sie für Benutzer der Klasse verfügbar sein müssen.

• Standardwerte sind dieselben wie Instanzvariablen. Für Zahlen ist der Standardwert 0; für Boolesche ist es falsch; und für Objektreferenzen ist es null. Werte können während der Deklaration oder innerhalb des Konstruktors zugewiesen werden. Zusätzlich können Werte in speziellen statischen Initialisierungsblöcken zugewiesen werden.

• Auf statische Variablen kann durch Aufrufen mit dem Klassennamen ClassName.VariableName zugegriffen werden .

• Wenn Klassenvariablen als öffentliches statisches Finale deklariert werden, werden Variablennamen (Konstanten) alle in Großbuchstaben geschrieben. Wenn die statischen Variablen nicht öffentlich und endgültig sind, entspricht die Benennungssyntax der Instanz und den lokalen Variablen.

Beispiel

import java.io.*;
public class Employee {

   // salary  variable is a private static variable
   private static double salary;

   // DEPARTMENT is a constant
   public static final String DEPARTMENT = "Development ";

   public static void main(String args[]) {
      salary = 1000;
      System.out.println(DEPARTMENT + "average salary:" + salary);
   }
}

Dies führt zu folgendem Ergebnis:

Ausgabe

Development average salary:1000

Note - Wenn auf die Variablen von einer externen Klasse aus zugegriffen wird, sollte auf die Konstante als Employee.DEPARTMENT zugegriffen werden

Was kommt als nächstes?

Sie haben in diesem Kapitel bereits Zugriffsmodifikatoren (öffentlich und privat) verwendet. Im nächsten Kapitel werden Zugriffsmodifikatoren und Nichtzugriffsmodifikatoren ausführlich erläutert.

Modifikatoren sind Schlüsselwörter, die Sie diesen Definitionen hinzufügen, um ihre Bedeutung zu ändern. Die Java-Sprache verfügt über eine Vielzahl von Modifikatoren, darunter die folgenden:

• Java Access Modifiers

• Nichtzugriffsmodifikatoren

Um einen Modifikator zu verwenden, fügen Sie sein Schlüsselwort in die Definition einer Klasse, Methode oder Variablen ein. Der Modifikator steht wie im folgenden Beispiel vor dem Rest der Anweisung.

Beispiel

public class className {
   // ...
}

private boolean myFlag;
static final double weeks = 9.5;
protected static final int BOXWIDTH = 42;

public static void main(String[] arguments) {
   // body of method
}

Zugriffssteuerungsmodifikatoren

Java bietet eine Reihe von Zugriffsmodifikatoren zum Festlegen von Zugriffsebenen für Klassen, Variablen, Methoden und Konstruktoren. Die vier Zugriffsebenen sind -

• Sichtbar für das Paket, die Standardeinstellung. Es werden keine Modifikatoren benötigt.
• Nur für die Klasse sichtbar (privat).
• Sichtbar für die Welt (öffentlich).
• Sichtbar für das Paket und alle Unterklassen (geschützt).

Nichtzugriffsmodifikatoren

Java bietet eine Reihe von Nichtzugriffsmodifikatoren, um viele andere Funktionen zu erreichen.

• Der statische Modifikator zum Erstellen von Klassenmethoden und -variablen.

• Der letzte Modifikator zum Abschließen der Implementierungen von Klassen, Methoden und Variablen.

• Der abstrakte Modifikator zum Erstellen abstrakter Klassen und Methoden.

• Die synchronisierten und flüchtigen Modifikatoren, die für Threads verwendet werden.

Was kommt als nächstes?

Im nächsten Abschnitt werden wir uns mit den in Java Language verwendeten Basisoperatoren befassen. Das Kapitel gibt Ihnen einen Überblick darüber, wie diese Operatoren während der Anwendungsentwicklung verwendet werden können.

Java bietet eine Vielzahl von Operatoren zum Bearbeiten von Variablen. Wir können alle Java-Operatoren in die folgenden Gruppen einteilen:

• Rechenzeichen
• Vergleichsoperatoren
• Bitweise Operatoren
• Logische Operatoren
• Zuweisungsoperatoren
• Verschiedene Operatoren

Die arithmetischen Operatoren

Arithmetische Operatoren werden in mathematischen Ausdrücken genauso verwendet wie in der Algebra. In der folgenden Tabelle sind die arithmetischen Operatoren aufgeführt.

Angenommen, die ganzzahlige Variable A enthält 10 und die Variable B 20, dann -

Beispiele anzeigen

Operator	Beschreibung	Beispiel
+ (Ergänzung)	Fügt Werte auf beiden Seiten des Operators hinzu.	A + B ergibt 30
- (Subtraktion)	Subtrahiert den rechten Operanden vom linken Operanden.	A - B ergibt -10
* (Multiplikation)	Multipliziert Werte auf beiden Seiten des Operators.	A * B ergibt 200
/ (Teilung)	Teilt den linken Operanden durch den rechten Operanden.	B / A ergibt 2
% (Modul)	Teilt den linken Operanden durch den rechten Operanden und gibt den Rest zurück.	B% A ergibt 0
++ (Inkrement)	Erhöht den Wert des Operanden um 1.	B ++ ergibt 21
- (Dekrement)	Verringert den Wert des Operanden um 1.	B-- gibt 19

Die Vergleichsoperatoren

Es gibt folgende relationale Operatoren, die von der Java-Sprache unterstützt werden.

Angenommen, Variable A hält 10 und Variable B hält 20, dann -

Beispiele anzeigen

Operator	Beschreibung	Beispiel
== (gleich)	Überprüft, ob die Werte von zwei Operanden gleich sind oder nicht. Wenn ja, wird die Bedingung wahr.	(A == B) ist nicht wahr.
! = (ungleich)	Überprüft, ob die Werte von zwei Operanden gleich sind oder nicht. Wenn die Werte nicht gleich sind, wird die Bedingung wahr.	(A! = B) ist wahr.
> (größer als)	Überprüft, ob der Wert des linken Operanden größer als der Wert des rechten Operanden ist. Wenn ja, wird die Bedingung wahr.	(A> B) ist nicht wahr.
<(weniger als)	Überprüft, ob der Wert des linken Operanden kleiner als der Wert des rechten Operanden ist. Wenn ja, wird die Bedingung wahr.	(A <B) ist wahr.
> = (größer oder gleich)	Überprüft, ob der Wert des linken Operanden größer oder gleich dem Wert des rechten Operanden ist. Wenn ja, wird die Bedingung wahr.	(A> = B) ist nicht wahr.
<= (kleiner oder gleich)	Überprüft, ob der Wert des linken Operanden kleiner oder gleich dem Wert des rechten Operanden ist. Wenn ja, wird die Bedingung wahr.	(A <= B) ist wahr.

Die bitweisen Operatoren

Java definiert mehrere bitweise Operatoren, die auf die Ganzzahltypen long, int, short, char und byte angewendet werden können.

Der bitweise Operator arbeitet mit Bits und führt eine bitweise Operation durch. Angenommen, a = 60 und b = 13; jetzt im Binärformat werden sie wie folgt sein -

a = 0011 1100

b = 0000 1101

-----------------

a & b = 0000 1100

a | b = 0011 1101

a ^ b = 0011 0001

~ a = 1100 0011

In der folgenden Tabelle sind die bitweisen Operatoren aufgeführt -

Angenommen, die ganzzahlige Variable A hält 60 und die Variable B hält 13, dann -

Beispiele anzeigen

Operator	Beschreibung	Beispiel
& (bitweise und)	Der binäre UND-Operator kopiert ein Bit in das Ergebnis, wenn es in beiden Operanden vorhanden ist.	(A & B) ergibt 12, was 0000 1100 ist
| (bitweise oder)	Der binäre ODER-Operator kopiert ein Bit, wenn es in einem der Operanden vorhanden ist.	(A | B) ergibt 61, was 0011 1101 ist
^ (bitweises XOR)	Der binäre XOR-Operator kopiert das Bit, wenn es in einem Operanden gesetzt ist, aber nicht in beiden.	(A ^ B) ergibt 49, was 0011 0001 ist
~ (bitweises Kompliment)	Der Komplementoperator für binäre Einsen ist unär und bewirkt das Umdrehen von Bits.	(~ A) ergibt -61, was aufgrund einer vorzeichenbehafteten Binärzahl 1100 0011 in 2er-Komplementform ist.
<< (Linksverschiebung)	Binärer Linksschaltoperator. Der Wert der linken Operanden wird um die Anzahl der vom rechten Operanden angegebenen Bits nach links verschoben.	Ein << 2 ergibt 240, was 1111 0000 ist
>> (Rechtsverschiebung)	Binärer Rechtsschieber. Der Wert der linken Operanden wird um die Anzahl der vom rechten Operanden angegebenen Bits nach rechts verschoben.	Eine >> 2 ergibt 15, was 1111 ist
>>> (Nullfüllung rechtsverschiebung)	Verschieben Sie den Nullfüllungsoperator nach rechts. Der Wert der linken Operanden wird um die vom rechten Operanden angegebene Anzahl von Bits nach rechts verschoben, und verschobene Werte werden mit Nullen gefüllt.	Eine >>> 2 ergibt 15, was 0000 1111 ist

Die logischen Operatoren

In der folgenden Tabelle sind die logischen Operatoren aufgeführt.

Angenommen, die booleschen Variablen A sind wahr und die Variable B ist falsch, dann -

Beispiele anzeigen

Operator	Beschreibung	Beispiel
&& (logisch und)	Wird als logischer UND-Operator bezeichnet. Wenn beide Operanden ungleich Null sind, wird die Bedingung wahr.	(A && B) ist falsch
|| (logisch oder)	Wird als logischer ODER-Operator bezeichnet. Wenn einer der beiden Operanden ungleich Null ist, wird die Bedingung erfüllt.	(A || B) ist wahr
! (logisch nicht)	Wird als logischer NICHT-Operator bezeichnet. Verwenden Sie diese Option, um den logischen Status des Operanden umzukehren. Wenn eine Bedingung wahr ist, macht der Operator Logical NOT false.	! (A && B) ist wahr

Die Zuweisungsoperatoren

Im Folgenden sind die Zuweisungsoperatoren aufgeführt, die von der Java-Sprache unterstützt werden:

Beispiele anzeigen

Operator	Beschreibung	Beispiel
=	Einfacher Zuweisungsoperator. Weist dem linken Operanden Werte von Operanden auf der rechten Seite zu.	C = A + B weist C den Wert von A + B zu
+ =	UND-Zuweisungsoperator hinzufügen. Es fügt dem linken Operanden den rechten Operanden hinzu und weist das Ergebnis dem linken Operanden zu.	C + = A entspricht C = C + A.
- =	UND-Zuweisungsoperator subtrahieren. Es subtrahiert den rechten Operanden vom linken Operanden und weist das Ergebnis dem linken Operanden zu.	C - = A entspricht C = C - A.
* =	Multiplizieren UND Zuweisungsoperator. Es multipliziert den rechten Operanden mit dem linken Operanden und weist das Ergebnis dem linken Operanden zu.	C * = A entspricht C = C * A.
/ =	Divide AND Zuweisungsoperator. Es teilt den linken Operanden mit dem rechten Operanden und weist das Ergebnis dem linken Operanden zu.	C / = A entspricht C = C / A.
% =	Modul UND Zuweisungsoperator. Es nimmt den Modul mit zwei Operanden und ordnet das Ergebnis dem linken Operanden zu.	C% = A entspricht C = C% A.
<< =	Linksverschiebung UND Zuweisungsoperator.	C << = 2 ist dasselbe wie C = C << 2
>> =	Rechtsverschiebung UND Zuweisungsoperator.	C >> = 2 ist dasselbe wie C = C >> 2
& =	Bitweiser UND-Zuweisungsoperator.	C & = 2 ist dasselbe wie C = C & 2
^ =	bitweises exklusives ODER und Zuweisungsoperator.	C ^ = 2 ist dasselbe wie C = C ^ 2
| =	bitweises Inklusiv-ODER und Zuweisungsoperator.	C | = 2 ist dasselbe wie C = C | 2

Verschiedene Betreiber

Es gibt nur wenige andere Operatoren, die von Java Language unterstützt werden.

Bedingter Operator (? :)

Der bedingte Operator wird auch als bezeichnet ternary operator. Dieser Operator besteht aus drei Operanden und wird zum Auswerten von Booleschen Ausdrücken verwendet. Ziel des Operators ist es, zu entscheiden, welcher Wert der Variablen zugewiesen werden soll. Der Operator wird geschrieben als -

variable x = (expression) ? value if true : value if false

Das Folgende ist ein Beispiel -

Example

public class Test {

   public static void main(String args[]) {
      int a, b;
      a = 10;
      b = (a == 1) ? 20: 30;
      System.out.println( "Value of b is : " +  b );

      b = (a == 10) ? 20: 30;
      System.out.println( "Value of b is : " + b );
   }
}

Dies führt zu folgendem Ergebnis:

Output

Value of b is : 30
Value of b is : 20

Instanz des Betreibers

Dieser Operator wird nur für Objektreferenzvariablen verwendet. Der Operator prüft, ob das Objekt von einem bestimmten Typ ist (Klassentyp oder Schnittstellentyp). Instanz des Operators wird geschrieben als -

( Object reference variable ) instanceof  (class/interface type)

Wenn das Objekt, auf das die Variable auf der linken Seite des Operators verweist, die IS-A-Prüfung für den Klassen- / Schnittstellentyp auf der rechten Seite besteht, ist das Ergebnis wahr. Das Folgende ist ein Beispiel -

Example

public class Test {

   public static void main(String args[]) {

      String name = "James";

      // following will return true since name is type of String
      boolean result = name instanceof String;
      System.out.println( result );
   }
}

Dies führt zu folgendem Ergebnis:

Output

true

Dieser Operator gibt weiterhin true zurück, wenn das zu vergleichende Objekt die Zuordnung ist, die mit dem Typ rechts kompatibel ist. Es folgt ein weiteres Beispiel:

Example

class Vehicle {}

public class Car extends Vehicle {

   public static void main(String args[]) {

      Vehicle a = new Car();
      boolean result =  a instanceof Car;
      System.out.println( result );
   }
}

Dies führt zu folgendem Ergebnis:

Output

true

Vorrang von Java-Operatoren

Die Operatorrangfolge bestimmt die Gruppierung von Begriffen in einem Ausdruck. Dies wirkt sich darauf aus, wie ein Ausdruck ausgewertet wird. Bestimmte Operatoren haben eine höhere Priorität als andere. Beispielsweise hat der Multiplikationsoperator eine höhere Priorität als der Additionsoperator -

Zum Beispiel ist x = 7 + 3 * 2; Hier wird x 13 zugewiesen, nicht 20, da der Operator * eine höhere Priorität als + hat. Daher wird er zuerst mit 3 * 2 multipliziert und dann zu 7 addiert.

Hier werden Operatoren mit der höchsten Priorität oben in der Tabelle angezeigt, Operatoren mit der niedrigsten Priorität unten. Innerhalb eines Ausdrucks werden zuerst Operatoren mit höherer Priorität ausgewertet.

Kategorie	Operator	Assoziativität
Postfix	Ausdruck ++ Ausdruck--	Links nach rechts
Einstellig	++ Ausdruck –-Ausdruck + Ausdruck –Ausdruck ~!	Rechts nach links
Multiplikativ	* /%	Links nach rechts
Zusatzstoff	+ -	Links nach rechts
Verschiebung	<< >> >>>	Links nach rechts
Relational	<> <=> = instanceof	Links nach rechts
Gleichberechtigung	==! =	Links nach rechts
Bitweises UND	&	Links nach rechts
Bitweises XOR	^	Links nach rechts
Bitweises ODER	|	Links nach rechts
Logisches UND	&&	Links nach rechts
Logisches ODER	||	Links nach rechts
Bedingt	?:	Rechts nach links
Zuordnung	= + = - = * = / =% = ^ = | = << = >> = >>> =	Rechts nach links

Was kommt als nächstes?

Im nächsten Kapitel wird die Schleifensteuerung in der Java-Programmierung erläutert. In diesem Kapitel werden verschiedene Arten von Schleifen beschrieben und wie diese Schleifen in der Java-Programmentwicklung verwendet werden können und für welche Zwecke sie verwendet werden.

Es kann vorkommen, dass Sie einen Codeblock mehrmals ausführen müssen. Im Allgemeinen werden Anweisungen nacheinander ausgeführt: Die erste Anweisung in einer Funktion wird zuerst ausgeführt, gefolgt von der zweiten usw.

Programmiersprachen bieten verschiedene Steuerungsstrukturen, die kompliziertere Ausführungspfade ermöglichen.

EIN loop Anweisung ermöglicht es uns, eine Anweisung oder eine Gruppe von Anweisungen mehrmals auszuführen. Im Folgenden wird die allgemeine Form einer Schleifenanweisung in den meisten Programmiersprachen beschrieben:

Die Programmiersprache Java bietet die folgenden Arten von Schleifen, um die Schleifenanforderungen zu erfüllen. Klicken Sie auf die folgenden Links, um deren Details zu überprüfen.

Sr.Nr.	Schleife & Beschreibung
1	while-Schleife Wiederholt eine Anweisung oder eine Gruppe von Anweisungen, während eine bestimmte Bedingung erfüllt ist. Es testet die Bedingung, bevor der Schleifenkörper ausgeführt wird.
2	für Schleife Führen Sie eine Folge von Anweisungen mehrmals aus und kürzen Sie den Code ab, der die Schleifenvariable verwaltet.
3	do ... while-Schleife Wie eine while-Anweisung, nur dass sie die Bedingung am Ende des Schleifenkörpers testet.

Schleifensteuerungsanweisungen

Schleifensteueranweisungen ändern die Ausführung von ihrer normalen Reihenfolge. Wenn die Ausführung einen Bereich verlässt, werden alle automatischen Objekte, die in diesem Bereich erstellt wurden, zerstört.

Java unterstützt die folgenden Steueranweisungen. Klicken Sie auf die folgenden Links, um deren Details zu überprüfen.

Sr.Nr.	Steueranweisung & Beschreibung
1	break-Anweisung Beendet die loop oder switch Anweisung und überträgt die Ausführung an die Anweisung unmittelbar nach der Schleife oder dem Schalter.
2	Aussage fortsetzen Bewirkt, dass die Schleife den Rest ihres Körpers überspringt und ihren Zustand sofort erneut testet, bevor sie wiederholt wird.

Erweiterte for-Schleife in Java

Ab Java 5 wurde die erweiterte for-Schleife eingeführt. Dies wird hauptsächlich verwendet, um die Sammlung von Elementen einschließlich Arrays zu durchlaufen.

Syntax

Es folgt die Syntax von Enhanced for Loop -

for(declaration : expression) {
   // Statements
}

• Declaration- Die neu deklarierte Blockvariable ist von einem Typ, der mit den Elementen des Arrays kompatibel ist, auf das Sie zugreifen. Die Variable ist im for-Block verfügbar und ihr Wert entspricht dem aktuellen Array-Element.

• Expression- Dies ergibt das Array, das Sie durchlaufen müssen. Der Ausdruck kann eine Arrayvariable oder ein Methodenaufruf sein, der ein Array zurückgibt.

Beispiel

public class Test {

   public static void main(String args[]) {
      int [] numbers = {10, 20, 30, 40, 50};

      for(int x : numbers ) {
         System.out.print( x );
         System.out.print(",");
      }
      System.out.print("\n");
      String [] names = {"James", "Larry", "Tom", "Lacy"};

      for( String name : names ) {
         System.out.print( name );
         System.out.print(",");
      }
   }
}

Dies führt zu folgendem Ergebnis:

Ausgabe

10, 20, 30, 40, 50,
James, Larry, Tom, Lacy,

Was kommt als nächstes?

Im folgenden Kapitel lernen wir die Entscheidungsfindung in der Java-Programmierung kennen.

Entscheidungsstrukturen haben eine oder mehrere Bedingungen, die vom Programm bewertet oder getestet werden müssen, zusammen mit einer Anweisung oder Anweisungen, die ausgeführt werden sollen, wenn die Bedingung als wahr bestimmt wird, und optional anderen Anweisungen, die ausgeführt werden sollen, wenn die Bedingung bestimmt wird falsch sein.

Es folgt die allgemeine Form einer typischen Entscheidungsstruktur, die in den meisten Programmiersprachen zu finden ist:

Die Programmiersprache Java bietet die folgenden Arten von Entscheidungsbefehlen. Klicken Sie auf die folgenden Links, um deren Details zu überprüfen.

Sr.Nr.	Aussage & Beschreibung
1	if-Anweisung Ein if statement besteht aus einem booleschen Ausdruck, gefolgt von einer oder mehreren Anweisungen.
2	if ... else-Anweisung Ein if statement kann von einem optionalen gefolgt werden else statement, wird ausgeführt, wenn der boolesche Ausdruck false ist.
3	verschachtelte if-Anweisung Sie können eine verwenden if oder else if Aussage in einem anderen if oder else if Aussage (n).
4	switch-Anweisung EIN switch Mit der Anweisung kann eine Variable auf Gleichheit mit einer Liste von Werten getestet werden.

Das ? : Operator

Wir haben abgedeckt conditional operator ? : im vorherigen Kapitel, das zum Ersetzen verwendet werden kann if...elseAussagen. Es hat die folgende allgemeine Form -

Exp1 ? Exp2 : Exp3;

Wobei Exp1, Exp2 und Exp3 Ausdrücke sind. Beachten Sie die Verwendung und Platzierung des Doppelpunkts.

Um den Wert des gesamten Ausdrucks zu bestimmen, wird zunächst exp1 ausgewertet.

• Wenn der Wert von exp1 wahr ist, ist der Wert von Exp2 der Wert des gesamten Ausdrucks.

• Wenn der Wert von exp1 falsch ist, wird Exp3 ausgewertet und sein Wert wird zum Wert des gesamten Ausdrucks.

Was kommt als nächstes?

Im nächsten Kapitel werden wir die Number-Klasse (im Paket java.lang) und ihre Unterklassen in Java Language diskutieren.

Wir werden einige Situationen untersuchen, in denen Sie Instanziierungen dieser Klassen anstelle der primitiven Datentypen verwenden, sowie Klassen wie Formatierung und mathematische Funktionen, die Sie bei der Arbeit mit Zahlen kennen müssen.

Wenn wir mit Zahlen arbeiten, verwenden wir normalerweise primitive Datentypen wie Byte, Int, Long, Double usw.

Beispiel

int i = 5000;
float gpa = 13.65f;
double mask = 125;

In der Entwicklung stoßen wir jedoch auf Situationen, in denen wir Objekte anstelle primitiver Datentypen verwenden müssen. Um dies zu erreichen, bietet Javawrapper classes.

Alle Wrapper-Klassen (Integer, Long, Byte, Double, Float, Short) sind Unterklassen der abstrakten Klassennummer.

Das Objekt der Wrapper-Klasse enthält oder umschließt seinen jeweiligen primitiven Datentyp. Das Konvertieren primitiver Datentypen in Objekte wird aufgerufenboxing, und dies wird vom Compiler erledigt. Daher müssen Sie bei Verwendung einer Wrapper-Klasse nur den Wert des primitiven Datentyps an den Konstruktor der Wrapper-Klasse übergeben.

Das Wrapper-Objekt wird wieder in einen primitiven Datentyp konvertiert, und dieser Vorgang wird als Unboxing bezeichnet. DasNumber Klasse ist Teil des Pakets java.lang.

Das Folgende ist ein Beispiel für Boxen und Unboxen -

Beispiel

public class Test {

   public static void main(String args[]) {
      Integer x = 5; // boxes int to an Integer object
      x =  x + 10;   // unboxes the Integer to a int
      System.out.println(x); 
   }
}

Dies führt zu folgendem Ergebnis:

Ausgabe

15

Wenn x ein ganzzahliger Wert zugewiesen wird, boxt der Compiler die Ganzzahl, da x ein ganzzahliges Objekt ist. Später wird x entpackt, damit sie als Ganzzahl hinzugefügt werden können.

Zahlenmethoden

Im Folgenden finden Sie eine Liste der Instanzmethoden, die alle Unterklassen der Number-Klasse implementieren:

Sr.Nr.	Methode & Beschreibung
1	xxxValue () Konvertiert den Wert dieses Number-Objekts in den Datentyp xxx und gibt ihn zurück.
2	vergleichen mit() Vergleicht dieses Number-Objekt mit dem Argument.
3	gleich () Legt fest, ob dieses Zahlenobjekt dem Argument entspricht.
4	Wert von() Gibt ein Integer-Objekt zurück, das den Wert des angegebenen Grundelements enthält.
5	toString () Gibt ein String-Objekt zurück, das den Wert eines angegebenen int oder Integer darstellt.
6	parseInt () Diese Methode wird verwendet, um den primitiven Datentyp eines bestimmten Strings abzurufen.
7	Abs() Gibt den absoluten Wert des Arguments zurück.
8	Ceil () Gibt die kleinste Ganzzahl zurück, die größer oder gleich dem Argument ist. Als Doppelgänger zurückgegeben.
9	Fußboden() Gibt die größte Ganzzahl zurück, die kleiner oder gleich dem Argument ist. Als Doppelgänger zurückgegeben.
10	rint () Gibt die Ganzzahl zurück, deren Wert dem Argument am nächsten kommt. Als Doppelgänger zurückgegeben.
11	runden() Gibt das nächstgelegene long oder int zurück, wie durch den Rückgabetyp der Methode für das Argument angegeben.
12	Mindest() Gibt das kleinere der beiden Argumente zurück.
13	max () Gibt das größere der beiden Argumente zurück.
14	exp () Gibt die Basis der natürlichen Logarithmen e an die Potenz des Arguments zurück.
15	Log() Gibt den natürlichen Logarithmus des Arguments zurück.
16	pow () Gibt den Wert des ersten Arguments zurück, der zur Potenz des zweiten Arguments erhoben wird.
17	sqrt () Gibt die Quadratwurzel des Arguments zurück.
18	Sünde() Gibt den Sinus des angegebenen Doppelwerts zurück.
19	cos () Gibt den Cosinus des angegebenen Doppelwerts zurück.
20	bräunen() Gibt den Tangens des angegebenen Doppelwerts zurück.
21	wie in() Gibt den Arkussinus des angegebenen Doppelwerts zurück.
22	acos () Gibt den Arccosinus des angegebenen Doppelwerts zurück.
23	eine Lohe() Gibt den Arkustangens des angegebenen Doppelwerts zurück.
24	atan2 () Konvertiert rechteckige Koordinaten (x, y) in Polarkoordinaten (r, Theta) und gibt Theta zurück.
25	toDegrees () Konvertiert das Argument in Grad.
26	toRadians () Konvertiert das Argument in Bogenmaß.
27	zufällig() Gibt eine Zufallszahl zurück.

Was kommt als nächstes?

Im nächsten Abschnitt werden wir die Zeichenklasse in Java durchgehen. Sie lernen, wie Sie Objektzeichen und primitive Datentypen char in Java verwenden.

Wenn wir mit Zeichen arbeiten, verwenden wir normalerweise primitive Datentypen char.

Beispiel

char ch = 'a';

// Unicode for uppercase Greek omega character
char uniChar = '\u039A'; 

// an array of chars
char[] charArray ={ 'a', 'b', 'c', 'd', 'e' };

In der Entwicklung stoßen wir jedoch auf Situationen, in denen wir Objekte anstelle primitiver Datentypen verwenden müssen. Um dies zu erreichen, stellt Java eine Wrapper-Klasse bereitCharacter für primitiven Datentyp char.

Die Zeichenklasse bietet eine Reihe nützlicher Klassenmethoden (dh statische Methoden) zum Bearbeiten von Zeichen. Sie können ein Zeichenobjekt mit dem Zeichenkonstruktor erstellen -

Character ch = new Character('a');

Der Java-Compiler erstellt unter bestimmten Umständen auch ein Zeichenobjekt für Sie. Wenn Sie beispielsweise ein primitives Zeichen an eine Methode übergeben, die ein Objekt erwartet, konvertiert der Compiler das Zeichen automatisch in ein Zeichen für Sie. Diese Funktion wird als Autoboxing oder Unboxing bezeichnet, wenn die Konvertierung in die andere Richtung erfolgt.

Beispiel

// Here following primitive char 'a'
// is boxed into the Character object ch
Character ch = 'a';

// Here primitive 'x' is boxed for method test,
// return is unboxed to char 'c'
char c = test('x');

Escape-Sequenzen

Ein Zeichen mit vorangestelltem Backslash (\) ist eine Escape-Sequenz und hat für den Compiler eine besondere Bedeutung.

Das Zeilenumbruchzeichen (\ n) wurde in diesem Lernprogramm in den Anweisungen System.out.println () häufig verwendet, um nach dem Drucken der Zeichenfolge zur nächsten Zeile zu gelangen.

Die folgende Tabelle zeigt die Java-Escape-Sequenzen -

Fluchtabfolge	Beschreibung
\ t	Fügt an dieser Stelle eine Registerkarte in den Text ein.
\ b	Fügt an dieser Stelle eine Rücktaste in den Text ein.
\ n	Fügt an dieser Stelle eine neue Zeile in den Text ein.
\ r	Fügt an dieser Stelle einen Wagenrücklauf in den Text ein.
\ f	Fügt an dieser Stelle einen Formular-Feed in den Text ein.
\ '	Fügt an dieser Stelle ein einfaches Anführungszeichen in den Text ein.
""	Fügt an dieser Stelle ein doppeltes Anführungszeichen in den Text ein.
\\	Fügt an dieser Stelle ein Backslash-Zeichen in den Text ein.

Wenn in einer print-Anweisung eine Escape-Sequenz auftritt, interpretiert der Compiler diese entsprechend.

Beispiel

Wenn Sie Anführungszeichen in Anführungszeichen setzen möchten, müssen Sie die Escape-Sequenz "" für die inneren Anführungszeichen verwenden.

public class Test {

   public static void main(String args[]) {
      System.out.println("She said \"Hello!\" to me.");
   }
}

Dies führt zu folgendem Ergebnis:

Ausgabe

She said "Hello!" to me.

Zeichenmethoden

Im Folgenden finden Sie eine Liste der wichtigen Instanzmethoden, die alle Unterklassen der Zeichenklasse implementieren:

Sr.Nr.	Methode & Beschreibung
1	isLetter () Legt fest, ob der angegebene Zeichenwert ein Buchstabe ist.
2	isDigit () Legt fest, ob der angegebene Zeichenwert eine Ziffer ist.
3	isWhitespace () Legt fest, ob der angegebene Zeichenwert ein Leerzeichen ist.
4	isUpperCase () Legt fest, ob der angegebene Zeichenwert in Großbuchstaben angegeben ist.
5	isLowerCase () Legt fest, ob der angegebene Zeichenwert in Kleinbuchstaben geschrieben ist.
6	toUpperCase () Gibt die Großbuchstabenform des angegebenen Zeichenwerts zurück.
7	toLowerCase () Gibt die Kleinbuchstabenform des angegebenen Zeichenwerts zurück.
8	toString () Gibt ein String-Objekt zurück, das den angegebenen Zeichenwert darstellt, dh eine Zeichenfolge mit einem Zeichen.

Eine vollständige Liste der Methoden finden Sie in der API-Spezifikation java.lang.Character.

Was kommt als nächstes?

Im nächsten Abschnitt werden wir die String-Klasse in Java durchgehen. Sie lernen, wie Sie Strings effizient deklarieren und verwenden sowie einige der wichtigen Methoden in der String-Klasse.

Zeichenfolgen, die in der Java-Programmierung weit verbreitet sind, sind eine Folge von Zeichen. In der Programmiersprache Java werden Zeichenfolgen als Objekte behandelt.

Die Java-Plattform bietet die String-Klasse zum Erstellen und Bearbeiten von Strings.

Strings erstellen

Der direkteste Weg, einen String zu erstellen, ist das Schreiben von -

String greeting = "Hello world!";

Immer wenn ein String-Literal in Ihrem Code auftritt, erstellt der Compiler ein String-Objekt mit dem Wert "Hallo Welt!".

Wie bei jedem anderen Objekt können Sie String-Objekte mit dem neuen Schlüsselwort und einem Konstruktor erstellen. Die String-Klasse verfügt über 11 Konstruktoren, mit denen Sie den Anfangswert des Strings unter Verwendung verschiedener Quellen, z. B. eines Array von Zeichen, angeben können.

Beispiel

public class StringDemo {

   public static void main(String args[]) {
      char[] helloArray = { 'h', 'e', 'l', 'l', 'o', '.' };
      String helloString = new String(helloArray);  
      System.out.println( helloString );
   }
}

Dies führt zu folgendem Ergebnis:

Ausgabe

hello.

Note- Die String-Klasse ist unveränderlich, sodass ein String-Objekt nach dem Erstellen nicht mehr geändert werden kann. Wenn viele Änderungen an Zeichenfolgen vorgenommen werden müssen, sollten Sie die Klassen String Buffer & String Builder verwenden .

String-Länge

Methoden zum Abrufen von Informationen über ein Objekt sind bekannt als accessor methods. Eine Zugriffsmethode, die Sie mit Zeichenfolgen verwenden können, ist die length () -Methode, die die Anzahl der im Zeichenfolgenobjekt enthaltenen Zeichen zurückgibt.

Das folgende Programm ist ein Beispiel für length(), Methode String-Klasse.

Beispiel

public class StringDemo {

   public static void main(String args[]) {
      String palindrome = "Dot saw I was Tod";
      int len = palindrome.length();
      System.out.println( "String Length is : " + len );
   }
}

Dies führt zu folgendem Ergebnis:

Ausgabe

String Length is : 17

Verketten von Strings

Die String-Klasse enthält eine Methode zum Verketten von zwei Strings -

string1.concat(string2);

Dies gibt eine neue Zeichenfolge zurück, die Zeichenfolge1 ist, und am Ende wird Zeichenfolge2 hinzugefügt. Sie können die concat () -Methode auch mit String-Literalen verwenden, wie in -

"My name is ".concat("Zara");

Zeichenfolgen werden häufiger mit dem Operator + verkettet, wie in -

"Hello," + " world" + "!"

was zu -

"Hello, world!"

Schauen wir uns das folgende Beispiel an:

Beispiel

public class StringDemo {

   public static void main(String args[]) {
      String string1 = "saw I was ";
      System.out.println("Dot " + string1 + "Tod");
   }
}

Dies führt zu folgendem Ergebnis:

Ausgabe

Dot saw I was Tod

Formatzeichenfolgen erstellen

Sie haben die Methoden printf () und format (), um Ausgaben mit formatierten Zahlen zu drucken. Die String-Klasse verfügt über eine äquivalente Klassenmethode, format (), die ein String-Objekt anstelle eines PrintStream-Objekts zurückgibt.

Mit der statischen format () -Methode von String können Sie eine formatierte Zeichenfolge erstellen, die Sie im Gegensatz zu einer einmaligen Druckanweisung wiederverwenden können. Zum Beispiel anstelle von -

Beispiel

System.out.printf("The value of the float variable is " +
                  "%f, while the value of the integer " +
                  "variable is %d, and the string " +
                  "is %s", floatVar, intVar, stringVar);

Sie können schreiben -

String fs;
fs = String.format("The value of the float variable is " +
                   "%f, while the value of the integer " +
                   "variable is %d, and the string " +
                   "is %s", floatVar, intVar, stringVar);
System.out.println(fs);

String-Methoden

Hier ist die Liste der Methoden, die von der String-Klasse unterstützt werden -

Sr.Nr.	Methode & Beschreibung
1	char charAt (int index) Gibt das Zeichen am angegebenen Index zurück.
2	int compareTo (Objekt o) Vergleicht diesen String mit einem anderen Objekt.
3	int compareTo (String anotherString) Vergleicht zwei Zeichenfolgen lexikografisch.
4	int compareToIgnoreCase (String str) Vergleicht zwei Zeichenfolgen lexikografisch und ignoriert dabei Fallunterschiede.
5	String concat (String str) Verkettet die angegebene Zeichenfolge mit dem Ende dieser Zeichenfolge.
6	boolean contentEquals (StringBuffer sb) Gibt nur dann true zurück, wenn dieser String dieselbe Zeichenfolge wie der angegebene StringBuffer darstellt.
7	statischer String copyValueOf (char [] data) Gibt eine Zeichenfolge zurück, die die Zeichenfolge im angegebenen Array darstellt.
8	statischer String copyValueOf (char [] Daten, int Offset, int count) Gibt eine Zeichenfolge zurück, die die Zeichenfolge im angegebenen Array darstellt.
9	Boolesche EndenWith (String-Suffix) Testet, ob diese Zeichenfolge mit dem angegebenen Suffix endet.
10	Boolescher Wert gleich (Object anObject) Vergleicht diese Zeichenfolge mit dem angegebenen Objekt.
11	boolean equalsIgnoreCase (String anotherString) Vergleicht diesen String mit einem anderen String und ignoriert dabei die Überlegungen zur Groß- und Kleinschreibung.
12	Byte getBytes () Codiert diesen String mit dem Standardzeichensatz der Plattform in eine Folge von Bytes und speichert das Ergebnis in einem neuen Byte-Array.
13	byte [] getBytes (String charsetName) Codiert diesen String mithilfe des benannten Zeichensatzes in eine Folge von Bytes und speichert das Ergebnis in einem neuen Byte-Array.
14	void getChars (int srcBegin, int srcEnd, char [] dst, int dstBegin) Kopiert Zeichen aus dieser Zeichenfolge in das Zielzeichenarray.
15	int hashCode () Gibt einen Hash-Code für diese Zeichenfolge zurück.
16	int indexOf (int ch) Gibt den Index innerhalb dieser Zeichenfolge des ersten Vorkommens des angegebenen Zeichens zurück.
17	int indexOf (int ch, int fromIndex) Gibt den Index innerhalb dieser Zeichenfolge des ersten Vorkommens des angegebenen Zeichens zurück und startet die Suche am angegebenen Index.
18	int indexOf (String str) Gibt den Index innerhalb dieser Zeichenfolge des ersten Auftretens des angegebenen Teilstrings zurück.
19	int indexOf (String str, int fromIndex) Gibt den Index innerhalb dieser Zeichenfolge des ersten Auftretens des angegebenen Teilstrings zurück, beginnend mit dem angegebenen Index.
20	String intern () Gibt eine kanonische Darstellung für das Zeichenfolgenobjekt zurück.
21	int lastIndexOf (int ch) Gibt den Index innerhalb dieser Zeichenfolge des letzten Vorkommens des angegebenen Zeichens zurück.
22	int lastIndexOf (int ch, int fromIndex) Gibt den Index innerhalb dieser Zeichenfolge des letzten Vorkommens des angegebenen Zeichens zurück und sucht ab dem angegebenen Index rückwärts.
23	int lastIndexOf (String str) Gibt den Index innerhalb dieser Zeichenfolge des Auftretens der angegebenen Teilzeichenfolge ganz rechts zurück.
24	int lastIndexOf (String str, int fromIndex) Gibt den Index innerhalb dieser Zeichenfolge des letzten Vorkommens der angegebenen Teilzeichenfolge zurück und sucht ab dem angegebenen Index rückwärts.
25	int length () Gibt die Länge dieser Zeichenfolge zurück.
26	Boolesche Übereinstimmungen (String regex) Gibt an, ob diese Zeichenfolge mit dem angegebenen regulären Ausdruck übereinstimmt.
27	boolean regionMatches (boolean ignoreCase, int toffset, String other, int ooffset, int len) Testet, ob zwei Zeichenfolgenbereiche gleich sind.
28	boolean regionMatches (int toffset, String other, int ooffset, int len) Testet, ob zwei Zeichenfolgenbereiche gleich sind.
29	String ersetzen (char oldChar, char newChar) Gibt eine neue Zeichenfolge zurück, die sich aus dem Ersetzen aller Vorkommen von oldChar in dieser Zeichenfolge durch newChar ergibt.
30	String replaceAll (String-Regex, String-Ersatz Ersetzt jeden Teilstring dieser Zeichenfolge, der dem angegebenen regulären Ausdruck entspricht, durch den angegebenen Ersatz.
31	String replaceFirst (String-Regex, String-Ersatz) Ersetzt den ersten Teilstring dieser Zeichenfolge, der dem angegebenen regulären Ausdruck entspricht, durch den angegebenen Ersatz.
32	String[] split(String regex) Splits this string around matches of the given regular expression.
33	String[] split(String regex, int limit) Splits this string around matches of the given regular expression.
34	boolean startsWith(String prefix) Tests if this string starts with the specified prefix.
35	boolean startsWith(String prefix, int toffset) Tests if this string starts with the specified prefix beginning a specified index.
36	CharSequence subSequence(int beginIndex, int endIndex) Returns a new character sequence that is a subsequence of this sequence.
37	String substring(int beginIndex) Returns a new string that is a substring of this string.
38	String substring(int beginIndex, int endIndex) Returns a new string that is a substring of this string.
39	char[] toCharArray() Converts this string to a new character array.
40	String toLowerCase() Converts all of the characters in this String to lower case using the rules of the default locale.
41	String toLowerCase(Locale locale) Converts all of the characters in this String to lower case using the rules of the given Locale.
42	String toString() This object (which is already a string!) is itself returned.
43	String toUpperCase() Converts all of the characters in this String to upper case using the rules of the default locale.
44	String toUpperCase(Locale locale) Converts all of the characters in this String to upper case using the rules of the given Locale.
45	String trim() Returns a copy of the string, with leading and trailing whitespace omitted.
46	static String valueOf(primitive data type x) Returns the string representation of the passed data type argument.

Java provides a data structure, the array, which stores a fixed-size sequential collection of elements of the same type. An array is used to store a collection of data, but it is often more useful to think of an array as a collection of variables of the same type.

Instead of declaring individual variables, such as number0, number1, ..., and number99, you declare one array variable such as numbers and use numbers[0], numbers[1], and ..., numbers[99] to represent individual variables.

This tutorial introduces how to declare array variables, create arrays, and process arrays using indexed variables.

Declaring Array Variables

To use an array in a program, you must declare a variable to reference the array, and you must specify the type of array the variable can reference. Here is the syntax for declaring an array variable −

Syntax

dataType[] arrayRefVar;   // preferred way.
or
dataType arrayRefVar[];  // works but not preferred way.

Note − The style dataType[] arrayRefVar is preferred. The style dataType arrayRefVar[] comes from the C/C++ language and was adopted in Java to accommodate C/C++ programmers.

Example

The following code snippets are examples of this syntax −

double[] myList;   // preferred way.
or
double myList[];   // works but not preferred way.

Creating Arrays

You can create an array by using the new operator with the following syntax −

Syntax

arrayRefVar = new dataType[arraySize];

The above statement does two things −

• It creates an array using new dataType[arraySize].

• It assigns the reference of the newly created array to the variable arrayRefVar.

Declaring an array variable, creating an array, and assigning the reference of the array to the variable can be combined in one statement, as shown below −

dataType[] arrayRefVar = new dataType[arraySize];

Alternatively you can create arrays as follows −

dataType[] arrayRefVar = {value0, value1, ..., valuek};

The array elements are accessed through the index. Array indices are 0-based; that is, they start from 0 to arrayRefVar.length-1.

Example

Following statement declares an array variable, myList, creates an array of 10 elements of double type and assigns its reference to myList −

double[] myList = new double[10];

Following picture represents array myList. Here, myList holds ten double values and the indices are from 0 to 9.

Processing Arrays

When processing array elements, we often use either for loop or foreach loop because all of the elements in an array are of the same type and the size of the array is known.

Example

Here is a complete example showing how to create, initialize, and process arrays −

public class TestArray {

   public static void main(String[] args) {
      double[] myList = {1.9, 2.9, 3.4, 3.5};

      // Print all the array elements
      for (int i = 0; i < myList.length; i++) {
         System.out.println(myList[i] + " ");
      }
     
      // Summing all elements
      double total = 0;
      for (int i = 0; i < myList.length; i++) {
         total += myList[i];
      }
      System.out.println("Total is " + total);
      
      // Finding the largest element
      double max = myList[0];
      for (int i = 1; i < myList.length; i++) {
         if (myList[i] > max) max = myList[i];
      }
      System.out.println("Max is " + max);  
   }
}

This will produce the following result −

Output

1.9
2.9
3.4
3.5
Total is 11.7
Max is 3.5

The foreach Loops

JDK 1.5 introduced a new for loop known as foreach loop or enhanced for loop, which enables you to traverse the complete array sequentially without using an index variable.

Example

The following code displays all the elements in the array myList −

public class TestArray {

   public static void main(String[] args) {
      double[] myList = {1.9, 2.9, 3.4, 3.5};

      // Print all the array elements
      for (double element: myList) {
         System.out.println(element);
      }
   }
}

This will produce the following result −

Output

1.9
2.9
3.4
3.5

Passing Arrays to Methods

Just as you can pass primitive type values to methods, you can also pass arrays to methods. For example, the following method displays the elements in an int array −

Example

public static void printArray(int[] array) {
   for (int i = 0; i < array.length; i++) {
      System.out.print(array[i] + " ");
   }
}

You can invoke it by passing an array. For example, the following statement invokes the printArray method to display 3, 1, 2, 6, 4, and 2 −

Example

printArray(new int[]{3, 1, 2, 6, 4, 2});

Returning an Array from a Method

A method may also return an array. For example, the following method returns an array that is the reversal of another array −

Example

public static int[] reverse(int[] list) {
   int[] result = new int[list.length];

   for (int i = 0, j = result.length - 1; i < list.length; i++, j--) {
      result[j] = list[i];
   }
   return result;
}

The Arrays Class

The java.util.Arrays class contains various static methods for sorting and searching arrays, comparing arrays, and filling array elements. These methods are overloaded for all primitive types.

Sr.No.	Method & Description
1	public static int binarySearch(Object[] a, Object key) Searches the specified array of Object ( Byte, Int , double, etc.) for the specified value using the binary search algorithm. The array must be sorted prior to making this call. This returns index of the search key, if it is contained in the list; otherwise, it returns ( – (insertion point + 1)).
2	public static boolean equals(long[] a, long[] a2) Returns true if the two specified arrays of longs are equal to one another. Two arrays are considered equal if both arrays contain the same number of elements, and all corresponding pairs of elements in the two arrays are equal. This returns true if the two arrays are equal. Same method could be used by all other primitive data types (Byte, short, Int, etc.)
3	public static void fill(int[] a, int val) Assigns the specified int value to each element of the specified array of ints. The same method could be used by all other primitive data types (Byte, short, Int, etc.)
4	public static void sort(Object[] a) Sorts the specified array of objects into an ascending order, according to the natural ordering of its elements. The same method could be used by all other primitive data types ( Byte, short, Int, etc.)

Java provides the Date class available in java.util package, this class encapsulates the current date and time.

The Date class supports two constructors as shown in the following table.

Sr.No.	Constructor & Description
1	Date( ) This constructor initializes the object with the current date and time.
2	Date(long millisec) This constructor accepts an argument that equals the number of milliseconds that have elapsed since midnight, January 1, 1970.

Following are the methods of the date class.

Sr.No.	Method & Description
1	boolean after(Date date) Returns true if the invoking Date object contains a date that is later than the one specified by date, otherwise, it returns false.
2	boolean before(Date date) Returns true if the invoking Date object contains a date that is earlier than the one specified by date, otherwise, it returns false.
3	Object clone( ) Duplicates the invoking Date object.
4	int compareTo(Date date) Compares the value of the invoking object with that of date. Returns 0 if the values are equal. Returns a negative value if the invoking object is earlier than date. Returns a positive value if the invoking object is later than date.
5	int compareTo(Object obj) Operates identically to compareTo(Date) if obj is of class Date. Otherwise, it throws a ClassCastException.
6	boolean equals(Object date) Returns true if the invoking Date object contains the same time and date as the one specified by date, otherwise, it returns false.
7	long getTime( ) Returns the number of milliseconds that have elapsed since January 1, 1970.
8	int hashCode( ) Returns a hash code for the invoking object.
9	void setTime(long time) Sets the time and date as specified by time, which represents an elapsed time in milliseconds from midnight, January 1, 1970.
10	String toString( ) Converts the invoking Date object into a string and returns the result.

Aktuelles Datum und Uhrzeit abrufen

Dies ist eine sehr einfache Methode, um das aktuelle Datum und die aktuelle Uhrzeit in Java abzurufen. Sie können ein einfaches Datumsobjekt mit der toString () -Methode verwenden, um das aktuelle Datum und die aktuelle Uhrzeit wie folgt zu drucken:

Beispiel

import java.util.Date;
public class DateDemo {

   public static void main(String args[]) {
      // Instantiate a Date object
      Date date = new Date();

      // display time and date using toString()
      System.out.println(date.toString());
   }
}

Dies führt zu folgendem Ergebnis:

Ausgabe

on May 04 09:51:52 CDT 2009

Datumsvergleich

Im Folgenden finden Sie drei Möglichkeiten, um zwei Daten zu vergleichen:

• Mit getTime () können Sie die Anzahl der Millisekunden abrufen, die seit Mitternacht, dem 1. Januar 1970, für beide Objekte vergangen sind, und diese beiden Werte vergleichen.

• Sie können die Methoden before (), after () und equals () verwenden. Da der 12. des Monats beispielsweise vor dem 18. liegt, gibt das neue Datum (99, 2, 12) vor (neues Datum (99, 2, 18)) true zurück.

• Sie können die compareTo () -Methode verwenden, die von der Comparable-Schnittstelle definiert und von Date implementiert wird.

Datumsformatierung mit SimpleDateFormat

SimpleDateFormat ist eine konkrete Klasse zum Formatieren und Analysieren von Datumsangaben in Bezug auf das Gebietsschema. Mit SimpleDateFormat können Sie zunächst benutzerdefinierte Muster für die Formatierung von Datum und Uhrzeit auswählen.

Beispiel

import java.util.*;
import java.text.*;

public class DateDemo {

   public static void main(String args[]) {
      Date dNow = new Date( );
      SimpleDateFormat ft = 
      new SimpleDateFormat ("E yyyy.MM.dd 'at' hh:mm:ss a zzz");

      System.out.println("Current Date: " + ft.format(dNow));
   }
}

Dies führt zu folgendem Ergebnis:

Ausgabe

Current Date: Sun 2004.07.18 at 04:14:09 PM PDT

Einfache DateFormat-Formatcodes

Verwenden Sie zum Festlegen des Zeitformats eine Zeitmusterzeichenfolge. In diesem Muster sind alle ASCII-Buchstaben als Musterbuchstaben reserviert, die wie folgt definiert sind:

Charakter	Beschreibung	Beispiel
G	Ära Bezeichner	ANZEIGE
y	Jahr in vier Ziffern	2001
M.	Monat im Jahr	Juli oder 07
d	Tag im Monat	10
h	Stunde in AM / PM (1 ~ 12)	12
H.	Stunde am Tag (0 ~ 23)	22
m	Minute in Stunde	30
s	Zweiter in der Minute	55
S.	Millisekunde	234
E.	Tag in der Woche	Dienstag
D.	Tag im Jahr	360
F.	Wochentag im Monat	2 (zweiter Mi. im Juli)
w	Woche im Jahr	40
W.	Woche im Monat	1
ein	AM / PM-Marker	PM
k	Stunde am Tag (1 ~ 24)	24
K.	Stunde in AM / PM (0 ~ 11)	10
z	Zeitzone	Östliche Standardzeit
'	Escape für Text	Trennzeichen
""	Einfaches Zitat	`

Datumsformatierung mit printf

Die Formatierung von Datum und Uhrzeit kann sehr einfach verwendet werden printfMethode. Sie verwenden ein Zwei-Buchstaben-Format, beginnend mitt und endet in einem der Buchstaben der Tabelle, wie im folgenden Code gezeigt.

Beispiel

import java.util.Date;
public class DateDemo {

   public static void main(String args[]) {
      // Instantiate a Date object
      Date date = new Date();

      // display time and date
      String str = String.format("Current Date/Time : %tc", date );

      System.out.printf(str);
   }
}

Dies führt zu folgendem Ergebnis:

Ausgabe

Current Date/Time : Sat Dec 15 16:37:57 MST 2012

Es wäre ein bisschen albern, wenn Sie das Datum mehrmals angeben müssten, um jedes Teil zu formatieren. Aus diesem Grund kann eine Formatzeichenfolge den Index des zu formatierenden Arguments angeben.

Der Index muss unmittelbar auf% folgen und mit einem $ abgeschlossen werden.

Beispiel

import java.util.Date;
public class DateDemo {

   public static void main(String args[]) {
      // Instantiate a Date object
      Date date = new Date();
  
      // display time and date
      System.out.printf("%1$s %2$tB %2$td, %2$tY", "Due date:", date);
   }
}

Dies führt zu folgendem Ergebnis:

Ausgabe

Due date: February 09, 2004

Alternativ können Sie das Flag <verwenden. Es gibt an, dass das gleiche Argument wie in der vorhergehenden Formatspezifikation erneut verwendet werden sollte.

Beispiel

import java.util.Date;
public class DateDemo {

   public static void main(String args[]) {
      // Instantiate a Date object
      Date date = new Date();
  
      // display formatted date
      System.out.printf("%s %tB %<te, %<tY", "Due date:", date);
   }
}

Dies führt zu folgendem Ergebnis:

Ausgabe

Due date: February 09, 2004

Umrechnungszeichen für Datum und Uhrzeit

Charakter	Beschreibung	Beispiel
c	Vollständiges Datum und Uhrzeit	Mo Mai 04 09:51:52 CDT 2009
F.	ISO 8601 Datum	09.02.2004
D.	US-formatiertes Datum (Monat / Tag / Jahr)	02/09/2004
T.	24 Stunden Zeit	18:05:19
r	12 Stunden Zeit	18:05:19 Uhr
R.	24 Stunden, keine Sekunden	18:05
Y.	Vierstelliges Jahr (mit führenden Nullen)	2004
y	Letzte zwei Ziffern des Jahres (mit führenden Nullen)	04
C.	Die ersten beiden Ziffern des Jahres (mit führenden Nullen)	20
B.	Voller Monatsname	Februar
b	Abgekürzter Monatsname	Feb.
m	Zweistelliger Monat (mit führenden Nullen)	02
d	Zweistelliger Tag (mit führenden Nullen)	03
e	Zweistelliger Tag (ohne führende Nullen)	9
EIN	Voller Wochentagsname	Montag
ein	Abgekürzter Wochentagsname	Mo.
j	Dreistelliger Tag des Jahres (mit führenden Nullen)	069
H.	Zweistellige Stunde (mit führenden Nullen) zwischen 00 und 23	18
k	Zweistellige Stunde (ohne führende Nullen) zwischen 0 und 23	18
ich	Zweistellige Stunde (mit führenden Nullen) zwischen 01 und 12	06
l	Zweistellige Stunde (ohne führende Nullen) zwischen 1 und 12	6
M.	Zweistellige Minuten (mit führenden Nullen)	05
S.	Zweistellige Sekunden (mit führenden Nullen)	19
L.	Dreistellige Millisekunden (mit führenden Nullen)	047
N.	Neunstellige Nanosekunden (mit führenden Nullen)	047000000
P.	Morgen- oder Nachmittagsmarkierung in Großbuchstaben	PM
p	Morgen- oder Nachmittagsmarkierung in Kleinbuchstaben	Uhr
z	RFC 822 numerischer Offset von GMT	-0800
Z.	Zeitzone	PST
s	Sekunden seit 1970-01-01 00:00:00 GMT	1078884319
Q.	Millisekunden seit 1970-01-01 00:00:00 GMT	1078884319047

Es gibt andere nützliche Klassen in Bezug auf Datum und Uhrzeit. Weitere Informationen finden Sie in der Java Standard-Dokumentation.

Analysieren von Zeichenfolgen in Daten

Die SimpleDateFormat-Klasse verfügt über einige zusätzliche Methoden, insbesondere parse (), mit denen versucht wird, eine Zeichenfolge gemäß dem im angegebenen SimpleDateFormat-Objekt gespeicherten Format zu analysieren.

Beispiel

import java.util.*;
import java.text.*;
  
public class DateDemo {

   public static void main(String args[]) {
      SimpleDateFormat ft = new SimpleDateFormat ("yyyy-MM-dd"); 
      String input = args.length == 0 ? "1818-11-11" : args[0]; 

      System.out.print(input + " Parses as "); 
      Date t;
      try {
         t = ft.parse(input); 
         System.out.println(t); 
      } catch (ParseException e) { 
         System.out.println("Unparseable using " + ft); 
      }
   }
}

Ein Probelauf des obigen Programms würde das folgende Ergebnis ergeben:

Ausgabe

1818-11-11 Parses as Wed Nov 11 00:00:00 EST 1818

Eine Weile schlafen

Sie können für einen beliebigen Zeitraum von einer Millisekunde bis zur Lebensdauer Ihres Computers schlafen. Zum Beispiel würde das folgende Programm 3 Sekunden lang schlafen -

Beispiel

import java.util.*;
public class SleepDemo {

   public static void main(String args[]) {
      try { 
         System.out.println(new Date( ) + "\n"); 
         Thread.sleep(5*60*10); 
         System.out.println(new Date( ) + "\n"); 
      } catch (Exception e) {
         System.out.println("Got an exception!"); 
      }
   }
}

Dies führt zu folgendem Ergebnis:

Ausgabe

Sun May 03 18:04:41 GMT 2009
Sun May 03 18:04:51 GMT 2009

Verstrichene Zeit messen

Manchmal müssen Sie den Zeitpunkt in Millisekunden messen. Schreiben wir also das obige Beispiel noch einmal neu -

Beispiel

import java.util.*;
public class DiffDemo {

   public static void main(String args[]) {
      try {
         long start = System.currentTimeMillis( );
         System.out.println(new Date( ) + "\n");
         
         Thread.sleep(5*60*10);
         System.out.println(new Date( ) + "\n");
         
         long end = System.currentTimeMillis( );
         long diff = end - start;
         System.out.println("Difference is : " + diff);
      } catch (Exception e) {
         System.out.println("Got an exception!");
      }
   }
}

Dies führt zu folgendem Ergebnis:

Ausgabe

Sun May 03 18:16:51 GMT 2009
Sun May 03 18:16:57 GMT 2009
Difference is : 5993

Gregorianische Kalenderklasse

GregorianCalendar ist eine konkrete Implementierung einer Calendar-Klasse, die den normalen Gregorian-Kalender implementiert, mit dem Sie vertraut sind. Wir haben die Kalenderklasse in diesem Tutorial nicht besprochen. Sie können dazu die Standard-Java-Dokumentation nachschlagen.

Das getInstance( )Die Methode des Kalenders gibt einen Gregorianischen Kalender zurück, der mit dem aktuellen Datum und der aktuellen Uhrzeit im Standardgebietsschema und in der Standardzeitzone initialisiert wurde. GregorianCalendar definiert zwei Felder: AD und BC. Diese repräsentieren die beiden im Gregorianischen Kalender definierten Epochen.

Es gibt auch mehrere Konstruktoren für GregorianCalendar-Objekte -

Sr.Nr.	Konstruktor & Beschreibung
1	GregorianCalendar() Erstellt einen Standard-Gregorianischen Kalender unter Verwendung der aktuellen Zeit in der Standardzeitzone mit dem Standardgebietsschema.
2	GregorianCalendar(int year, int month, int date) Erstellt einen Gregorianischen Kalender mit dem angegebenen Datum in der Standardzeitzone mit dem Standardgebietsschema.
3	GregorianCalendar(int year, int month, int date, int hour, int minute) Erstellt einen Gregorianischen Kalender mit dem angegebenen Datum und der angegebenen Uhrzeit für die Standardzeitzone mit dem Standardgebietsschema.
4	GregorianCalendar(int year, int month, int date, int hour, int minute, int second) Erstellt einen Gregorianischen Kalender mit dem angegebenen Datum und der angegebenen Uhrzeit für die Standardzeitzone mit dem Standardgebietsschema.
5	GregorianCalendar(Locale aLocale) Erstellt einen Gregorianischen Kalender basierend auf der aktuellen Zeit in der Standardzeitzone mit dem angegebenen Gebietsschema.
6	GregorianCalendar(TimeZone zone) Erstellt einen Gregorianischen Kalender basierend auf der aktuellen Zeit in der angegebenen Zeitzone mit dem Standardgebietsschema.
7	GregorianCalendar(TimeZone zone, Locale aLocale) Erstellt einen Gregorianischen Kalender basierend auf der aktuellen Zeit in der angegebenen Zeitzone mit dem angegebenen Gebietsschema.

Hier ist die Liste einiger nützlicher Unterstützungsmethoden, die von der GregorianCalendar-Klasse bereitgestellt werden:

Sr.Nr.	Methode & Beschreibung
1	void add(int field, int amount) Fügt dem angegebenen Zeitfeld die angegebene (signierte) Zeit hinzu, basierend auf den Regeln des Kalenders.
2	protected void computeFields() Konvertiert UTC als Millisekunden in Zeitfeldwerte.
3	protected void computeTime() Kalender überschreibt Konvertiert Zeitfeldwerte als Millisekunden in UTC.
4	boolean equals(Object obj) Vergleicht diesen Gregorianischen Kalender mit einer Objektreferenz.
5	int get(int field) Ruft den Wert für ein bestimmtes Zeitfeld ab.
6	int getActualMaximum(int field) Gibt den Maximalwert zurück, den dieses Feld bei aktuellem Datum haben könnte.
7	int getActualMinimum(int field) Gibt den Mindestwert zurück, den dieses Feld angesichts des aktuellen Datums haben könnte.
8	int getGreatestMinimum(int field) Gibt den höchsten Mindestwert für das angegebene Feld zurück, wenn er variiert.
9	Date getGregorianChange() Ruft das Änderungsdatum des Gregorianischen Kalenders ab.
10	int getLeastMaximum(int field) Gibt den niedrigsten Maximalwert für das angegebene Feld zurück, wenn er variiert.
11	int getMaximum(int field) Gibt den Maximalwert für das angegebene Feld zurück.
12	Date getTime() Ruft die aktuelle Uhrzeit dieses Kalenders ab.
13	long getTimeInMillis() Ruft die aktuelle Zeit dieses Kalenders als lang ab.
14	TimeZone getTimeZone() Ruft die Zeitzone ab.
15	int getMinimum(int field) Gibt den Mindestwert für das angegebene Feld zurück.
16	int hashCode() Überschreibt den Hashcode.
17	boolean isLeapYear(int year) Bestimmt, ob das angegebene Jahr ein Schaltjahr ist.
18	void roll(int field, boolean up) Addiert oder subtrahiert (nach oben / unten) eine einzelne Zeiteinheit für das angegebene Zeitfeld, ohne größere Felder zu ändern.
19	void set(int field, int value) Legt das Zeitfeld mit dem angegebenen Wert fest.
20	void set(int year, int month, int date) Legt die Werte für die Felder Jahr, Monat und Datum fest.
21	void set(int year, int month, int date, int hour, int minute) Legt die Werte für die Felder Jahr, Monat, Datum, Stunde und Minute fest.
22	void set(int year, int month, int date, int hour, int minute, int second) Legt die Werte für die Felder Jahr, Monat, Datum, Stunde, Minute und Sekunde fest.
23	void setGregorianChange(Date date) Legt das Änderungsdatum für GregorianCalendar fest.
24	void setTime(Date date) Legt die aktuelle Uhrzeit dieses Kalenders mit dem angegebenen Datum fest.
25	void setTimeInMillis(long millis) Legt die aktuelle Zeit dieses Kalenders ab dem angegebenen langen Wert fest.
26	void setTimeZone(TimeZone value) Legt die Zeitzone mit dem angegebenen Zeitzonenwert fest.
27	String toString() Gibt eine Zeichenfolgendarstellung dieses Kalenders zurück.

Beispiel

import java.util.*;
public class GregorianCalendarDemo {

   public static void main(String args[]) {
      String months[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", 
         "Oct", "Nov", "Dec"};
      
      int year;
      // Create a Gregorian calendar initialized
      // with the current date and time in the
      // default locale and timezone.
      
      GregorianCalendar gcalendar = new GregorianCalendar();
      
      // Display current time and date information.
      System.out.print("Date: ");
      System.out.print(months[gcalendar.get(Calendar.MONTH)]);
      System.out.print(" " + gcalendar.get(Calendar.DATE) + " ");
      System.out.println(year = gcalendar.get(Calendar.YEAR));
      System.out.print("Time: ");
      System.out.print(gcalendar.get(Calendar.HOUR) + ":");
      System.out.print(gcalendar.get(Calendar.MINUTE) + ":");
      System.out.println(gcalendar.get(Calendar.SECOND));

      // Test if the current year is a leap year
      if(gcalendar.isLeapYear(year)) {
         System.out.println("The current year is a leap year");
      }else {
         System.out.println("The current year is not a leap year");
      }
   }
}

Dies führt zu folgendem Ergebnis:

Ausgabe

Date: Apr 22 2009
Time: 11:25:27
The current year is not a leap year

Eine vollständige Liste der in der Kalenderklasse verfügbaren Konstanten finden Sie in der Standard-Java-Dokumentation.

Java bietet das Paket java.util.regex für den Mustervergleich mit regulären Ausdrücken. Reguläre Java-Ausdrücke sind der Programmiersprache Perl sehr ähnlich und sehr einfach zu erlernen.

Ein regulärer Ausdruck ist eine spezielle Folge von Zeichen, mit deren Hilfe Sie andere Zeichenfolgen oder Sätze von Zeichenfolgen mithilfe einer speziellen Syntax in einem Muster abgleichen oder finden können. Sie können zum Suchen, Bearbeiten oder Bearbeiten von Text und Daten verwendet werden.

Das Paket java.util.regex besteht hauptsächlich aus den folgenden drei Klassen:

• Pattern Class- Ein Pattern-Objekt ist eine kompilierte Darstellung eines regulären Ausdrucks. Die Pattern-Klasse bietet keine öffentlichen Konstruktoren. Um ein Muster zu erstellen, müssen Sie zuerst eine seiner öffentlichen statischen Elemente aufrufencompile()Methoden, die dann ein Pattern-Objekt zurückgeben. Diese Methoden akzeptieren einen regulären Ausdruck als erstes Argument.

• Matcher Class- Ein Matcher-Objekt ist die Engine, die das Muster interpretiert und Übereinstimmungsoperationen für eine Eingabezeichenfolge ausführt. Wie die Pattern-Klasse definiert Matcher keine öffentlichen Konstruktoren. Sie erhalten ein Matcher-Objekt, indem Sie das aufrufenmatcher() Methode für ein Pattern-Objekt.

• PatternSyntaxException - Ein PatternSyntaxException-Objekt ist eine nicht aktivierte Ausnahme, die auf einen Syntaxfehler in einem Muster mit regulären Ausdrücken hinweist.

Gruppen erfassen

Das Erfassen von Gruppen ist eine Möglichkeit, mehrere Zeichen als eine Einheit zu behandeln. Sie werden erstellt, indem die zu gruppierenden Zeichen in Klammern gesetzt werden. Beispielsweise erstellt der reguläre Ausdruck (Hund) eine einzelne Gruppe mit den Buchstaben "d", "o" und "g".

Erfassungsgruppen werden nummeriert, indem ihre öffnenden Klammern von links nach rechts gezählt werden. In dem Ausdruck ((A) (B (C))) gibt es zum Beispiel vier solche Gruppen -

• ((A)(B(C)))
• (A)
• (B(C))
• (C)

Rufen Sie die groupCount-Methode für ein Matcher-Objekt auf, um herauszufinden, wie viele Gruppen im Ausdruck vorhanden sind. Die groupCount-Methode gibt eine zurückint Zeigt die Anzahl der Erfassungsgruppen an, die im Matcher-Muster vorhanden sind.

Es gibt auch eine spezielle Gruppe, Gruppe 0, die immer den gesamten Ausdruck darstellt. Diese Gruppe ist nicht in der von groupCount gemeldeten Summe enthalten.

Example

Das folgende Beispiel zeigt, wie Sie eine Ziffernfolge aus der angegebenen alphanumerischen Zeichenfolge finden.

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexMatches {

   public static void main( String args[] ) {
      // String to be scanned to find the pattern.
      String line = "This order was placed for QT3000! OK?";
      String pattern = "(.*)(\\d+)(.*)";

      // Create a Pattern object
      Pattern r = Pattern.compile(pattern);

      // Now create matcher object.
      Matcher m = r.matcher(line);
      if (m.find( )) {
         System.out.println("Found value: " + m.group(0) );
         System.out.println("Found value: " + m.group(1) );
         System.out.println("Found value: " + m.group(2) );
      }else {
         System.out.println("NO MATCH");
      }
   }
}

Dies führt zu folgendem Ergebnis:

Output

Found value: This order was placed for QT3000! OK?
Found value: This order was placed for QT300
Found value: 0

Syntax für reguläre Ausdrücke

In der folgenden Tabelle sind alle in Java verfügbaren Metazeichen für reguläre Ausdrücke aufgeführt.

Unterausdruck	Streichhölzer
^	Entspricht dem Zeilenanfang.
$	Entspricht dem Zeilenende.
.	Entspricht einem einzelnen Zeichen außer Zeilenumbruch. Verwenden vonm Mit dieser Option kann es auch mit der Newline übereinstimmen.
[...]	Entspricht einem einzelnen Zeichen in Klammern.
[^ ...]	Entspricht einem einzelnen Zeichen, das nicht in Klammern steht.
\EIN	Anfang der gesamten Saite.
\ z	Ende der gesamten Zeichenfolge.
\ Z.	Ende der gesamten Zeichenfolge mit Ausnahme des zulässigen Abschlussabschlusses.
Re*	Entspricht 0 oder mehr Vorkommen des vorhergehenden Ausdrucks.
re +	Entspricht 1 oder mehr der vorherigen Sache.
Re?	Entspricht 0 oder 1 Vorkommen des vorhergehenden Ausdrucks.
re {n}	Entspricht genau n Vorkommen des vorhergehenden Ausdrucks.
re {n,}	Entspricht n oder mehr Vorkommen des vorhergehenden Ausdrucks.
re {n, m}	Entspricht mindestens n und höchstens m Vorkommen des vorhergehenden Ausdrucks.
a | b	Entspricht entweder a oder b.
(Re)	Gruppiert reguläre Ausdrücke und merkt sich den übereinstimmenden Text.
(?: re)	Gruppiert reguläre Ausdrücke, ohne sich an den übereinstimmenden Text zu erinnern.
(?> re)	Entspricht dem unabhängigen Muster ohne Rückverfolgung.
\ w	Entspricht den Wortzeichen.
\ W.	Entspricht den Nichtwortzeichen.
\ s	Entspricht dem Leerzeichen. Entspricht [\ t \ n \ r \ f].
\ S.	Entspricht dem Nicht-Leerzeichen.
\ d	Entspricht den Ziffern. Entspricht [0-9].
\ D.	Entspricht den Nicht-Ziffern.
\EIN	Entspricht dem Anfang der Zeichenfolge.
\ Z.	Entspricht dem Ende der Zeichenfolge. Wenn eine neue Zeile vorhanden ist, stimmt sie kurz vor der neuen Zeile überein.
\ z	Entspricht dem Ende der Zeichenfolge.
\G	Entspricht dem Punkt, an dem das letzte Spiel beendet wurde.
\ n	Rückverweis auf Erfassungsgruppennummer "n".
\ b	Entspricht den Wortgrenzen außerhalb der Klammern. Entspricht der Rücktaste (0x08) in den Klammern.
\ B.	Entspricht den Nichtwortgrenzen.
\ n, \ t usw.	Entspricht Zeilenumbrüchen, Wagenrückläufen, Tabulatoren usw.
\ Q.	Escape (Zitat) alle Zeichen bis zu \ E.
\ E.	Beendet das mit \ Q begonnene Zitat.

Methoden der Matcher-Klasse

Hier ist eine Liste nützlicher Instanzmethoden -

Indexmethoden

Indexmethoden bieten nützliche Indexwerte, die genau anzeigen, wo die Übereinstimmung in der Eingabezeichenfolge gefunden wurde.

Sr.Nr.	Methode & Beschreibung
1	public int start() Gibt den Startindex der vorherigen Übereinstimmung zurück.
2	public int start(int group) Gibt den Startindex der Teilsequenz zurück, die von der angegebenen Gruppe während der vorherigen Übereinstimmungsoperation erfasst wurde.
3	public int end() Gibt den Versatz nach dem letzten übereinstimmenden Zeichen zurück.
4	public int end(int group) Gibt den Versatz nach dem letzten Zeichen der Teilsequenz zurück, die von der angegebenen Gruppe während der vorherigen Übereinstimmungsoperation erfasst wurde.

Studienmethoden

Studienmethoden überprüfen die Eingabezeichenfolge und geben einen Booleschen Wert zurück, der angibt, ob das Muster gefunden wurde oder nicht.

Sr.Nr.	Methode & Beschreibung
1	public boolean lookingAt() Es wird versucht, die Eingabesequenz, beginnend am Anfang der Region, mit dem Muster abzugleichen.
2	public boolean find() Versucht, die nächste Teilsequenz der Eingabesequenz zu finden, die dem Muster entspricht.
3	public boolean find(int start) Setzt diesen Matcher zurück und versucht dann, die nächste Teilsequenz der Eingabesequenz zu finden, die dem Muster entspricht, beginnend mit dem angegebenen Index.
4	public boolean matches() Versuche, die gesamte Region mit dem Muster abzugleichen.

Ersatzmethoden

Ersetzungsmethoden sind nützliche Methoden zum Ersetzen von Text in einer Eingabezeichenfolge.

Sr.Nr.	Methode & Beschreibung
1	public Matcher appendReplacement(StringBuffer sb, String replacement) Implementiert einen nicht-terminalen Schritt zum Anhängen und Ersetzen.
2	public StringBuffer appendTail(StringBuffer sb) Implementiert einen Schritt zum Anhängen und Ersetzen des Terminals.
3	public String replaceAll(String replacement) Ersetzt jede Teilsequenz der Eingabesequenz, die dem Muster entspricht, durch die angegebene Ersetzungszeichenfolge.
4	public String replaceFirst(String replacement) Ersetzt die erste Teilsequenz der Eingabesequenz, die dem Muster entspricht, durch die angegebene Ersetzungszeichenfolge.
5	public static String quoteReplacement(String s) Gibt eine Literal-Ersatzzeichenfolge für die angegebene Zeichenfolge zurück. Diese Methode erzeugt einen String, der als Literalersatz fungierts in der appendReplacement-Methode der Matcher-Klasse.

Die Start- und Endmethoden

Das folgende Beispiel zählt, wie oft das Wort "cat" in der Eingabezeichenfolge erscheint.

Example

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexMatches {

   private static final String REGEX = "\\bcat\\b";
   private static final String INPUT = "cat cat cat cattie cat";

   public static void main( String args[] ) {
      Pattern p = Pattern.compile(REGEX);
      Matcher m = p.matcher(INPUT);   // get a matcher object
      int count = 0;

      while(m.find()) {
         count++;
         System.out.println("Match number "+count);
         System.out.println("start(): "+m.start());
         System.out.println("end(): "+m.end());
      }
   }
}

Dies führt zu folgendem Ergebnis:

Output

Match number 1
start(): 0
end(): 3
Match number 2
start(): 4
end(): 7
Match number 3
start(): 8
end(): 11
Match number 4
start(): 19
end(): 22

Sie können sehen, dass in diesem Beispiel Wortgrenzen verwendet werden, um sicherzustellen, dass die Buchstaben "c" "a" "t" nicht nur eine Teilzeichenfolge in einem längeren Wort sind. Es enthält auch einige nützliche Informationen darüber, wo in der Eingabezeichenfolge die Übereinstimmung stattgefunden hat.

Die Startmethode gibt den Startindex der Teilsequenz zurück, die von der angegebenen Gruppe während der vorherigen Übereinstimmungsoperation erfasst wurde, und das Ende gibt den Index des zuletzt übereinstimmenden Zeichens plus eins zurück.

Die Übereinstimmungen und Suchmethoden

Die Übereinstimmungen und die LookingAt-Methoden versuchen beide, eine Eingabesequenz mit einem Muster abzugleichen. Der Unterschied besteht jedoch darin, dass bei Übereinstimmungen die gesamte Eingabesequenz abgeglichen werden muss, bei LookingAt jedoch nicht.

Beide Methoden beginnen immer am Anfang der Eingabezeichenfolge. Hier ist das Beispiel, das die Funktionalität erklärt -

Example

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexMatches {

   private static final String REGEX = "foo";
   private static final String INPUT = "fooooooooooooooooo";
   private static Pattern pattern;
   private static Matcher matcher;

   public static void main( String args[] ) {
      pattern = Pattern.compile(REGEX);
      matcher = pattern.matcher(INPUT);

      System.out.println("Current REGEX is: "+REGEX);
      System.out.println("Current INPUT is: "+INPUT);

      System.out.println("lookingAt(): "+matcher.lookingAt());
      System.out.println("matches(): "+matcher.matches());
   }
}

Dies führt zu folgendem Ergebnis:

Output

Current REGEX is: foo
Current INPUT is: fooooooooooooooooo
lookingAt(): true
matches(): false

Die Methoden replaceFirst und replaceAll

Die Methoden replaceFirst und replaceAll ersetzen den Text, der einem bestimmten regulären Ausdruck entspricht. Wie der Name schon sagt, ersetzt replaceFirst das erste Vorkommen und replaceAll alle Vorkommen.

Hier ist das Beispiel, das die Funktionalität erklärt -

Example

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexMatches {

   private static String REGEX = "dog";
   private static String INPUT = "The dog says meow. " + "All dogs say meow.";
   private static String REPLACE = "cat";

   public static void main(String[] args) {
      Pattern p = Pattern.compile(REGEX);
      
      // get a matcher object
      Matcher m = p.matcher(INPUT); 
      INPUT = m.replaceAll(REPLACE);
      System.out.println(INPUT);
   }
}

Dies führt zu folgendem Ergebnis:

Output

The cat says meow. All cats say meow.

Die Methoden appendReplacement und appendTail

Die Matcher-Klasse bietet auch die Methoden appendReplacement und appendTail zum Ersetzen von Text.

Hier ist das Beispiel, das die Funktionalität erklärt -

Example

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexMatches {

   private static String REGEX = "a*b";
   private static String INPUT = "aabfooaabfooabfoob";
   private static String REPLACE = "-";
   public static void main(String[] args) {

      Pattern p = Pattern.compile(REGEX);
      
      // get a matcher object
      Matcher m = p.matcher(INPUT);
      StringBuffer sb = new StringBuffer();
      while(m.find()) {
         m.appendReplacement(sb, REPLACE);
      }
      m.appendTail(sb);
      System.out.println(sb.toString());
   }
}

Dies führt zu folgendem Ergebnis:

Output

-foo-foo-foo-

PatternSyntaxException-Klassenmethoden

Eine PatternSyntaxException ist eine nicht aktivierte Ausnahme, die auf einen Syntaxfehler in einem Muster für reguläre Ausdrücke hinweist. Die PatternSyntaxException-Klasse bietet die folgenden Methoden, mit denen Sie feststellen können, was schief gelaufen ist:

Sr.Nr.	Methode & Beschreibung
1	public String getDescription() Ruft die Beschreibung des Fehlers ab.
2	public int getIndex() Ruft den Fehlerindex ab.
3	public String getPattern() Ruft das fehlerhafte Muster für reguläre Ausdrücke ab.
4	public String getMessage() Gibt eine mehrzeilige Zeichenfolge zurück, die die Beschreibung des Syntaxfehlers und seines Index, das fehlerhafte Muster für reguläre Ausdrücke und eine visuelle Anzeige des Fehlerindex innerhalb des Musters enthält.

Eine Java-Methode ist eine Sammlung von Anweisungen, die zur Ausführung einer Operation zusammengefasst sind. Wenn Sie das System.out aufrufen.println() Methode führt das System beispielsweise tatsächlich mehrere Anweisungen aus, um eine Nachricht auf der Konsole anzuzeigen.

Jetzt lernen Sie, wie Sie Ihre eigenen Methoden mit oder ohne Rückgabewerte erstellen, eine Methode mit oder ohne Parameter aufrufen und die Methodenabstraktion im Programmdesign anwenden.

Methode erstellen

Betrachten Sie das folgende Beispiel, um die Syntax einer Methode zu erläutern:

Syntax

public static int methodName(int a, int b) {
   // body
}

Hier,

• public static - Modifikator

• int - Rückgabetyp

• methodName - Name der Methode

• a, b - formale Parameter

• int a, int b - Liste der Parameter

Die Methodendefinition besteht aus einem Methodenkopf und einem Methodenkörper. Das gleiche wird in der folgenden Syntax gezeigt -

Syntax

modifier returnType nameOfMethod (Parameter List) {
   // method body
}

Die oben gezeigte Syntax umfasst -

• modifier - Es definiert den Zugriffstyp der Methode und kann optional verwendet werden.

• returnType - Die Methode kann einen Wert zurückgeben.

• nameOfMethod- Dies ist der Methodenname. Die Methodensignatur besteht aus dem Methodennamen und der Parameterliste.

• Parameter List- Die Liste der Parameter ist der Typ, die Reihenfolge und die Anzahl der Parameter einer Methode. Diese sind optional. Die Methode kann Nullparameter enthalten.

• method body - Der Methodenkörper definiert, was die Methode mit den Anweisungen macht.

Example

Hier wird der Quellcode der oben definierten Methode aufgerufen min(). Diese Methode verwendet zwei Parameter num1 und num2 und gibt das Maximum zwischen den beiden zurück -

/** the snippet returns the minimum between two numbers */

public static int minFunction(int n1, int n2) {
   int min;
   if (n1 > n2)
      min = n2;
   else
      min = n1;

   return min; 
}

Methodenaufruf

Für die Verwendung einer Methode sollte sie aufgerufen werden. Es gibt zwei Möglichkeiten, wie eine Methode aufgerufen wird, dh die Methode gibt einen Wert zurück oder gibt nichts zurück (kein Rückgabewert).

Der Prozess des Methodenaufrufs ist einfach. Wenn ein Programm eine Methode aufruft, wird die Programmsteuerung auf die aufgerufene Methode übertragen. Diese aufgerufene Methode gibt dann unter zwei Bedingungen die Kontrolle an den Aufrufer zurück, wenn -

• Die return-Anweisung wird ausgeführt.
• es erreicht die Methode, die das Schließen der Klammer beendet.

Die Methoden, die void zurückgeben, werden als Aufruf einer Anweisung betrachtet. Betrachten wir ein Beispiel -

System.out.println("This is tutorialspoint.com!");

Die Methode, die einen Wert zurückgibt, kann anhand des folgenden Beispiels verstanden werden:

int result = sum(6, 9);

Das folgende Beispiel zeigt, wie eine Methode definiert und aufgerufen wird.

Example

public class ExampleMinNumber {
   
   public static void main(String[] args) {
      int a = 11;
      int b = 6;
      int c = minFunction(a, b);
      System.out.println("Minimum Value = " + c);
   }

   /** returns the minimum of two numbers */
   public static int minFunction(int n1, int n2) {
      int min;
      if (n1 > n2)
         min = n2;
      else
         min = n1;

      return min; 
   }
}

Dies führt zu folgendem Ergebnis:

Output

Minimum value = 6

Das leere Schlüsselwort

Mit dem Schlüsselwort void können wir Methoden erstellen, die keinen Wert zurückgeben. Im folgenden Beispiel betrachten wir eine void-Methode methodRankPoints . Diese Methode ist eine void-Methode, die keinen Wert zurückgibt. Der Aufruf einer void-Methode muss eine Anweisung sein, dh methodRankPoints (255.7); . Es ist eine Java-Anweisung, die mit einem Semikolon endet, wie im folgenden Beispiel gezeigt.

Example

public class ExampleVoid {

   public static void main(String[] args) {
      methodRankPoints(255.7);
   }

   public static void methodRankPoints(double points) {
      if (points >= 202.5) {
         System.out.println("Rank:A1");
      }else if (points >= 122.4) {
         System.out.println("Rank:A2");
      }else {
         System.out.println("Rank:A3");
      }
   }
}

Dies führt zu folgendem Ergebnis:

Output

Rank:A1

Parameter als Wert übergeben

Während der Arbeit im Aufrufprozess sind Argumente zu übergeben. Diese sollten in derselben Reihenfolge wie ihre jeweiligen Parameter in der Methodenspezifikation sein. Parameter können als Wert oder als Referenz übergeben werden.

Das Übergeben von Parametern als Wert bedeutet, dass eine Methode mit einem Parameter aufgerufen wird. Dadurch wird der Argumentwert an den Parameter übergeben.

Example

Das folgende Programm zeigt ein Beispiel für die Übergabe von Parametern nach Wert. Die Werte der Argumente bleiben auch nach dem Methodenaufruf gleich.

public class swappingExample {

   public static void main(String[] args) {
      int a = 30;
      int b = 45;
      System.out.println("Before swapping, a = " + a + " and b = " + b);

      // Invoke the swap method
      swapFunction(a, b);
      System.out.println("\n**Now, Before and After swapping values will be same here**:");
      System.out.println("After swapping, a = " + a + " and b is " + b);
   }

   public static void swapFunction(int a, int b) {
      System.out.println("Before swapping(Inside), a = " + a + " b = " + b);
      
      // Swap n1 with n2
      int c = a;
      a = b;
      b = c;
      System.out.println("After swapping(Inside), a = " + a + " b = " + b);
   }
}

Dies führt zu folgendem Ergebnis:

Output

Before swapping, a = 30 and b = 45
Before swapping(Inside), a = 30 b = 45
After swapping(Inside), a = 45 b = 30

**Now, Before and After swapping values will be same here**:
After swapping, a = 30 and b is 45

Methodenüberladung

Wenn eine Klasse zwei oder mehr Methoden mit demselben Namen, aber unterschiedlichen Parametern hat, wird dies als Methodenüberladung bezeichnet. Es unterscheidet sich vom Überschreiben. Beim Überschreiben hat eine Methode denselben Methodennamen, Typ, dieselbe Anzahl von Parametern usw.

Betrachten wir das zuvor beschriebene Beispiel zum Ermitteln der Mindestanzahl von Ganzzahltypen. Wenn, nehmen wir an, wir wollen die minimale Anzahl von Doppeltypen finden. Anschließend wird das Konzept der Überladung eingeführt, um zwei oder mehr Methoden mit demselben Namen, aber unterschiedlichen Parametern zu erstellen.

Das folgende Beispiel erklärt dasselbe -

Example

public class ExampleOverloading {

   public static void main(String[] args) {
      int a = 11;
      int b = 6;
      double c = 7.3;
      double d = 9.4;
      int result1 = minFunction(a, b);
      
      // same function name with different parameters
      double result2 = minFunction(c, d);
      System.out.println("Minimum Value = " + result1);
      System.out.println("Minimum Value = " + result2);
   }

   // for integer
   public static int minFunction(int n1, int n2) {
      int min;
      if (n1 > n2)
         min = n2;
      else
         min = n1;

      return min; 
   }
   
   // for double
   public static double minFunction(double n1, double n2) {
     double min;
      if (n1 > n2)
         min = n2;
      else
         min = n1;

      return min; 
   }
}

Dies führt zu folgendem Ergebnis:

Output

Minimum Value = 6
Minimum Value = 7.3

Überladungsmethoden machen das Programm lesbar. Hier werden zwei Methoden mit demselben Namen, aber unterschiedlichen Parametern angegeben. Die Mindestanzahl von Integer- und Double-Typen ist das Ergebnis.

Verwenden von Befehlszeilenargumenten

Manchmal möchten Sie einige Informationen an ein Programm übergeben, wenn Sie es ausführen. Dies wird erreicht, indem Befehlszeilenargumente an main () übergeben werden.

Ein Befehlszeilenargument ist die Information, die direkt auf den Namen des Programms in der Befehlszeile folgt, wenn es ausgeführt wird. Der Zugriff auf die Befehlszeilenargumente in einem Java-Programm ist recht einfach. Sie werden als Zeichenfolgen im String-Array gespeichert, das an main () übergeben wird.

Example

Das folgende Programm zeigt alle Befehlszeilenargumente an, mit denen es aufgerufen wird -

public class CommandLine {

   public static void main(String args[]) { 
      for(int i = 0; i<args.length; i++) {
         System.out.println("args[" + i + "]: " +  args[i]);
      }
   }
}

Versuchen Sie, dieses Programm wie hier gezeigt auszuführen -

$java CommandLine this is a command line 200 -100

Dies führt zu folgendem Ergebnis:

Output

args[0]: this
args[1]: is
args[2]: a
args[3]: command
args[4]: line
args[5]: 200
args[6]: -100

Das Schlüsselwort this

thisist ein Schlüsselwort in Java, das als Referenz auf das Objekt der aktuellen Klasse mit einer Instanzmethode oder einem Konstruktor verwendet wird. Auf diese Weise können Sie auf die Mitglieder einer Klasse wie Konstruktoren, Variablen und Methoden verweisen.

Note- Das Schlüsselwort this wird nur in Instanzmethoden oder Konstruktoren verwendet

Im Allgemeinen ist das Schlüsselwort dieser wird verwendet , um -

• Unterscheiden Sie die Instanzvariablen von lokalen Variablen, wenn sie dieselben Namen haben, innerhalb eines Konstruktors oder einer Methode.

class Student {
   int age;   
   Student(int age) {
      this.age = age;	
   }
}

• Rufen Sie einen Konstruktortyp (parametrisierter Konstruktor oder Standard) von einem anderen in einer Klasse auf. Dies wird als expliziter Konstruktoraufruf bezeichnet.

class Student {
   int age
   Student() {
      this(20);
   }
   
   Student(int age) {
      this.age = age;	
   }
}

Example

Hier ist ein Beispiel, das dieses Schlüsselwort verwendet, um auf die Mitglieder einer Klasse zuzugreifen. Kopieren Sie das folgende Programm und fügen Sie es in eine Datei mit dem Namen ein:This_Example.java.

public class This_Example {
   // Instance variable num
   int num = 10;
	
   This_Example() {
      System.out.println("This is an example program on keyword this");	
   }

   This_Example(int num) {
      // Invoking the default constructor
      this();
      
      // Assigning the local variable num to the instance variable num
      this.num = num;	   
   }
   
   public void greet() {
      System.out.println("Hi Welcome to Tutorialspoint");
   }
      
   public void print() {
      // Local variable num
      int num = 20;
      
      // Printing the local variable
      System.out.println("value of local variable num is : "+num);
      
      // Printing the instance variable
      System.out.println("value of instance variable num is : "+this.num);
      
      // Invoking the greet method of a class
      this.greet();     
   }
   
   public static void main(String[] args) {
      // Instantiating the class
      This_Example obj1 = new This_Example();
      
      // Invoking the print method
      obj1.print();
	  
      // Passing a new value to the num variable through Parameterized constructor
      This_Example obj2 = new This_Example(30);
      
      // Invoking the print method again
      obj2.print(); 
   }
}

Dies führt zu folgendem Ergebnis:

Output

This is an example program on keyword this 
value of local variable num is : 20
value of instance variable num is : 10
Hi Welcome to Tutorialspoint
This is an example program on keyword this 
value of local variable num is : 20
value of instance variable num is : 30
Hi Welcome to Tutorialspoint

Variable Argumente (var-args)

Mit JDK 1.5 können Sie eine variable Anzahl von Argumenten desselben Typs an eine Methode übergeben. Der Parameter in der Methode wird wie folgt deklariert:

typeName... parameterName

In der Methodendeklaration geben Sie den Typ an, gefolgt von einem Auslassungszeichen (...). In einer Methode darf nur ein Parameter variabler Länge angegeben werden, und dieser Parameter muss der letzte Parameter sein. Alle regulären Parameter müssen davor stehen.

Example

public class VarargsDemo {

   public static void main(String args[]) {
      // Call method with variable args  
	   printMax(34, 3, 3, 2, 56.5);
      printMax(new double[]{1, 2, 3});
   }

   public static void printMax( double... numbers) {
      if (numbers.length == 0) {
         System.out.println("No argument passed");
         return;
      }

      double result = numbers[0];

      for (int i = 1; i <  numbers.length; i++)
      if (numbers[i] >  result)
      result = numbers[i];
      System.out.println("The max value is " + result);
   }
}

Dies führt zu folgendem Ergebnis:

Output

The max value is 56.5
The max value is 3.0

Die finalize () -Methode

Es ist möglich, eine Methode zu definieren, die unmittelbar vor der endgültigen Zerstörung eines Objekts durch den Garbage Collector aufgerufen wird. Diese Methode wird aufgerufenfinalize( )und kann verwendet werden, um sicherzustellen, dass ein Objekt sauber beendet wird.

Beispielsweise können Sie finalize () verwenden, um sicherzustellen, dass eine geöffnete Datei, die diesem Objekt gehört, geschlossen wird.

Um einer Klasse einen Finalizer hinzuzufügen, definieren Sie einfach die finalize () -Methode. Die Java-Laufzeit ruft diese Methode immer dann auf, wenn ein Objekt dieser Klasse recycelt werden soll.

In der finalize () -Methode geben Sie die Aktionen an, die ausgeführt werden müssen, bevor ein Objekt zerstört wird.

Die finalize () -Methode hat diese allgemeine Form -

protected void finalize( ) {
   // finalization code here
}

Hier ist das Schlüsselwort protected ein Bezeichner, der den Zugriff auf finalize () durch Code verhindert, der außerhalb seiner Klasse definiert ist.

Dies bedeutet, dass Sie nicht wissen können, wann oder ob finalize () ausgeführt wird. Wenn Ihr Programm beispielsweise vor der Speicherbereinigung beendet wird, wird finalize () nicht ausgeführt.

Das Paket java.io enthält nahezu jede Klasse, die Sie möglicherweise jemals für die Eingabe und Ausgabe (E / A) in Java benötigen. Alle diese Streams repräsentieren eine Eingabequelle und ein Ausgabeziel. Der Stream im Paket java.io unterstützt viele Daten wie Grundelemente, Objekte, lokalisierte Zeichen usw.

Strom

Ein Stream kann als eine Folge von Daten definiert werden. Es gibt zwei Arten von Streams -

• InPutStream - Der InputStream wird zum Lesen von Daten aus einer Quelle verwendet.

• OutPutStream - Der OutputStream wird zum Schreiben von Daten in ein Ziel verwendet.

Java bietet eine starke, aber flexible Unterstützung für E / A in Bezug auf Dateien und Netzwerke. Dieses Lernprogramm behandelt jedoch sehr grundlegende Funktionen in Bezug auf Streams und E / A. Wir werden die am häufigsten verwendeten Beispiele einzeln sehen -

Byte-Streams

Java-Byte-Streams werden verwendet, um die Eingabe und Ausgabe von 8-Bit-Bytes durchzuführen. Es gibt zwar viele Klassen, die sich auf Byte-Streams beziehen, aber die am häufigsten verwendeten Klassen sind:FileInputStream und FileOutputStream. Das folgende Beispiel verwendet diese beiden Klassen, um eine Eingabedatei in eine Ausgabedatei zu kopieren.

Example

import java.io.*;
public class CopyFile {

   public static void main(String args[]) throws IOException {  
      FileInputStream in = null;
      FileOutputStream out = null;

      try {
         in = new FileInputStream("input.txt");
         out = new FileOutputStream("output.txt");
         
         int c;
         while ((c = in.read()) != -1) {
            out.write(c);
         }
      }finally {
         if (in != null) {
            in.close();
         }
         if (out != null) {
            out.close();
         }
      }
   }
}

Jetzt haben wir eine Datei input.txt mit folgendem Inhalt -

This is test for copy file.

Kompilieren Sie als nächsten Schritt das obige Programm und führen Sie es aus. Dadurch wird die Datei output.txt mit dem gleichen Inhalt wie in input.txt erstellt. Fügen wir also den obigen Code in die Datei CopyFile.java ein und gehen Sie wie folgt vor:

$javac CopyFile.java $java CopyFile

Charakter-Streams

Java Byte Streams werden verwendet, um die Eingabe und Ausgabe von 8-Bit-Bytes durchzuführen, während Java CharacterStreams werden verwendet, um die Ein- und Ausgabe für 16-Bit-Unicode durchzuführen. Es gibt zwar viele Klassen, die sich auf Zeichenströme beziehen, aber die am häufigsten verwendeten Klassen sind:FileReader und FileWriter. Obwohl FileReader intern FileInputStream und FileWriter FileOutputStream verwendet, besteht der Hauptunterschied darin, dass FileReader jeweils zwei Bytes liest und FileWriter jeweils zwei Bytes schreibt.

Wir können das obige Beispiel neu schreiben, das diese beiden Klassen verwendet, um eine Eingabedatei (mit Unicode-Zeichen) in eine Ausgabedatei zu kopieren.

Example

import java.io.*;
public class CopyFile {

   public static void main(String args[]) throws IOException {
      FileReader in = null;
      FileWriter out = null;

      try {
         in = new FileReader("input.txt");
         out = new FileWriter("output.txt");
         
         int c;
         while ((c = in.read()) != -1) {
            out.write(c);
         }
      }finally {
         if (in != null) {
            in.close();
         }
         if (out != null) {
            out.close();
         }
      }
   }
}

Jetzt haben wir eine Datei input.txt mit folgendem Inhalt -

This is test for copy file.

Kompilieren Sie als nächsten Schritt das obige Programm und führen Sie es aus. Dadurch wird die Datei output.txt mit dem gleichen Inhalt wie in input.txt erstellt. Fügen wir also den obigen Code in die Datei CopyFile.java ein und gehen Sie wie folgt vor:

$javac CopyFile.java $java CopyFile

Standard-Streams

Alle Programmiersprachen unterstützen Standard-E / A, bei denen das Programm des Benutzers Eingaben von einer Tastatur entgegennehmen und dann eine Ausgabe auf dem Computerbildschirm erzeugen kann. Wenn Sie mit den Programmiersprachen C oder C ++ vertraut sind, müssen Sie die drei Standardgeräte STDIN, STDOUT und STDERR kennen. In ähnlicher Weise bietet Java die folgenden drei Standard-Streams:

• Standard Input - Dies wird verwendet, um die Daten dem Benutzerprogramm zuzuführen. In der Regel wird eine Tastatur als Standardeingabestream verwendet und als dargestellt System.in.

• Standard Output - Dies wird verwendet, um die vom Benutzerprogramm erzeugten Daten auszugeben, und normalerweise wird ein Computerbildschirm für den Standardausgabestream verwendet und als dargestellt System.out.

• Standard Error - Hiermit werden die vom Benutzerprogramm erzeugten Fehlerdaten ausgegeben. In der Regel wird ein Computerbildschirm für den Standardfehlerstrom verwendet und als dargestellt System.err.

Es folgt ein einfaches Programm, das erstellt InputStreamReader Standard-Eingabestream lesen, bis der Benutzer ein "q" eingibt -

Example

import java.io.*;
public class ReadConsole {

   public static void main(String args[]) throws IOException {
      InputStreamReader cin = null;

      try {
         cin = new InputStreamReader(System.in);
         System.out.println("Enter characters, 'q' to quit.");
         char c;
         do {
            c = (char) cin.read();
            System.out.print(c);
         } while(c != 'q');
      }finally {
         if (cin != null) {
            cin.close();
         }
      }
   }
}

Lassen Sie uns den obigen Code in der Datei ReadConsole.java behalten und versuchen, ihn wie im folgenden Programm gezeigt zu kompilieren und auszuführen. Dieses Programm liest und gibt das gleiche Zeichen weiter aus, bis wir 'q' drücken -

$javac ReadConsole.java $java ReadConsole
Enter characters, 'q' to quit.
1
1
e
e
q
q

Dateien lesen und schreiben

Wie zuvor beschrieben, kann ein Stream als eine Folge von Daten definiert werden. DasInputStream wird verwendet, um Daten aus einer Quelle zu lesen und die OutputStream wird zum Schreiben von Daten an ein Ziel verwendet.

Hier ist eine Hierarchie von Klassen, die sich mit Eingabe- und Ausgabestreams befassen.

Die zwei wichtigen Ströme sind FileInputStream und FileOutputStream, die in diesem Tutorial besprochen werden.

FileInputStream

Dieser Stream wird zum Lesen von Daten aus den Dateien verwendet. Objekte können mit dem Schlüsselwort erstellt werdennew und es gibt verschiedene Arten von Konstruktoren.

Der folgende Konstruktor verwendet einen Dateinamen als Zeichenfolge, um ein Eingabestreamobjekt zum Lesen der Datei zu erstellen.

InputStream f = new FileInputStream("C:/java/hello");

Der folgende Konstruktor verwendet ein Dateiobjekt, um ein Eingabestreamobjekt zum Lesen der Datei zu erstellen. Zuerst erstellen wir ein Dateiobjekt mit der File () -Methode wie folgt:

File f = new File("C:/java/hello");
InputStream f = new FileInputStream(f);

Sobald Sie das InputStream- Objekt zur Hand haben, gibt es eine Liste von Hilfsmethoden, die zum Lesen zum Streamen oder für andere Vorgänge im Stream verwendet werden können.

Sr.Nr.	Methode & Beschreibung
1	public void close() throws IOException{} Diese Methode schließt den Dateiausgabestream. Gibt alle mit der Datei verknüpften Systemressourcen frei. Löst eine IOException aus.
2	protected void finalize()throws IOException {} Diese Methode bereinigt die Verbindung zur Datei. Stellt sicher, dass die Methode close dieses Dateiausgabestreams aufgerufen wird, wenn keine Verweise mehr auf diesen Stream vorhanden sind. Löst eine IOException aus.
3	public int read(int r)throws IOException{} Diese Methode liest das angegebene Datenbyte aus dem InputStream. Gibt ein int zurück. Gibt das nächste Datenbyte zurück und -1 wird zurückgegeben, wenn es das Ende der Datei ist.
4	public int read(byte[] r) throws IOException{} Diese Methode liest r.length Bytes aus dem Eingabestream in ein Array. Gibt die Gesamtzahl der gelesenen Bytes zurück. Wenn es das Ende der Datei ist, wird -1 zurückgegeben.
5	public int available() throws IOException{} Gibt die Anzahl der Bytes an, die aus diesem Dateieingabestream gelesen werden können. Gibt ein int zurück.

Es stehen weitere wichtige Eingabestreams zur Verfügung. Weitere Informationen finden Sie unter den folgenden Links:

• ByteArrayInputStream

• DataInputStream

FileOutputStream

Mit FileOutputStream wird eine Datei erstellt und Daten in diese geschrieben. Der Stream erstellt eine Datei, falls diese noch nicht vorhanden ist, bevor er zur Ausgabe geöffnet wird.

Hier sind zwei Konstruktoren, mit denen ein FileOutputStream-Objekt erstellt werden kann.

Der folgende Konstruktor verwendet einen Dateinamen als Zeichenfolge, um ein Eingabestreamobjekt zum Schreiben der Datei zu erstellen.

OutputStream f = new FileOutputStream("C:/java/hello")

Der folgende Konstruktor verwendet ein Dateiobjekt, um ein Ausgabestreamobjekt zum Schreiben der Datei zu erstellen. Zuerst erstellen wir ein Dateiobjekt mit der File () -Methode wie folgt:

File f = new File("C:/java/hello");
OutputStream f = new FileOutputStream(f);

Sobald Sie das OutputStream- Objekt zur Hand haben, gibt es eine Liste von Hilfsmethoden , mit denen Sie in den Stream schreiben oder andere Vorgänge im Stream ausführen können.

Sr.Nr.	Methode & Beschreibung
1	public void close() throws IOException{} Diese Methode schließt den Dateiausgabestream. Gibt alle mit der Datei verknüpften Systemressourcen frei. Löst eine IOException aus.
2	protected void finalize()throws IOException {} Diese Methode bereinigt die Verbindung zur Datei. Stellt sicher, dass die Methode close dieses Dateiausgabestreams aufgerufen wird, wenn keine Verweise mehr auf diesen Stream vorhanden sind. Löst eine IOException aus.
3	public void write(int w)throws IOException{} Diese Methode schreibt das angegebene Byte in den Ausgabestream.
4	public void write(byte[] w) Schreibt w.length Bytes aus dem genannten Byte-Array in den OutputStream.

Es stehen weitere wichtige Ausgabestreams zur Verfügung. Weitere Informationen finden Sie unter den folgenden Links:

• ByteArrayOutputStream

• DataOutputStream

Example

Das folgende Beispiel zeigt InputStream und OutputStream -

import java.io.*;
public class fileStreamTest {

   public static void main(String args[]) {
   
      try {
         byte bWrite [] = {11,21,3,40,5};
         OutputStream os = new FileOutputStream("test.txt");
         for(int x = 0; x < bWrite.length ; x++) {
            os.write( bWrite[x] );   // writes the bytes
         }
         os.close();
     
         InputStream is = new FileInputStream("test.txt");
         int size = is.available();

         for(int i = 0; i < size; i++) {
            System.out.print((char)is.read() + "  ");
         }
         is.close();
      } catch (IOException e) {
         System.out.print("Exception");
      }	
   }
}

Der obige Code würde die Datei test.txt erstellen und gegebene Zahlen im Binärformat schreiben. Gleiches gilt für die Ausgabe auf dem Standardbildschirm.

Dateinavigation und E / A.

Es gibt mehrere andere Klassen, die wir durchlaufen würden, um die Grundlagen der Dateinavigation und der E / A kennenzulernen.

• Dateiklasse

• FileReader-Klasse

• FileWriter-Klasse

Verzeichnisse in Java

Ein Verzeichnis ist eine Datei, die eine Liste anderer Dateien und Verzeichnisse enthalten kann. Sie verwendenFileObjekt zum Erstellen von Verzeichnissen, zum Auflisten der in einem Verzeichnis verfügbaren Dateien. Überprüfen Sie für vollständige Details eine Liste aller Methoden, die Sie für das Dateiobjekt aufrufen können, und was sich auf Verzeichnisse bezieht.

Verzeichnisse erstellen

Es gibt zwei nützliche File Dienstprogrammmethoden, mit denen Verzeichnisse erstellt werden können -

• Das mkdir( )Die Methode erstellt ein Verzeichnis und gibt bei Erfolg true und bei Fehler false zurück. Ein Fehler zeigt an, dass der im Dateiobjekt angegebene Pfad bereits vorhanden ist oder dass das Verzeichnis nicht erstellt werden kann, da der gesamte Pfad noch nicht vorhanden ist.

• Das mkdirs() Methode erstellt sowohl ein Verzeichnis als auch alle übergeordneten Elemente des Verzeichnisses.

Das folgende Beispiel erstellt das Verzeichnis "/ tmp / user / java / bin" -

Example

import java.io.File;
public class CreateDir {

   public static void main(String args[]) {
      String dirname = "/tmp/user/java/bin";
      File d = new File(dirname);
      
      // Create directory now.
      d.mkdirs();
   }
}

Kompilieren Sie den obigen Code und führen Sie ihn aus, um "/ tmp / user / java / bin" zu erstellen.

Note- Java kümmert sich automatisch um Pfadtrennzeichen unter UNIX und Windows gemäß den Konventionen. Wenn Sie in einer Windows-Version von Java einen Schrägstrich (/) verwenden, wird der Pfad weiterhin korrekt aufgelöst.

Verzeichnisse auflisten

Sie können verwenden list( ) Methode bereitgestellt von File Objekt, um alle in einem Verzeichnis verfügbaren Dateien und Verzeichnisse wie folgt aufzulisten:

Example

import java.io.File;
public class ReadDir {

   public static void main(String[] args) {
      File file = null;
      String[] paths;
  
      try {      
         // create new file object
         file = new File("/tmp");

         // array of files and directory
         paths = file.list();

         // for each name in the path array
         for(String path:paths) {
            // prints filename and directory name
            System.out.println(path);
         }
      } catch (Exception e) {
         // if any error occurs
         e.printStackTrace();
      }
   }
}

Dies führt zu dem folgenden Ergebnis basierend auf den in Ihrem Verzeichnis verfügbaren Verzeichnissen und Dateien /tmp Verzeichnis -

Output

test1.txt
test2.txt
ReadDir.java
ReadDir.class

Eine Ausnahme (oder ein außergewöhnliches Ereignis) ist ein Problem, das während der Ausführung eines Programms auftritt. Wenn einException tritt der normale Programmfluss auf und das Programm / die Anwendung wird abnormal beendet, was nicht empfohlen wird. Daher sind diese Ausnahmen zu behandeln.

Eine Ausnahme kann aus vielen verschiedenen Gründen auftreten. Im Folgenden sind einige Szenarien aufgeführt, in denen eine Ausnahme auftritt.

• Ein Benutzer hat ungültige Daten eingegeben.

• Eine Datei, die geöffnet werden muss, kann nicht gefunden werden.

• Eine Netzwerkverbindung wurde während der Kommunikation unterbrochen oder der JVM hat nicht genügend Speicher.

Einige dieser Ausnahmen werden durch Benutzerfehler verursacht, andere durch Programmiererfehler und andere durch physische Ressourcen, die auf irgendeine Weise ausgefallen sind.

Basierend auf diesen haben wir drei Kategorien von Ausnahmen. Sie müssen sie verstehen, um zu wissen, wie die Ausnahmebehandlung in Java funktioniert.

• Checked exceptions- Eine geprüfte Ausnahme ist eine Ausnahme, die vom Compiler zur Kompilierungszeit geprüft (benachrichtigt) wird. Diese werden auch als Ausnahmen zur Kompilierungszeit bezeichnet. Diese Ausnahmen können nicht einfach ignoriert werden. Der Programmierer sollte sich um diese Ausnahmen kümmern (sie behandeln).

Zum Beispiel, wenn Sie verwenden FileReaderKlasse in Ihrem Programm, um Daten aus einer Datei zu lesen. Wenn die in ihrem Konstruktor angegebene Datei nicht vorhanden ist, tritt eine FileNotFoundException auf, und der Compiler fordert den Programmierer auf, die Ausnahme zu behandeln.

Beispiel

import java.io.File;
import java.io.FileReader;

public class FilenotFound_Demo {

   public static void main(String args[]) {		
      File file = new File("E://file.txt");
      FileReader fr = new FileReader(file); 
   }
}

Wenn Sie versuchen, das obige Programm zu kompilieren, erhalten Sie die folgenden Ausnahmen.

Ausgabe

C:\>javac FilenotFound_Demo.java
FilenotFound_Demo.java:8: error: unreported exception FileNotFoundException; must be caught or declared to be thrown
      FileReader fr = new FileReader(file);
                      ^
1 error

Note - Seit den Methoden read() und close() Wenn die FileReader-Klasse eine IOException auslöst, können Sie beobachten, dass der Compiler zusammen mit FileNotFoundException eine Benachrichtigung zur Behandlung der IOException sendet.

• Unchecked exceptions- Eine nicht aktivierte Ausnahme ist eine Ausnahme, die zum Zeitpunkt der Ausführung auftritt. Diese werden auch als bezeichnetRuntime Exceptions. Dazu gehören Programmierfehler wie Logikfehler oder die missbräuchliche Verwendung einer API. Laufzeitausnahmen werden zum Zeitpunkt der Kompilierung ignoriert.

Zum Beispiel, wenn Sie eine Reihe von Größe 5 in Ihrem Programm deklariert haben, und versuchen , das 6 zu nennen ^ten Element des Arrays dann ein ArrayIndexOutOfBoundsExceptionexception auftritt.

Beispiel

public class Unchecked_Demo {
   
   public static void main(String args[]) {
      int num[] = {1, 2, 3, 4};
      System.out.println(num[5]);
   }
}

Wenn Sie das obige Programm kompilieren und ausführen, erhalten Sie die folgende Ausnahme.

Ausgabe

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 5
	at Exceptions.Unchecked_Demo.main(Unchecked_Demo.java:8)

• Errors- Dies sind überhaupt keine Ausnahmen, sondern Probleme, die außerhalb der Kontrolle des Benutzers oder des Programmierers auftreten. Fehler werden in Ihrem Code normalerweise ignoriert, da Sie selten etwas gegen einen Fehler unternehmen können. Wenn beispielsweise ein Stapelüberlauf auftritt, tritt ein Fehler auf. Sie werden zum Zeitpunkt der Kompilierung ebenfalls ignoriert.

Ausnahmehierarchie

Alle Ausnahmeklassen sind Untertypen der Klasse java.lang.Exception. Die Ausnahmeklasse ist eine Unterklasse der Throwable-Klasse. Neben der Ausnahmeklasse gibt es eine weitere Unterklasse namens Error, die von der Throwable-Klasse abgeleitet ist.

Fehler sind abnormale Zustände, die bei schwerwiegenden Fehlern auftreten. Diese werden von den Java-Programmen nicht behandelt. Fehler werden generiert, um Fehler anzuzeigen, die von der Laufzeitumgebung generiert wurden. Beispiel: JVM hat nicht genügend Speicher. Normalerweise können Programme keine Fehler beheben.

Die Exception-Klasse hat zwei Hauptunterklassen: IOException-Klasse und RuntimeException-Klasse.

Im Folgenden finden Sie eine Liste der am häufigsten aktivierten und deaktivierten integrierten Ausnahmen von Java .

Ausnahmemethoden

Im Folgenden finden Sie eine Liste wichtiger Methoden, die in der Throwable-Klasse verfügbar sind.

Sr.Nr.	Methode & Beschreibung
1	public String getMessage() Gibt eine detaillierte Nachricht über die aufgetretene Ausnahme zurück. Diese Nachricht wird im Throwable-Konstruktor initialisiert.
2	public Throwable getCause() Gibt die Ursache der Ausnahme zurück, die durch ein Throwable-Objekt dargestellt wird.
3	public String toString() Gibt den Namen der Klasse zurück, die mit dem Ergebnis von getMessage () verknüpft ist.
4	public void printStackTrace() Druckt das Ergebnis von toString () zusammen mit der Stapelverfolgung an System.err, den Fehlerausgabestream.
5	public StackTraceElement [] getStackTrace() Gibt ein Array zurück, das jedes Element in der Stapelverfolgung enthält. Das Element am Index 0 repräsentiert den oberen Rand des Aufrufstapels, und das letzte Element im Array repräsentiert die Methode am unteren Rand des Aufrufstapels.
6	public Throwable fillInStackTrace() Füllt die Stapelverfolgung dieses Throwable-Objekts mit der aktuellen Stapelverfolgung und fügt alle vorherigen Informationen in der Stapelverfolgung hinzu.

Ausnahmen fangen

Eine Methode fängt eine Ausnahme mit einer Kombination aus try und catchSchlüsselwörter. Um den Code wird ein Try / Catch-Block platziert, der möglicherweise eine Ausnahme generiert. Code in einem try / catch-Block wird als geschützter Code bezeichnet, und die Syntax für die Verwendung von try / catch sieht wie folgt aus:

Syntax

try {
   // Protected code
} catch (ExceptionName e1) {
   // Catch block
}

Der Code, der für Ausnahmen anfällig ist, wird in den try-Block eingefügt. Wenn eine Ausnahme auftritt, wird diese Ausnahme von dem damit verbundenen catch-Block behandelt. Auf jeden Try-Block sollte sofort entweder ein Catch-Block oder ein Final-Block folgen.

Bei einer catch-Anweisung wird die Art der Ausnahme angegeben, die Sie abfangen möchten. Wenn im geschützten Code eine Ausnahme auftritt, wird der oder die nach dem Versuch folgenden catch-Blöcke überprüft. Wenn der Typ der aufgetretenen Ausnahme in einem catch-Block aufgeführt ist, wird die Ausnahme an den catch-Block übergeben, ähnlich wie ein Argument an einen Methodenparameter übergeben wird.

Beispiel

Das folgende Array ist mit 2 Elementen deklariert. Dann versucht der Code die 3 für den Zugriff auf ^rd Element des Arrays , die eine Ausnahme ausgelöst.

// File Name : ExcepTest.java
import java.io.*;

public class ExcepTest {

   public static void main(String args[]) {
      try {
         int a[] = new int[2];
         System.out.println("Access element three :" + a[3]);
      } catch (ArrayIndexOutOfBoundsException e) {
         System.out.println("Exception thrown  :" + e);
      }
      System.out.println("Out of the block");
   }
}

Dies führt zu folgendem Ergebnis:

Ausgabe

Exception thrown  :java.lang.ArrayIndexOutOfBoundsException: 3
Out of the block

Mehrere Fangblöcke

Auf einen Try-Block können mehrere Catch-Blöcke folgen. Die Syntax für mehrere Catch-Blöcke sieht wie folgt aus:

Syntax

try {
   // Protected code
} catch (ExceptionType1 e1) {
   // Catch block
} catch (ExceptionType2 e2) {
   // Catch block
} catch (ExceptionType3 e3) {
   // Catch block
}

Die vorherigen Anweisungen zeigen drei Fangblöcke, aber Sie können nach einem einzigen Versuch eine beliebige Anzahl davon haben. Wenn im geschützten Code eine Ausnahme auftritt, wird die Ausnahme in den ersten catch-Block in der Liste ausgelöst. Wenn der Datentyp der ausgelösten Ausnahme mit ExceptionType1 übereinstimmt, wird er dort abgefangen. Wenn nicht, wird die Ausnahme an die zweite catch-Anweisung weitergegeben. Dies wird fortgesetzt, bis die Ausnahme entweder abgefangen wird oder alle Fänge durchläuft. In diesem Fall stoppt die aktuelle Methode die Ausführung und die Ausnahme wird auf die vorherige Methode im Aufrufstapel zurückgesetzt.

Beispiel

Hier ist ein Codesegment, das zeigt, wie mehrere try / catch-Anweisungen verwendet werden.

try {
   file = new FileInputStream(fileName);
   x = (byte) file.read();
} catch (IOException i) {
   i.printStackTrace();
   return -1;
} catch (FileNotFoundException f) // Not valid! {
   f.printStackTrace();
   return -1;
}

Mehrere Arten von Ausnahmen abfangen

Da Sie mit Java 7 mehr als eine Ausnahme mit einem einzigen Catch-Block behandeln können, vereinfacht diese Funktion den Code. Hier ist, wie Sie es tun würden -

catch (IOException|FileNotFoundException ex) {
   logger.log(ex);
   throw ex;

Die Schlüsselwörter Throws / Throw

Wenn eine Methode eine geprüfte Ausnahme nicht behandelt, muss sie von der Methode deklariert werden throwsStichwort. Das Schlüsselwort throw wird am Ende der Signatur einer Methode angezeigt.

Sie können eine Ausnahme auslösen, entweder eine neu instanziierte oder eine Ausnahme, die Sie gerade abgefangen haben, indem Sie die throw Stichwort.

Versuchen Sie, den Unterschied zwischen Throws und Throw-Schlüsselwörtern zu verstehen. Mit Throws wird die Behandlung einer aktivierten Ausnahme verschoben und mit Throw wird eine Ausnahme explizit aufgerufen.

Die folgende Methode deklariert, dass eine RemoteException ausgelöst wird -

Beispiel

import java.io.*;
public class className {

   public void deposit(double amount) throws RemoteException {
      // Method implementation
      throw new RemoteException();
   }
   // Remainder of class definition
}

Eine Methode kann deklarieren, dass sie mehr als eine Ausnahme auslöst. In diesem Fall werden die Ausnahmen in einer durch Kommas getrennten Liste deklariert. Die folgende Methode deklariert beispielsweise, dass eine RemoteException und eine InsufficientFundsException ausgelöst werden.

Beispiel

import java.io.*;
public class className {

   public void withdraw(double amount) throws RemoteException, 
      InsufficientFundsException {
      // Method implementation
   }
   // Remainder of class definition
}

Der endgültige Block

Der finally-Block folgt einem try-Block oder einem catch-Block. Ein endgültiger Codeblock wird immer ausgeführt, unabhängig vom Auftreten einer Ausnahme.

Mit einem finally-Block können Sie alle Anweisungen vom Bereinigungstyp ausführen, die Sie ausführen möchten, unabhängig davon, was im geschützten Code geschieht.

Ein finally-Block wird am Ende der catch-Blöcke angezeigt und hat die folgende Syntax:

Syntax

try {
   // Protected code
} catch (ExceptionType1 e1) {
   // Catch block
} catch (ExceptionType2 e2) {
   // Catch block
} catch (ExceptionType3 e3) {
   // Catch block
}finally {
   // The finally block always executes.
}

Beispiel

public class ExcepTest {

   public static void main(String args[]) {
      int a[] = new int[2];
      try {
         System.out.println("Access element three :" + a[3]);
      } catch (ArrayIndexOutOfBoundsException e) {
         System.out.println("Exception thrown  :" + e);
      }finally {
         a[0] = 6;
         System.out.println("First element value: " + a[0]);
         System.out.println("The finally statement is executed");
      }
   }
}

Dies führt zu folgendem Ergebnis:

Ausgabe

Exception thrown  :java.lang.ArrayIndexOutOfBoundsException: 3
First element value: 6
The finally statement is executed

Beachten Sie Folgendes -

• Eine catch-Klausel kann ohne eine try-Anweisung nicht existieren.

• Es ist nicht obligatorisch, finally-Klauseln zu haben, wenn ein try / catch-Block vorhanden ist.

• Der try-Block kann weder ohne catch-Klausel noch ohne finally-Klausel vorhanden sein.

• Zwischen den Blöcken try, catch und finally kann kein Code vorhanden sein.

Der Versuch mit Ressourcen

Wenn wir Ressourcen wie Streams, Verbindungen usw. verwenden, müssen wir diese im Allgemeinen explizit mit finally block schließen. Im folgenden Programm lesen wir Daten aus einer Datei mitFileReader und wir schließen es mit finally block.

Beispiel

import java.io.File;
import java.io.FileReader;
import java.io.IOException;

public class ReadData_Demo {

   public static void main(String args[]) {
      FileReader fr = null;		
      try {
         File file = new File("file.txt");
         fr = new FileReader(file); char [] a = new char[50];
         fr.read(a);   // reads the content to the array
         for(char c : a)
         System.out.print(c);   // prints the characters one by one
      } catch (IOException e) {
         e.printStackTrace();
      }finally {
         try {
            fr.close();
         } catch (IOException ex) {		
            ex.printStackTrace();
         }
      }
   }
}

try-with-resources, auch bezeichnet als automatic resource managementist ein neuer Ausnahmebehandlungsmechanismus, der in Java 7 eingeführt wurde und die im try catch-Block verwendeten Ressourcen automatisch schließt.

Um diese Anweisung zu verwenden, müssen Sie lediglich die erforderlichen Ressourcen in Klammern deklarieren. Die erstellte Ressource wird am Ende des Blocks automatisch geschlossen. Es folgt die Syntax der Anweisung try-with-resources.

Syntax

try(FileReader fr = new FileReader("file path")) {
   // use the resource
   } catch () {
      // body of catch 
   }
}

Das folgende Programm liest die Daten in einer Datei mithilfe der Anweisung try-with-resources.

Beispiel

import java.io.FileReader;
import java.io.IOException;

public class Try_withDemo {

   public static void main(String args[]) {
      try(FileReader fr = new FileReader("E://file.txt")) {
         char [] a = new char[50];
         fr.read(a);   // reads the contentto the array
         for(char c : a)
         System.out.print(c);   // prints the characters one by one
      } catch (IOException e) {
         e.printStackTrace();
      }
   }
}

Die folgenden Punkte sind bei der Arbeit mit der Try-with-Resources-Anweisung zu beachten.

• Um eine Klasse mit der Anweisung try-with-resources zu verwenden, sollte sie implementiert werden AutoCloseable Schnittstelle und die close() Methode davon wird automatisch zur Laufzeit aufgerufen.

• Sie können mehr als eine Klasse in der Anweisung try-with-resources deklarieren.

• Während Sie im try-Block der try-with-resources-Anweisung mehrere Klassen deklarieren, werden diese Klassen in umgekehrter Reihenfolge geschlossen.

• Mit Ausnahme der Deklaration von Ressourcen in Klammern entspricht alles dem normalen try / catch-Block eines try-Blocks.

• Die in try deklarierte Ressource wird unmittelbar vor dem Start des try-Blocks instanziiert.

• Die im try-Block deklarierte Ressource wird implizit als final deklariert.

Benutzerdefinierte Ausnahmen

Sie können Ihre eigenen Ausnahmen in Java erstellen. Beachten Sie beim Schreiben Ihrer eigenen Ausnahmeklassen die folgenden Punkte:

• Alle Ausnahmen müssen ein Kind von Throwable sein.

• Wenn Sie eine aktivierte Ausnahme schreiben möchten, die automatisch von der Handle- oder Deklarationsregel erzwungen wird, müssen Sie die Ausnahmeklasse erweitern.

• Wenn Sie eine Laufzeitausnahme schreiben möchten, müssen Sie die RuntimeException-Klasse erweitern.

Wir können unsere eigene Ausnahmeklasse wie folgt definieren:

class MyException extends Exception {
}

Sie müssen nur die vordefinierten erweitern ExceptionKlasse, um Ihre eigene Ausnahme zu erstellen. Diese gelten als geprüfte Ausnahmen. FolgendeInsufficientFundsExceptionclass ist eine benutzerdefinierte Ausnahme, die die Exception-Klasse erweitert und zu einer aktivierten Ausnahme macht. Eine Ausnahmeklasse ist wie jede andere Klasse und enthält nützliche Felder und Methoden.

Beispiel

// File Name InsufficientFundsException.java
import java.io.*;

public class InsufficientFundsException extends Exception {
   private double amount;
   
   public InsufficientFundsException(double amount) {
      this.amount = amount;
   }
   
   public double getAmount() {
      return amount;
   }
}

Um die Verwendung unserer benutzerdefinierten Ausnahme zu demonstrieren, enthält die folgende CheckingAccount-Klasse eine draw () -Methode, die eine InsufficientFundsException auslöst.

// File Name CheckingAccount.java
import java.io.*;

public class CheckingAccount {
   private double balance;
   private int number;
   
   public CheckingAccount(int number) {
      this.number = number;
   }
   
   public void deposit(double amount) {
      balance += amount;
   }
   
   public void withdraw(double amount) throws InsufficientFundsException {
      if(amount <= balance) {
         balance -= amount;
      }else {
         double needs = amount - balance;
         throw new InsufficientFundsException(needs);
      }
   }
   
   public double getBalance() {
      return balance;
   }
   
   public int getNumber() {
      return number;
   }
}

Das folgende BankDemo-Programm demonstriert das Aufrufen der Einzahlungs- () und Auszahlungsmethoden () von CheckingAccount.

// File Name BankDemo.java
public class BankDemo {

   public static void main(String [] args) {
      CheckingAccount c = new CheckingAccount(101);
      System.out.println("Depositing $500..."); c.deposit(500.00); try { System.out.println("\nWithdrawing $100...");
         c.withdraw(100.00);
         System.out.println("\nWithdrawing $600..."); c.withdraw(600.00); } catch (InsufficientFundsException e) { System.out.println("Sorry, but you are short $" + e.getAmount());
         e.printStackTrace();
      }
   }
}

Kompilieren Sie alle drei oben genannten Dateien und führen Sie BankDemo aus. Dies führt zu folgendem Ergebnis:

Ausgabe

Depositing $500... Withdrawing $100...

Withdrawing $600... Sorry, but you are short $200.0
InsufficientFundsException
         at CheckingAccount.withdraw(CheckingAccount.java:25)
         at BankDemo.main(BankDemo.java:13)

Häufige Ausnahmen

In Java ist es möglich, zwei Kategorien von Ausnahmen und Fehlern zu definieren.

• JVM Exceptions- Dies sind Ausnahmen / Fehler, die ausschließlich oder logisch von der JVM ausgelöst werden. Beispiele: NullPointerException, ArrayIndexOutOfBoundsException, ClassCastException.

• Programmatic Exceptions- Diese Ausnahmen werden explizit von der Anwendung oder den API-Programmierern ausgelöst. Beispiele: IllegalArgumentException, IllegalStateException.

In diesem Kapitel werden wir innere Klassen von Java diskutieren.

Verschachtelte Klassen

In Java können ebenso wie Methoden auch Variablen einer Klasse eine andere Klasse als Mitglied haben. Das Schreiben einer Klasse innerhalb einer anderen ist in Java zulässig. Die darin geschriebene Klasse heißtnested classund die Klasse, die die innere Klasse enthält, heißt die outer class.

Syntax

Es folgt die Syntax zum Schreiben einer verschachtelten Klasse. Hier die KlasseOuter_Demo ist die äußere Klasse und die Klasse Inner_Demo ist die verschachtelte Klasse.

class Outer_Demo {
   class Inner_Demo {
   }
}

Verschachtelte Klassen werden in zwei Typen unterteilt:

• Non-static nested classes - Dies sind die nicht statischen Mitglieder einer Klasse.

• Static nested classes - Dies sind die statischen Mitglieder einer Klasse.

Innere Klassen (nicht statische verschachtelte Klassen)

Innere Klassen sind ein Sicherheitsmechanismus in Java. Wir wissen, dass dem Zugriffsmodifikator keine Klasse zugeordnet werden kannprivate, aber wenn wir die Klasse als Mitglied einer anderen Klasse haben, kann die innere Klasse privat gemacht werden. Dies wird auch verwendet, um auf die privaten Mitglieder einer Klasse zuzugreifen.

Es gibt drei Arten von inneren Klassen, je nachdem, wie und wo Sie sie definieren. Sie sind -

• Innere Klasse
• Methodenlokale innere Klasse
• Anonyme innere Klasse

Innere Klasse

Das Erstellen einer inneren Klasse ist ganz einfach. Sie müssen nur eine Klasse innerhalb einer Klasse schreiben. Im Gegensatz zu einer Klasse kann eine innere Klasse privat sein. Wenn Sie eine innere Klasse als privat deklarieren, kann von einem Objekt außerhalb der Klasse nicht mehr darauf zugegriffen werden.

Es folgt das Programm zum Erstellen einer inneren Klasse und zum Zugriff darauf. Im angegebenen Beispiel machen wir die innere Klasse privat und greifen über eine Methode auf die Klasse zu.

Example

class Outer_Demo {
   int num;
   
   // inner class
   private class Inner_Demo {
      public void print() {
         System.out.println("This is an inner class");
      }
   }
   
   // Accessing he inner class from the method within
   void display_Inner() {
      Inner_Demo inner = new Inner_Demo();
      inner.print();
   }
}
   
public class My_class {

   public static void main(String args[]) {
      // Instantiating the outer class 
      Outer_Demo outer = new Outer_Demo();
      
      // Accessing the display_Inner() method.
      outer.display_Inner();
   }
}

Hier können Sie das beobachten Outer_Demo ist die äußere Klasse, Inner_Demo ist die innere Klasse, display_Inner() ist die Methode, in der wir die innere Klasse instanziieren, und diese Methode wird von der aufgerufen main Methode.

Wenn Sie das obige Programm kompilieren und ausführen, erhalten Sie das folgende Ergebnis:

Output

This is an inner class.

Zugriff auf die privaten Mitglieder

Wie bereits erwähnt, werden innere Klassen auch verwendet, um auf die privaten Mitglieder einer Klasse zuzugreifen. Angenommen, eine Klasse hat private Mitglieder, um auf sie zuzugreifen. Schreiben Sie eine innere Klasse hinein, geben Sie die privaten Mitglieder von einer Methode innerhalb der inneren Klasse zurück, z.getValue()Rufen Sie schließlich von einer anderen Klasse (von der aus Sie auf die privaten Mitglieder zugreifen möchten) die Methode getValue () der inneren Klasse auf.

Um die innere Klasse zu instanziieren, müssen Sie zunächst die äußere Klasse instanziieren. Anschließend können Sie anhand des Objekts der äußeren Klasse die innere Klasse instanziieren.

Outer_Demo outer = new Outer_Demo();
Outer_Demo.Inner_Demo inner = outer.new Inner_Demo();

Das folgende Programm zeigt, wie Sie mit der inneren Klasse auf die privaten Mitglieder einer Klasse zugreifen.

Example

class Outer_Demo {
   // private variable of the outer class
   private int num = 175;  
   
   // inner class
   public class Inner_Demo {
      public int getNum() {
         System.out.println("This is the getnum method of the inner class");
         return num;
      }
   }
}

public class My_class2 {

   public static void main(String args[]) {
      // Instantiating the outer class
      Outer_Demo outer = new Outer_Demo();
      
      // Instantiating the inner class
      Outer_Demo.Inner_Demo inner = outer.new Inner_Demo();
      System.out.println(inner.getNum());
   }
}

Wenn Sie das obige Programm kompilieren und ausführen, erhalten Sie das folgende Ergebnis:

Output

This is the getnum method of the inner class: 175

Methodenlokale innere Klasse

In Java können wir eine Klasse innerhalb einer Methode schreiben, und dies ist ein lokaler Typ. Wie bei lokalen Variablen ist der Umfang der inneren Klasse innerhalb der Methode eingeschränkt.

Eine methodenlokale innere Klasse kann nur innerhalb der Methode instanziiert werden, in der die innere Klasse definiert ist. Das folgende Programm zeigt, wie eine methodenlokale innere Klasse verwendet wird.

Example

public class Outerclass {
   // instance method of the outer class 
   void my_Method() {
      int num = 23;

      // method-local inner class
      class MethodInner_Demo {
         public void print() {
            System.out.println("This is method inner class "+num);	   
         }   
      } // end of inner class
	   
      // Accessing the inner class
      MethodInner_Demo inner = new MethodInner_Demo();
      inner.print();
   }
   
   public static void main(String args[]) {
      Outerclass outer = new Outerclass();
      outer.my_Method();	   	   
   }
}

Wenn Sie das obige Programm kompilieren und ausführen, erhalten Sie das folgende Ergebnis:

Output

This is method inner class 23

Anonyme innere Klasse

Eine innere Klasse, die ohne Klassennamen deklariert wurde, wird als bezeichnet anonymous inner class. Bei anonymen inneren Klassen deklarieren und instanziieren wir sie gleichzeitig. Im Allgemeinen werden sie immer dann verwendet, wenn Sie die Methode einer Klasse oder einer Schnittstelle überschreiben müssen. Die Syntax einer anonymen inneren Klasse lautet wie folgt:

Syntax

AnonymousInner an_inner = new AnonymousInner() {
   public void my_method() {
      ........
      ........
   }   
};

Das folgende Programm zeigt, wie die Methode einer Klasse mithilfe einer anonymen inneren Klasse überschrieben wird.

Example

abstract class AnonymousInner {
   public abstract void mymethod();
}

public class Outer_class {

   public static void main(String args[]) {
      AnonymousInner inner = new AnonymousInner() {
         public void mymethod() {
            System.out.println("This is an example of anonymous inner class");
         }
      };
      inner.mymethod();	
   }
}

Wenn Sie das obige Programm kompilieren und ausführen, erhalten Sie das folgende Ergebnis:

Output

This is an example of anonymous inner class

Auf die gleiche Weise können Sie die Methoden der konkreten Klasse sowie der Schnittstelle mithilfe einer anonymen inneren Klasse überschreiben.

Anonyme innere Klasse als Argument

Wenn eine Methode ein Objekt einer Schnittstelle, einer abstrakten Klasse oder einer konkreten Klasse akzeptiert, können wir im Allgemeinen die Schnittstelle implementieren, die abstrakte Klasse erweitern und das Objekt an die Methode übergeben. Wenn es sich um eine Klasse handelt, können wir sie direkt an die Methode übergeben.

In allen drei Fällen können Sie der Methode jedoch eine anonyme innere Klasse übergeben. Hier ist die Syntax zum Übergeben einer anonymen inneren Klasse als Methodenargument:

obj.my_Method(new My_Class() {
   public void Do() {
      .....
      .....
   }
});

Das folgende Programm zeigt, wie eine anonyme innere Klasse als Methodenargument übergeben wird.

Example

// interface
interface Message {
   String greet();
}

public class My_class {
   // method which accepts the object of interface Message
   public void displayMessage(Message m) {
      System.out.println(m.greet() +
         ", This is an example of anonymous inner class as an argument");  
   }

   public static void main(String args[]) {
      // Instantiating the class
      My_class obj = new My_class();

      // Passing an anonymous inner class as an argument
      obj.displayMessage(new Message() {
         public String greet() {
            return "Hello";
         }
      });
   }
}

Wenn Sie das obige Programm kompilieren und ausführen, erhalten Sie das folgende Ergebnis:

Output

Hello, This is an example of anonymous inner class as an argument

Statisch verschachtelte Klasse

Eine statische innere Klasse ist eine verschachtelte Klasse, die ein statisches Mitglied der äußeren Klasse ist. Auf den Zugriff kann zugegriffen werden, ohne die äußere Klasse mithilfe anderer statischer Elemente zu instanziieren. Genau wie statische Elemente hat eine statisch verschachtelte Klasse keinen Zugriff auf die Instanzvariablen und -methoden der äußeren Klasse. Die Syntax der statisch verschachtelten Klasse lautet wie folgt:

Syntax

class MyOuter {
   static class Nested_Demo {
   }
}

Das Instanziieren einer statisch verschachtelten Klasse unterscheidet sich ein wenig vom Instanziieren einer inneren Klasse. Das folgende Programm zeigt, wie eine statisch verschachtelte Klasse verwendet wird.

Example

public class Outer {
   static class Nested_Demo {
      public void my_method() {
         System.out.println("This is my nested class");
      }
   }
   
   public static void main(String args[]) {
      Outer.Nested_Demo nested = new Outer.Nested_Demo();	 
      nested.my_method();
   }
}

Wenn Sie das obige Programm kompilieren und ausführen, erhalten Sie das folgende Ergebnis:

Output

This is my nested class

Vererbung kann als der Prozess definiert werden, bei dem eine Klasse die Eigenschaften (Methoden und Felder) einer anderen Klasse erhält. Durch die Verwendung der Vererbung werden die Informationen in einer hierarchischen Reihenfolge verwaltet.

Die Klasse, die die Eigenschaften anderer erbt, wird als Unterklasse (abgeleitete Klasse, untergeordnete Klasse) bezeichnet, und die Klasse, deren Eigenschaften vererbt werden, wird als Oberklasse (Basisklasse, übergeordnete Klasse) bezeichnet.

erweitert Keyword

extendsist das Schlüsselwort, mit dem die Eigenschaften einer Klasse geerbt werden. Es folgt die Syntax des erweiterten Schlüsselworts.

Syntax

class Super {
   .....
   .....
}
class Sub extends Super {
   .....
   .....
}

Beispielcode

Das folgende Beispiel zeigt die Java-Vererbung. In diesem Beispiel können Sie zwei Klassen beobachten, nämlich Berechnung und My_Calculation.

Bei Verwendung des Schlüsselworts extensiv erbt My_Calculation die Methoden Addition () und Subtraction () der Berechnungsklasse.

Kopieren Sie das folgende Programm und fügen Sie es in eine Datei mit dem Namen My_Calculation.java ein

Example

class Calculation {
   int z;
	
   public void addition(int x, int y) {
      z = x + y;
      System.out.println("The sum of the given numbers:"+z);
   }
	
   public void Subtraction(int x, int y) {
      z = x - y;
      System.out.println("The difference between the given numbers:"+z);
   }
}

public class My_Calculation extends Calculation {
   public void multiplication(int x, int y) {
      z = x * y;
      System.out.println("The product of the given numbers:"+z);
   }
	
   public static void main(String args[]) {
      int a = 20, b = 10;
      My_Calculation demo = new My_Calculation();
      demo.addition(a, b);
      demo.Subtraction(a, b);
      demo.multiplication(a, b);
   }
}

Kompilieren Sie den obigen Code und führen Sie ihn wie unten gezeigt aus.

javac My_Calculation.java
java My_Calculation

Nach dem Ausführen des Programms wird das folgende Ergebnis angezeigt:

Output

The sum of the given numbers:30
The difference between the given numbers:10
The product of the given numbers:200

Im gegebenen Programm, wenn ein Objekt zu My_CalculationWenn eine Klasse erstellt wird, wird eine Kopie des Inhalts der Oberklasse darin erstellt. Aus diesem Grund können Sie mit dem Objekt der Unterklasse auf die Mitglieder einer Oberklasse zugreifen.

Die Superclass-Referenzvariable kann das Unterklassenobjekt enthalten. Mit dieser Variablen können Sie jedoch nur auf die Mitglieder der Superklasse zugreifen. Um auf die Mitglieder beider Klassen zuzugreifen, wird empfohlen, immer eine Referenzvariable für die Unterklasse zu erstellen.

Wenn Sie das obige Programm in Betracht ziehen, können Sie die Klasse wie unten angegeben instanziieren. Verwenden Sie jedoch die Referenzvariable der Oberklasse (cal In diesem Fall können Sie die Methode nicht aufrufen multiplication(), die zur Unterklasse My_Calculation gehört.

Calculation demo = new My_Calculation();
demo.addition(a, b);
demo.Subtraction(a, b);

Note- Eine Unterklasse erbt alle Mitglieder (Felder, Methoden und verschachtelte Klassen) von ihrer Oberklasse. Konstruktoren sind keine Mitglieder, daher werden sie nicht von Unterklassen geerbt, aber der Konstruktor der Oberklasse kann aus der Unterklasse aufgerufen werden.

Das Super-Schlüsselwort

Das super Schlüsselwort ist ähnlich wie thisStichwort. Es folgen die Szenarien, in denen das Schlüsselwort super verwendet wird.

• Es ist daran gewöhnt differentiate the members der Oberklasse von den Mitgliedern der Unterklasse, wenn sie den gleichen Namen haben.

• Es ist daran gewöhnt invoke the superclass Konstruktor aus der Unterklasse.

Differenzierung der Mitglieder

Wenn eine Klasse die Eigenschaften einer anderen Klasse erbt. Und wenn die Mitglieder der Oberklasse dieselben Namen wie die Unterklasse haben, verwenden wir zur Unterscheidung dieser Variablen das Schlüsselwort super, wie unten gezeigt.

super.variable
super.method();

Beispielcode

In diesem Abschnitt finden Sie ein Programm, das die Verwendung von demonstriert super Stichwort.

In dem angegebenen Programm haben Sie zwei Klassen, nämlich Sub_class und Super_class , beide haben eine Methode namens display () mit unterschiedlichen Implementierungen und eine Variable namens num mit unterschiedlichen Werten. Wir rufen die display () -Methode beider Klassen auf und drucken den Wert der Variablen num beider Klassen. Hier können Sie beobachten, dass wir das Schlüsselwort super verwendet haben, um die Mitglieder der Oberklasse von der Unterklasse zu unterscheiden.

Kopieren Sie das Programm und fügen Sie es in eine Datei mit dem Namen Sub_class.java ein.

Example

class Super_class {
   int num = 20;

   // display method of superclass
   public void display() {
      System.out.println("This is the display method of superclass");
   }
}

public class Sub_class extends Super_class {
   int num = 10;

   // display method of sub class
   public void display() {
      System.out.println("This is the display method of subclass");
   }

   public void my_method() {
      // Instantiating subclass
      Sub_class sub = new Sub_class();

      // Invoking the display() method of sub class
      sub.display();

      // Invoking the display() method of superclass
      super.display();

      // printing the value of variable num of subclass
      System.out.println("value of the variable named num in sub class:"+ sub.num);

      // printing the value of variable num of superclass
      System.out.println("value of the variable named num in super class:"+ super.num);
   }

   public static void main(String args[]) {
      Sub_class obj = new Sub_class();
      obj.my_method();
   }
}

Kompilieren Sie den obigen Code und führen Sie ihn mit der folgenden Syntax aus.

javac Super_Demo
java Super

Bei Ausführung des Programms erhalten Sie folgendes Ergebnis:

Output

This is the display method of subclass
This is the display method of superclass
value of the variable named num in sub class:10
value of the variable named num in super class:20

Aufrufen des Superclass-Konstruktors

Wenn eine Klasse die Eigenschaften einer anderen Klasse erbt, erhält die Unterklasse automatisch den Standardkonstruktor der Oberklasse. Wenn Sie jedoch einen parametrisierten Konstruktor der Oberklasse aufrufen möchten, müssen Sie das Schlüsselwort super wie unten gezeigt verwenden.

super(values);

Beispielcode

Das in diesem Abschnitt beschriebene Programm zeigt, wie mit dem Schlüsselwort super der parametrisierte Konstruktor der Oberklasse aufgerufen wird. Dieses Programm enthält eine Oberklasse und eine Unterklasse, wobei die Oberklasse einen parametrisierten Konstruktor enthält, der einen ganzzahligen Wert akzeptiert, und wir haben das Schlüsselwort super verwendet, um den parametrisierten Konstruktor der Oberklasse aufzurufen.

Kopieren Sie das folgende Programm und fügen Sie es in eine Datei mit dem Namen Subclass.java ein

Example

class Superclass {
   int age;

   Superclass(int age) {
      this.age = age; 		 
   }

   public void getAge() {
      System.out.println("The value of the variable named age in super class is: " +age);
   }
}

public class Subclass extends Superclass {
   Subclass(int age) {
      super(age);
   }

   public static void main(String args[]) {
      Subclass s = new Subclass(24);
      s.getAge();
   }
}

Kompilieren Sie den obigen Code und führen Sie ihn mit der folgenden Syntax aus.

javac Subclass
java Subclass

Bei Ausführung des Programms erhalten Sie folgendes Ergebnis:

Output

The value of the variable named age in super class is: 24

IS-A-Beziehung

IS-A ist eine Art zu sagen: Dieses Objekt ist ein Typ dieses Objekts. Mal sehen, wie dieextends Schlüsselwort wird verwendet, um Vererbung zu erreichen.

public class Animal {
}

public class Mammal extends Animal {
}

public class Reptile extends Animal {
}

public class Dog extends Mammal {
}

Basierend auf dem obigen Beispiel ist nun objektorientiert Folgendes wahr:

• Tier ist die Oberklasse der Säugetierklasse.
• Tier ist die Oberklasse der Reptilienklasse.
• Säugetier und Reptil sind Unterklassen der Tierklasse.
• Hund ist die Unterklasse der Säugetier- und Tierklassen.

Wenn wir nun die IS-A-Beziehung betrachten, können wir sagen:

• Säugetier IS-A Tier
• Reptil IS-A Tier
• Hund ist ein Säugetier
• Daher: Hund ist auch ein Tier

Mit dem Schlüsselwort extens können die Unterklassen alle Eigenschaften der Oberklasse mit Ausnahme der privaten Eigenschaften der Oberklasse erben.

Mit dem Instanzoperator können wir sicherstellen, dass Mammal tatsächlich ein Tier ist.

Example

class Animal {
}

class Mammal extends Animal {
}

class Reptile extends Animal {
}

public class Dog extends Mammal {

   public static void main(String args[]) {
      Animal a = new Animal();
      Mammal m = new Mammal();
      Dog d = new Dog();

      System.out.println(m instanceof Animal);
      System.out.println(d instanceof Mammal);
      System.out.println(d instanceof Animal);
   }
}

Dies führt zu folgendem Ergebnis:

Output

true
true
true

Da haben wir ein gutes Verständnis für die extends Stichwort, lassen Sie uns untersuchen, wie die implements Das Schlüsselwort wird verwendet, um die IS-A-Beziehung abzurufen.

Im Allgemeinen ist die implementsDas Schlüsselwort wird mit Klassen verwendet, um die Eigenschaften einer Schnittstelle zu erben. Schnittstellen können niemals um eine Klasse erweitert werden.

Example

public interface Animal {
}

public class Mammal implements Animal {
}

public class Dog extends Mammal {
}

Die Instanz des Schlüsselworts

Verwenden wir die instanceof Bediener zu überprüfen, ob Säugetier tatsächlich ein Tier ist und Hund tatsächlich ein Tier ist.

Example

interface Animal{}
class Mammal implements Animal{}

public class Dog extends Mammal {

   public static void main(String args[]) {
      Mammal m = new Mammal();
      Dog d = new Dog();

      System.out.println(m instanceof Animal);
      System.out.println(d instanceof Mammal);
      System.out.println(d instanceof Animal);
   }
}

Dies führt zu folgendem Ergebnis:

Output

true
true
true

HAT-A Beziehung

Diese Beziehungen basieren hauptsächlich auf der Verwendung. Dies bestimmt, ob eine bestimmte KlasseHAS-Asichere Sache. Diese Beziehung trägt dazu bei, Doppelarbeit und Fehler zu reduzieren.

Schauen wir uns ein Beispiel an -

Example

public class Vehicle{}
public class Speed{}

public class Van extends Vehicle {
   private Speed sp;
}

Dies zeigt, dass Klasse Van HAS-A Speed. Durch eine separate Klasse für Geschwindigkeit müssen wir nicht den gesamten Code, der zur Geschwindigkeit gehört, in die Van-Klasse einfügen, sodass die Geschwindigkeitsklasse in mehreren Anwendungen wiederverwendet werden kann.

In der objektorientierten Funktion müssen sich die Benutzer nicht darum kümmern, welches Objekt die eigentliche Arbeit erledigt. Um dies zu erreichen, verbirgt die Van-Klasse die Implementierungsdetails vor den Benutzern der Van-Klasse. Im Grunde genommen fordern die Benutzer die Van-Klasse auf, eine bestimmte Aktion auszuführen, und die Van-Klasse erledigt die Arbeit entweder selbst oder bittet eine andere Klasse, die Aktion auszuführen.

Arten der Vererbung

Es gibt verschiedene Arten der Vererbung, wie unten gezeigt.

Eine sehr wichtige Tatsache ist, dass Java keine Mehrfachvererbung unterstützt. Dies bedeutet, dass eine Klasse nicht mehr als eine Klasse erweitern kann. Daher ist folgendes illegal -

Example

public class extends Animal, Mammal{}

Eine Klasse kann jedoch eine oder mehrere Schnittstellen implementieren, wodurch Java die Unmöglichkeit der Mehrfachvererbung beseitigt hat.

Im vorherigen Kapitel haben wir über Ober- und Unterklassen gesprochen. Wenn eine Klasse eine Methode von ihrer Oberklasse erbt, besteht die Möglichkeit, die Methode zu überschreiben, sofern sie nicht als endgültig markiert ist.

Das Überschreiben hat den Vorteil, dass ein Verhalten definiert werden kann, das für den Unterklassentyp spezifisch ist. Dies bedeutet, dass eine Unterklasse eine übergeordnete Klassenmethode basierend auf ihren Anforderungen implementieren kann.

Objektorientiert bedeutet Überschreiben, die Funktionalität einer vorhandenen Methode zu überschreiben.

Beispiel

Schauen wir uns ein Beispiel an.

class Animal {
   public void move() {
      System.out.println("Animals can move");
   }
}

class Dog extends Animal {
   public void move() {
      System.out.println("Dogs can walk and run");
   }
}

public class TestDog {

   public static void main(String args[]) {
      Animal a = new Animal();   // Animal reference and object
      Animal b = new Dog();   // Animal reference but Dog object

      a.move();   // runs the method in Animal class
      b.move();   // runs the method in Dog class
   }
}

Dies führt zu folgendem Ergebnis:

Ausgabe

Animals can move
Dogs can walk and run

Im obigen Beispiel können Sie das sehen, obwohl bist eine Tierart, die die Verschiebungsmethode in der Hundeklasse ausführt. Der Grund dafür ist: In der Kompilierungszeit wird der Referenztyp überprüft. Zur Laufzeit ermittelt JVM jedoch den Objekttyp und führt die Methode aus, die zu diesem bestimmten Objekt gehört.

Daher wird das Programm im obigen Beispiel ordnungsgemäß kompiliert, da die Animal-Klasse die Methode move hat. Zur Laufzeit wird dann die für dieses Objekt spezifische Methode ausgeführt.

Betrachten Sie das folgende Beispiel -

Beispiel

class Animal {
   public void move() {
      System.out.println("Animals can move");
   }
}

class Dog extends Animal {
   public void move() {
      System.out.println("Dogs can walk and run");
   }
   public void bark() {
      System.out.println("Dogs can bark");
   }
}

public class TestDog {

   public static void main(String args[]) {
      Animal a = new Animal();   // Animal reference and object
      Animal b = new Dog();   // Animal reference but Dog object

      a.move();   // runs the method in Animal class
      b.move();   // runs the method in Dog class
      b.bark();
   }
}

Dies führt zu folgendem Ergebnis:

Ausgabe

TestDog.java:26: error: cannot find symbol
      b.bark();
       ^
  symbol:   method bark()
  location: variable b of type Animal
1 error

Dieses Programm gibt einen Kompilierungszeitfehler aus, da der Referenztyp Animal von b keine Methode mit dem Namen bark hat.

Regeln zum Überschreiben von Methoden

• Die Argumentliste sollte genau der der überschriebenen Methode entsprechen.

• Der Rückgabetyp sollte derselbe oder ein Untertyp des Rückgabetyps sein, der in der ursprünglich überschriebenen Methode in der Oberklasse deklariert wurde.

• Die Zugriffsebene kann nicht restriktiver sein als die Zugriffsebene der überschriebenen Methode. Beispiel: Wenn die Superklassenmethode als öffentlich deklariert ist, kann die überschreibende Methode in der Unterklasse weder privat noch geschützt sein.

• Instanzmethoden können nur überschrieben werden, wenn sie von der Unterklasse geerbt werden.

• Eine als final deklarierte Methode kann nicht überschrieben werden.

• Eine als statisch deklarierte Methode kann nicht überschrieben, sondern erneut deklariert werden.

• Wenn eine Methode nicht vererbt werden kann, kann sie nicht überschrieben werden.

• Eine Unterklasse innerhalb desselben Pakets wie die Oberklasse der Instanz kann jede Oberklassenmethode überschreiben, die nicht als privat oder endgültig deklariert ist.

• Eine Unterklasse in einem anderen Paket kann nur die nicht endgültigen Methoden überschreiben, die als öffentlich oder geschützt deklariert wurden.

• Eine überschreibende Methode kann alle nicht aktivierten Ausnahmen auslösen, unabhängig davon, ob die überschriebene Methode Ausnahmen auslöst oder nicht. Die überschreibende Methode sollte jedoch keine geprüften Ausnahmen auslösen, die neu oder umfassender sind als die von der überschriebenen Methode deklarierten. Die überschreibende Methode kann engere oder weniger Ausnahmen auslösen als die überschriebene Methode.

• Konstruktoren können nicht überschrieben werden.

Verwenden des Super-Schlüsselworts

Beim Aufrufen einer Superklassenversion einer überschriebenen Methode wird die super Schlüsselwort wird verwendet.

Beispiel

class Animal {
   public void move() {
      System.out.println("Animals can move");
   }
}

class Dog extends Animal {
   public void move() {
      super.move();   // invokes the super class method
      System.out.println("Dogs can walk and run");
   }
}

public class TestDog {

   public static void main(String args[]) {
      Animal b = new Dog();   // Animal reference but Dog object
      b.move();   // runs the method in Dog class
   }
}

Dies führt zu folgendem Ergebnis:

Ausgabe

Animals can move
Dogs can walk and run

Polymorphismus ist die Fähigkeit eines Objekts, viele Formen anzunehmen. Die häufigste Verwendung von Polymorphismus in OOP tritt auf, wenn eine übergeordnete Klassenreferenz verwendet wird, um auf ein untergeordnetes Klassenobjekt zu verweisen.

Jedes Java-Objekt, das mehr als einen IS-A-Test bestehen kann, wird als polymorph betrachtet. In Java sind alle Java-Objekte polymorph, da jedes Objekt den IS-A-Test für seinen eigenen Typ und für die Klasse Object besteht.

Es ist wichtig zu wissen, dass der einzige mögliche Zugriff auf ein Objekt eine Referenzvariable ist. Eine Referenzvariable kann nur von einem Typ sein. Einmal deklariert, kann der Typ einer Referenzvariablen nicht mehr geändert werden.

Die Referenzvariable kann anderen Objekten zugewiesen werden, sofern sie nicht als endgültig deklariert ist. Der Typ der Referenzvariablen bestimmt die Methoden, die für das Objekt aufgerufen werden können.

Eine Referenzvariable kann auf jedes Objekt ihres deklarierten Typs oder auf jeden Subtyp ihres deklarierten Typs verweisen. Eine Referenzvariable kann als Klassen- oder Schnittstellentyp deklariert werden.

Beispiel

Schauen wir uns ein Beispiel an.

public interface Vegetarian{}
public class Animal{}
public class Deer extends Animal implements Vegetarian{}

Nun wird die Deer-Klasse als polymorph angesehen, da diese mehrfach vererbt wird. Das Folgende gilt für die obigen Beispiele -

• Ein Hirsch ist ein Tier
• Ein Hirsch ist ein Vegetarier
• Ein Hirsch ist ein Hirsch
• Ein Hirsch ist ein Objekt

Wenn wir die Fakten der Referenzvariablen auf eine Deer-Objektreferenz anwenden, sind die folgenden Erklärungen zulässig:

Beispiel

Deer d = new Deer();
Animal a = d;
Vegetarian v = d;
Object o = d;

Alle Referenzvariablen d, a, v, o beziehen sich auf dasselbe Deer-Objekt im Heap.

Virtuelle Methoden

In diesem Abschnitt werde ich Ihnen zeigen, wie Sie durch das Verhalten überschriebener Methoden in Java den Polymorphismus beim Entwerfen Ihrer Klassen nutzen können.

Wir haben bereits das Überschreiben von Methoden erörtert, bei dem eine untergeordnete Klasse eine Methode in ihrem übergeordneten Element überschreiben kann. Eine überschriebene Methode ist im Wesentlichen in der übergeordneten Klasse ausgeblendet und wird nur aufgerufen, wenn die untergeordnete Klasse das Schlüsselwort super in der überschreibenden Methode verwendet.

Beispiel

/* File name : Employee.java */
public class Employee {
   private String name;
   private String address;
   private int number;

   public Employee(String name, String address, int number) {
      System.out.println("Constructing an Employee");
      this.name = name;
      this.address = address;
      this.number = number;
   }

   public void mailCheck() {
      System.out.println("Mailing a check to " + this.name + " " + this.address);
   }

   public String toString() {
      return name + " " + address + " " + number;
   }

   public String getName() {
      return name;
   }

   public String getAddress() {
      return address;
   }

   public void setAddress(String newAddress) {
      address = newAddress;
   }

   public int getNumber() {
      return number;
   }
}

Nehmen wir nun an, wir erweitern die Mitarbeiterklasse wie folgt:

/* File name : Salary.java */
public class Salary extends Employee {
   private double salary; // Annual salary
   
   public Salary(String name, String address, int number, double salary) {
      super(name, address, number);
      setSalary(salary);
   }
   
   public void mailCheck() {
      System.out.println("Within mailCheck of Salary class ");
      System.out.println("Mailing check to " + getName()
      + " with salary " + salary);
   }
   
   public double getSalary() {
      return salary;
   }
   
   public void setSalary(double newSalary) {
      if(newSalary >= 0.0) {
         salary = newSalary;
      }
   }
   
   public double computePay() {
      System.out.println("Computing salary pay for " + getName());
      return salary/52;
   }
}

Nun studieren Sie das folgende Programm sorgfältig und versuchen, seine Ausgabe zu bestimmen -

/* File name : VirtualDemo.java */
public class VirtualDemo {

   public static void main(String [] args) {
      Salary s = new Salary("Mohd Mohtashim", "Ambehta, UP", 3, 3600.00);
      Employee e = new Salary("John Adams", "Boston, MA", 2, 2400.00);
      System.out.println("Call mailCheck using Salary reference --");   
      s.mailCheck();
      System.out.println("\n Call mailCheck using Employee reference--");
      e.mailCheck();
   }
}

Dies führt zu folgendem Ergebnis:

Ausgabe

Constructing an Employee
Constructing an Employee

Call mailCheck using Salary reference --
Within mailCheck of Salary class
Mailing check to Mohd Mohtashim with salary 3600.0

Call mailCheck using Employee reference--
Within mailCheck of Salary class
Mailing check to John Adams with salary 2400.0

Hier instanziieren wir zwei Gehaltsobjekte. Eine mit einer Gehaltsreferenzsund die andere unter Verwendung einer Mitarbeiterreferenz e.

Beim Aufrufen von s.mailCheck () sieht der Compiler zur Kompilierungszeit mailCheck () in der Salary-Klasse, und die JVM ruft zur Laufzeit mailCheck () in der Salary-Klasse auf.

mailCheck () ein e ist ganz anders weil eist eine Mitarbeiterreferenz. Wenn der Compiler e.mailCheck () sieht , sieht der Compiler die mailCheck () -Methode in der Employee-Klasse.

Hier verwendete der Compiler zur Kompilierungszeit mailCheck () in Employee, um diese Anweisung zu validieren. Zur Laufzeit ruft die JVM jedoch mailCheck () in der Gehaltsklasse auf.

Dieses Verhalten wird als Aufruf virtueller Methoden bezeichnet, und diese Methoden werden als virtuelle Methoden bezeichnet. Eine überschriebene Methode wird zur Laufzeit aufgerufen, unabhängig davon, welcher Datentyp die Referenz ist, die zur Kompilierungszeit im Quellcode verwendet wurde.

Gemäß Wörterbuch, abstractionist die Qualität des Umgangs mit Ideen und nicht mit Ereignissen. Wenn Sie beispielsweise den Fall von E-Mails betrachten, komplexe Details, z. B. was passiert, sobald Sie eine E-Mail senden, ist das von Ihrem E-Mail-Server verwendete Protokoll für den Benutzer nicht sichtbar. Um eine E-Mail zu senden, müssen Sie nur den Inhalt eingeben, die Adresse des Empfängers angeben und auf Senden klicken.

Ebenso ist bei der objektorientierten Programmierung die Abstraktion ein Prozess, bei dem die Implementierungsdetails vor dem Benutzer verborgen werden. Dem Benutzer wird nur die Funktionalität bereitgestellt. Mit anderen Worten, der Benutzer hat die Informationen darüber, was das Objekt tut, anstatt wie es es tut.

In Java wird die Abstraktion mithilfe von abstrakten Klassen und Schnittstellen erreicht.

Abstrakte Klasse

Eine Klasse, die die enthält abstract Das Schlüsselwort in seiner Deklaration wird als abstrakte Klasse bezeichnet.

• Abstrakte Klassen können abstrakte Methoden enthalten oder nicht , dh Methoden ohne Körper (public void get ();)

• Wenn eine Klasse jedoch mindestens eine abstrakte Methode hat, dann die Klasse must als abstrakt deklariert werden.

• Wenn eine Klasse als abstrakt deklariert ist, kann sie nicht instanziiert werden.

• Um eine abstrakte Klasse zu verwenden, müssen Sie sie von einer anderen Klasse erben und Implementierungen für die darin enthaltenen abstrakten Methoden bereitstellen.

• Wenn Sie eine abstrakte Klasse erben, müssen Sie Implementierungen für alle darin enthaltenen abstrakten Methoden bereitstellen.

Beispiel

Dieser Abschnitt enthält ein Beispiel für die abstrakte Klasse. Um eine abstrakte Klasse zu erstellen, verwenden Sie einfach dieabstract Schlüsselwort vor dem Klassenschlüsselwort in der Klassendeklaration.

/* File name : Employee.java */
public abstract class Employee {
   private String name;
   private String address;
   private int number;

   public Employee(String name, String address, int number) {
      System.out.println("Constructing an Employee");
      this.name = name;
      this.address = address;
      this.number = number;
   }
   
   public double computePay() {
     System.out.println("Inside Employee computePay");
     return 0.0;
   }
   
   public void mailCheck() {
      System.out.println("Mailing a check to " + this.name + " " + this.address);
   }

   public String toString() {
      return name + " " + address + " " + number;
   }

   public String getName() {
      return name;
   }
 
   public String getAddress() {
      return address;
   }
   
   public void setAddress(String newAddress) {
      address = newAddress;
   }
 
   public int getNumber() {
      return number;
   }
}

Sie können feststellen, dass die Employee-Klasse mit Ausnahme abstrakter Methoden mit der normalen Klasse in Java identisch ist. Die Klasse ist jetzt abstrakt, hat aber noch drei Felder, sieben Methoden und einen Konstruktor.

Jetzt können Sie versuchen, die Employee-Klasse folgendermaßen zu instanziieren:

/* File name : AbstractDemo.java */
public class AbstractDemo {

   public static void main(String [] args) {
      /* Following is not allowed and would raise error */
      Employee e = new Employee("George W.", "Houston, TX", 43);
      System.out.println("\n Call mailCheck using Employee reference--");
      e.mailCheck();
   }
}

Wenn Sie die obige Klasse kompilieren, wird der folgende Fehler angezeigt:

Employee.java:46: Employee is abstract; cannot be instantiated
      Employee e = new Employee("George W.", "Houston, TX", 43);
                   ^
1 error

Vererbung der abstrakten Klasse

Wir können die Eigenschaften der Employee-Klasse genau wie die konkrete Klasse folgendermaßen erben:

Beispiel

/* File name : Salary.java */
public class Salary extends Employee {
   private double salary;   // Annual salary
   
   public Salary(String name, String address, int number, double salary) {
      super(name, address, number);
      setSalary(salary);
   }
   
   public void mailCheck() {
      System.out.println("Within mailCheck of Salary class ");
      System.out.println("Mailing check to " + getName() + " with salary " + salary);
   }
 
   public double getSalary() {
      return salary;
   }
   
   public void setSalary(double newSalary) {
      if(newSalary >= 0.0) {
         salary = newSalary;
      }
   }
   
   public double computePay() {
      System.out.println("Computing salary pay for " + getName());
      return salary/52;
   }
}

Hier können Sie die Employee-Klasse nicht instanziieren, aber Sie können die Gehaltsklasse instanziieren. Mit dieser Instanz können Sie auf alle drei Felder und sieben Methoden der Employee-Klasse zugreifen, wie unten gezeigt.

/* File name : AbstractDemo.java */
public class AbstractDemo {

   public static void main(String [] args) {
      Salary s = new Salary("Mohd Mohtashim", "Ambehta, UP", 3, 3600.00);
      Employee e = new Salary("John Adams", "Boston, MA", 2, 2400.00);
      System.out.println("Call mailCheck using Salary reference --");
      s.mailCheck();
      System.out.println("\n Call mailCheck using Employee reference--");
      e.mailCheck();
   }
}

Dies ergibt das folgende Ergebnis:

Ausgabe

Constructing an Employee
Constructing an Employee
Call mailCheck using Salary reference --
Within mailCheck of Salary class 
Mailing check to Mohd Mohtashim with salary 3600.0

 Call mailCheck using Employee reference--
Within mailCheck of Salary class 
Mailing check to John Adams with salary 2400.0

Abstrakte Methoden

Wenn eine Klasse eine bestimmte Methode enthalten soll, die tatsächliche Implementierung dieser Methode jedoch von untergeordneten Klassen bestimmt werden soll, können Sie die Methode in der übergeordneten Klasse als Zusammenfassung deklarieren.

• abstract Das Schlüsselwort wird verwendet, um die Methode als abstrakt zu deklarieren.

• Sie müssen die platzieren abstract Schlüsselwort vor dem Methodennamen in der Methodendeklaration.

• Eine abstrakte Methode enthält eine Methodensignatur, jedoch keinen Methodenkörper.

• Anstelle von geschweiften Klammern hat eine abstrakte Methode am Ende einen Semoi-Doppelpunkt (;).

Das Folgende ist ein Beispiel für die abstrakte Methode.

Beispiel

public abstract class Employee {
   private String name;
   private String address;
   private int number;
   
   public abstract double computePay();
   // Remainder of class definition
}

Das Deklarieren einer Methode als abstrakt hat zwei Konsequenzen:

• Die Klasse, die es enthält, muss als abstrakt deklariert werden.

• Jede Klasse, die die aktuelle Klasse erbt, muss entweder die abstrakte Methode überschreiben oder sich selbst als abstrakt deklarieren.

Note- Schließlich muss eine untergeordnete Klasse die abstrakte Methode implementieren. Andernfalls hätten Sie eine Hierarchie abstrakter Klassen, die nicht instanziiert werden können.

Angenommen, die Gehaltsklasse erbt die Employee-Klasse, dann sollte sie die implementieren computePay() Methode wie unten gezeigt -

/* File name : Salary.java */
public class Salary extends Employee {
   private double salary;   // Annual salary
  
   public double computePay() {
      System.out.println("Computing salary pay for " + getName());
      return salary/52;
   }
   // Remainder of class definition
}

Encapsulationist eines der vier grundlegenden OOP-Konzepte. Die anderen drei sind Vererbung, Polymorphismus und Abstraktion.

Die Kapselung in Java ist ein Mechanismus, bei dem die Daten (Variablen) und der Code, die auf die Daten (Methoden) einwirken, als eine Einheit zusammengefasst werden. Bei der Kapselung werden die Variablen einer Klasse vor anderen Klassen verborgen und können nur über die Methoden ihrer aktuellen Klasse aufgerufen werden. Daher ist es auch bekannt alsdata hiding.

Um die Kapselung in Java zu erreichen -

• Deklarieren Sie die Variablen einer Klasse als privat.

• Stellen Sie öffentliche Setter- und Getter-Methoden bereit, um die Variablenwerte zu ändern und anzuzeigen.

Beispiel

Das folgende Beispiel zeigt, wie die Kapselung in Java erreicht wird.

/* File name : EncapTest.java */
public class EncapTest {
   private String name;
   private String idNum;
   private int age;

   public int getAge() {
      return age;
   }

   public String getName() {
      return name;
   }

   public String getIdNum() {
      return idNum;
   }

   public void setAge( int newAge) {
      age = newAge;
   }

   public void setName(String newName) {
      name = newName;
   }

   public void setIdNum( String newId) {
      idNum = newId;
   }
}

Die öffentlichen Methoden setXXX () und getXXX () sind die Zugriffspunkte der Instanzvariablen der EncapTest-Klasse. Normalerweise werden diese Methoden als Getter und Setter bezeichnet. Daher sollte jede Klasse, die auf die Variablen zugreifen möchte, über diese Getter und Setter auf sie zugreifen.

Auf die Variablen der EncapTest-Klasse kann mit dem folgenden Programm zugegriffen werden:

/* File name : RunEncap.java */
public class RunEncap {

   public static void main(String args[]) {
      EncapTest encap = new EncapTest();
      encap.setName("James");
      encap.setAge(20);
      encap.setIdNum("12343ms");

      System.out.print("Name : " + encap.getName() + " Age : " + encap.getAge());
   }
}

Dies führt zu folgendem Ergebnis:

Ausgabe

Name : James Age : 20

Vorteile der Kapselung

• Die Felder einer Klasse können schreibgeschützt oder schreibgeschützt sein.

• Eine Klasse kann die vollständige Kontrolle darüber haben, was in ihren Feldern gespeichert ist.

Eine Schnittstelle ist ein Referenztyp in Java. Es ist ähnlich wie in der Klasse. Es ist eine Sammlung abstrakter Methoden. Eine Klasse implementiert eine Schnittstelle und erbt dadurch die abstrakten Methoden der Schnittstelle.

Neben abstrakten Methoden kann eine Schnittstelle auch Konstanten, Standardmethoden, statische Methoden und verschachtelte Typen enthalten. Methodenkörper existieren nur für Standardmethoden und statische Methoden.

Das Schreiben einer Schnittstelle ähnelt dem Schreiben einer Klasse. Eine Klasse beschreibt jedoch die Attribute und Verhaltensweisen eines Objekts. Und eine Schnittstelle enthält Verhaltensweisen, die eine Klasse implementiert.

Sofern die Klasse, die die Schnittstelle implementiert, nicht abstrakt ist, müssen alle Methoden der Schnittstelle in der Klasse definiert werden.

Eine Schnittstelle ähnelt einer Klasse auf folgende Weise:

• Eine Schnittstelle kann beliebig viele Methoden enthalten.

• Eine Schnittstelle wird in eine Datei mit a geschrieben .java Erweiterung, wobei der Name der Schnittstelle mit dem Namen der Datei übereinstimmt.

• Der Bytecode einer Schnittstelle wird in a angezeigt .class Datei.

• Schnittstellen werden in Paketen angezeigt, und die entsprechende Bytecodedatei muss sich in einer Verzeichnisstruktur befinden, die dem Paketnamen entspricht.

Eine Schnittstelle unterscheidet sich jedoch in mehreren Punkten von einer Klasse, einschließlich:

• Sie können eine Schnittstelle nicht instanziieren.

• Eine Schnittstelle enthält keine Konstruktoren.

• Alle Methoden in einer Schnittstelle sind abstrakt.

• Eine Schnittstelle darf keine Instanzfelder enthalten. Die einzigen Felder, die in einer Schnittstelle angezeigt werden können, müssen sowohl als statisch als auch als endgültig deklariert werden.

• Eine Schnittstelle wird nicht um eine Klasse erweitert. es wird von einer Klasse implementiert.

• Eine Schnittstelle kann mehrere Schnittstellen erweitern.

Schnittstellen deklarieren

Das interfaceDas Schlüsselwort wird verwendet, um eine Schnittstelle zu deklarieren. Hier ist ein einfaches Beispiel, um eine Schnittstelle zu deklarieren:

Beispiel

Es folgt ein Beispiel für eine Schnittstelle -

/* File name : NameOfInterface.java */
import java.lang.*;
// Any number of import statements

public interface NameOfInterface {
   // Any number of final, static fields
   // Any number of abstract method declarations\
}

Schnittstellen haben die folgenden Eigenschaften:

• Eine Schnittstelle ist implizit abstrakt. Sie müssen das nicht verwendenabstract Schlüsselwort beim Deklarieren einer Schnittstelle.

• Jede Methode in einer Schnittstelle ist implizit abstrakt, sodass das abstrakte Schlüsselwort nicht benötigt wird.

• Methoden in einer Schnittstelle sind implizit öffentlich.

Beispiel

/* File name : Animal.java */
interface Animal {
   public void eat();
   public void travel();
}

Schnittstellen implementieren

Wenn eine Klasse eine Schnittstelle implementiert, können Sie sich vorstellen, dass die Klasse einen Vertrag unterzeichnet und sich damit einverstanden erklärt, das spezifische Verhalten der Schnittstelle auszuführen. Wenn eine Klasse nicht alle Verhaltensweisen der Schnittstelle ausführt, muss sich die Klasse als abstrakt deklarieren.

Eine Klasse verwendet die implementsSchlüsselwort zum Implementieren einer Schnittstelle. Das Schlüsselwort implements wird in der Klassendeklaration nach dem erweiterten Teil der Deklaration angezeigt.

Beispiel

/* File name : MammalInt.java */
public class MammalInt implements Animal {

   public void eat() {
      System.out.println("Mammal eats");
   }

   public void travel() {
      System.out.println("Mammal travels");
   } 

   public int noOfLegs() {
      return 0;
   }

   public static void main(String args[]) {
      MammalInt m = new MammalInt();
      m.eat();
      m.travel();
   }
}

Dies führt zu folgendem Ergebnis:

Ausgabe

Mammal eats
Mammal travels

Beim Überschreiben von in Schnittstellen definierten Methoden müssen verschiedene Regeln beachtet werden:

• Überprüfte Ausnahmen sollten nicht für andere Implementierungsmethoden als die von der Schnittstellenmethode deklarierten oder für Unterklassen der von der Schnittstellenmethode deklarierten deklariert werden.

• Die Signatur der Schnittstellenmethode und derselbe Rückgabetyp oder Subtyp sollten beim Überschreiben der Methoden beibehalten werden.

• Eine Implementierungsklasse selbst kann abstrakt sein. In diesem Fall müssen Schnittstellenmethoden nicht implementiert werden.

Bei Implementierungsschnittstellen gibt es mehrere Regeln -

• Eine Klasse kann mehrere Schnittstellen gleichzeitig implementieren.

• Eine Klasse kann nur eine Klasse erweitern, aber viele Schnittstellen implementieren.

• Eine Schnittstelle kann eine andere Schnittstelle erweitern, ähnlich wie eine Klasse eine andere Klasse erweitern kann.

Schnittstellen erweitern

Eine Schnittstelle kann eine andere Schnittstelle auf dieselbe Weise erweitern, wie eine Klasse eine andere Klasse erweitern kann. Dasextends Das Schlüsselwort wird verwendet, um eine Schnittstelle zu erweitern, und die untergeordnete Schnittstelle erbt die Methoden der übergeordneten Schnittstelle.

Die folgende Sportschnittstelle wird um Hockey- und Fußballschnittstellen erweitert.

Beispiel

// Filename: Sports.java
public interface Sports {
   public void setHomeTeam(String name);
   public void setVisitingTeam(String name);
}

// Filename: Football.java
public interface Football extends Sports {
   public void homeTeamScored(int points);
   public void visitingTeamScored(int points);
   public void endOfQuarter(int quarter);
}

// Filename: Hockey.java
public interface Hockey extends Sports {
   public void homeGoalScored();
   public void visitingGoalScored();
   public void endOfPeriod(int period);
   public void overtimePeriod(int ot);
}

Die Hockey-Oberfläche verfügt über vier Methoden, erbt jedoch zwei von Sports. Daher muss eine Klasse, die Hockey implementiert, alle sechs Methoden implementieren. Ebenso muss eine Klasse, die Fußball implementiert, die drei Methoden aus Fußball und die beiden Methoden aus Sport definieren.

Mehrere Schnittstellen erweitern

Eine Java-Klasse kann nur eine übergeordnete Klasse erweitern. Mehrfachvererbung ist nicht zulässig. Schnittstellen sind jedoch keine Klassen, und eine Schnittstelle kann mehr als eine übergeordnete Schnittstelle erweitern.

Das Schlüsselwort extens wird wird einmal verwendet, und die übergeordneten Schnittstellen werden in einer durch Kommas getrennten Liste deklariert.

Wenn die Hockey-Oberfläche beispielsweise sowohl Sport als auch Event erweitert, wird sie als - deklariert.

Beispiel

public interface Hockey extends Sports, Event

Schnittstellen markieren

Die häufigste Verwendung zum Erweitern von Schnittstellen tritt auf, wenn die übergeordnete Schnittstelle keine Methoden enthält. Beispielsweise hat die MouseListener-Schnittstelle im Paket java.awt.event java.util.EventListener erweitert, das definiert ist als -

Beispiel

package java.util;
public interface EventListener
{}

Eine Schnittstelle ohne Methoden wird als bezeichnet taggingSchnittstelle. Es gibt zwei grundlegende Entwurfszwecke für das Markieren von Schnittstellen:

Creates a common parent- Wie bei der EventListener-Schnittstelle, die um Dutzende anderer Schnittstellen in der Java-API erweitert wird, können Sie mithilfe einer Tagging-Schnittstelle ein gemeinsames übergeordnetes Element aus einer Gruppe von Schnittstellen erstellen. Wenn eine Schnittstelle beispielsweise EventListener erweitert, weiß die JVM, dass diese bestimmte Schnittstelle in einem Ereignisdelegierungsszenario verwendet wird.

Adds a data type to a class- Aus dieser Situation stammt der Begriff Tagging. Eine Klasse, die eine Tagging-Schnittstelle implementiert, muss keine Methoden definieren (da die Schnittstelle keine hat), aber die Klasse wird durch Polymorphismus zu einem Schnittstellentyp.

Pakete werden in Java verwendet, um Namenskonflikte zu vermeiden, den Zugriff zu steuern, das Suchen / Auffinden und Verwenden von Klassen, Schnittstellen, Aufzählungen und Anmerkungen zu vereinfachen usw.

EIN Package kann als Gruppierung verwandter Typen (Klassen, Schnittstellen, Aufzählungen und Anmerkungen) definiert werden, die Zugriffsschutz und Namespace-Verwaltung bieten.

Einige der in Java vorhandenen Pakete sind -

• java.lang - bündelt die Grundklassen

• java.io - Klassen für Eingabe- und Ausgabefunktionen sind in diesem Paket gebündelt

Programmierer können ihre eigenen Pakete definieren, um Gruppen von Klassen / Schnittstellen usw. zu bündeln. Es wird empfohlen, verwandte Klassen, die von Ihnen implementiert wurden, zu gruppieren, damit ein Programmierer leicht feststellen kann, ob Klassen, Schnittstellen, Aufzählungen und Anmerkungen zusammenhängen.

Da das Paket einen neuen Namespace erstellt, treten keine Namenskonflikte mit Namen in anderen Paketen auf. Mithilfe von Paketen ist es einfacher, die Zugriffssteuerung bereitzustellen, und es ist auch einfacher, die zugehörigen Klassen zu finden.

Ein Paket erstellen

Beim Erstellen eines Pakets sollten Sie einen Namen für das Paket auswählen und a einschließen package Anweisung zusammen mit diesem Namen oben in jeder Quelldatei, die die Klassen, Schnittstellen, Aufzählungen und Anmerkungstypen enthält, die Sie in das Paket aufnehmen möchten.

Die Paketanweisung sollte die erste Zeile in der Quelldatei sein. Jede Quelldatei kann nur eine Paketanweisung enthalten und gilt für alle Typen in der Datei.

Wenn keine Paketanweisung verwendet wird, werden die Klassen-, Schnittstellen-, Aufzählungs- und Anmerkungstypen in das aktuelle Standardpaket eingefügt.

Um die Java-Programme mit Paketanweisungen zu kompilieren, müssen Sie die Option -d wie unten gezeigt verwenden.

javac -d Destination_folder file_name.java

Anschließend wird am angegebenen Ziel ein Ordner mit dem angegebenen Paketnamen erstellt, und die kompilierten Klassendateien werden in diesem Ordner abgelegt.

Beispiel

Schauen wir uns ein Beispiel an, das ein Paket namens erstellt animals. Es wird empfohlen, Paketnamen mit Kleinbuchstaben zu verwenden, um Konflikte mit den Namen von Klassen und Schnittstellen zu vermeiden.

Das folgende Paketbeispiel enthält eine Schnittstelle mit dem Namen Tiere -

/* File name : Animal.java */
package animals;

interface Animal {
   public void eat();
   public void travel();
}

Nun wollen wir uns die obige Schnittstelle im selben Paket implementieren Tiere -

package animals;
/* File name : MammalInt.java */

public class MammalInt implements Animal {

   public void eat() {
      System.out.println("Mammal eats");
   }

   public void travel() {
      System.out.println("Mammal travels");
   } 

   public int noOfLegs() {
      return 0;
   }

   public static void main(String args[]) {
      MammalInt m = new MammalInt();
      m.eat();
      m.travel();
   }
}

Kompilieren Sie nun die Java-Dateien wie unten gezeigt -

$ javac -d . Animal.java $ javac -d . MammalInt.java

Nun ein Paket / Ordner mit dem Namen animals wird im aktuellen Verzeichnis erstellt und diese Klassendateien werden wie unten gezeigt darin abgelegt.

Sie können die Klassendatei innerhalb des Pakets ausführen und das Ergebnis wie unten gezeigt erhalten.

Mammal eats
Mammal travels

Das Import-Schlüsselwort

Wenn eine Klasse eine andere Klasse im selben Paket verwenden möchte, muss der Paketname nicht verwendet werden. Klassen im selben Paket finden sich ohne spezielle Syntax.

Beispiel

Hier wird eine Klasse namens Boss zum Abrechnungspaket hinzugefügt, das bereits Employee enthält. Der Chef kann dann auf die Employee-Klasse verweisen, ohne das Abrechnungspräfix zu verwenden, wie die folgende Boss-Klasse zeigt.

package payroll;
public class Boss {
   public void payEmployee(Employee e) {
      e.mailCheck();
   }
}

Was passiert, wenn die Mitarbeiterklasse nicht im Abrechnungspaket enthalten ist? Die Boss-Klasse muss dann eine der folgenden Techniken verwenden, um auf eine Klasse in einem anderen Paket zu verweisen.

• Der vollständig qualifizierte Name der Klasse kann verwendet werden. Zum Beispiel -

payroll.Employee

• Das Paket kann mit dem Schlüsselwort import und dem Platzhalter (*) importiert werden. Zum Beispiel -

import payroll.*;

• Die Klasse selbst kann mit dem Schlüsselwort import importiert werden. Zum Beispiel -

import payroll.Employee;

Note- Eine Klassendatei kann beliebig viele Importanweisungen enthalten. Die Importanweisungen müssen nach der Paketanweisung und vor der Klassendeklaration erscheinen.

Die Verzeichnisstruktur von Paketen

Zwei Hauptergebnisse treten auf, wenn eine Klasse in ein Paket eingefügt wird -

• Der Name des Pakets wird Teil des Namens der Klasse, wie wir gerade im vorherigen Abschnitt besprochen haben.

• Der Name des Pakets muss mit der Verzeichnisstruktur übereinstimmen, in der sich der entsprechende Bytecode befindet.

Hier ist eine einfache Möglichkeit, Ihre Dateien in Java zu verwalten:

Fügen Sie den Quellcode für eine Klasse, eine Schnittstelle, eine Aufzählung oder einen Anmerkungstyp in eine Textdatei ein, deren Name der einfache Name des Typs ist und dessen Erweiterung lautet .java.

Zum Beispiel -

// File Name :  Car.java
package vehicle;

public class Car {
   // Class implementation.   
}

Legen Sie nun die Quelldatei in einem Verzeichnis ab, dessen Name den Namen des Pakets widerspiegelt, zu dem die Klasse gehört.

....\vehicle\Car.java

Nun wären der qualifizierte Klassenname und der Pfadname wie folgt:

• Klassenname → Fahrzeug
• Pfadname → Fahrzeug \ Car.java (in Fenstern)

Im Allgemeinen verwendet ein Unternehmen seinen umgekehrten Internetdomänennamen für seine Paketnamen.

Example- Der Internet-Domainname eines Unternehmens lautet apple.com. Alle Paketnamen beginnen dann mit com.apple. Jede Komponente des Paketnamens entspricht einem Unterverzeichnis.

Example - Das Unternehmen hatte ein com.apple.computers-Paket, das eine Dell.java-Quelldatei enthielt. Es würde in einer Reihe von Unterverzeichnissen wie diesem enthalten sein. -

....\com\apple\computers\Dell.java

Zum Zeitpunkt der Kompilierung erstellt der Compiler für jede darin definierte Klasse, Schnittstelle und Aufzählung eine andere Ausgabedatei. Der Basisname der Ausgabedatei ist der Name des Typs und seine Erweiterung ist.class.

Zum Beispiel -

// File Name: Dell.java
package com.apple.computers;

public class Dell {
}

class Ups {
}

Kompilieren Sie diese Datei nun wie folgt mit der Option -d -

$javac -d . Dell.java

Die Dateien werden wie folgt kompiliert:

.\com\apple\computers\Dell.class
.\com\apple\computers\Ups.class

Sie können alle in \ com \ apple \ computer \ definierten Klassen oder Schnittstellen wie folgt importieren :

import com.apple.computers.*;

Wie die .java-Quelldateien sollten sich die kompilierten .class-Dateien in einer Reihe von Verzeichnissen befinden, die den Paketnamen widerspiegeln. Der Pfad zu den .class-Dateien muss jedoch nicht mit dem Pfad zu den .java-Quelldateien übereinstimmen. Sie können Ihre Quell- und Klassenverzeichnisse getrennt anordnen, als -

<path-one>\sources\com\apple\computers\Dell.java

<path-two>\classes\com\apple\computers\Dell.class

Auf diese Weise ist es möglich, anderen Programmierern Zugriff auf das Klassenverzeichnis zu gewähren, ohne Ihre Quellen preiszugeben. Sie müssen auch Quell- und Klassendateien auf diese Weise verwalten, damit der Compiler und die Java Virtual Machine (JVM) alle von Ihrem Programm verwendeten Typen finden können.

Der vollständige Pfad zum Klassenverzeichnis <Pfad-wo> \ classes wird als Klassenpfad bezeichnet und mit der Systemvariablen CLASSPATH festgelegt. Sowohl der Compiler als auch die JVM erstellen den Pfad zu Ihren .class-Dateien, indem Sie den Paketnamen zum Klassenpfad hinzufügen.

Angenommen, <Pfad-zwei> \ classes ist der Klassenpfad, und der Paketname lautet com.apple.computers. Dann suchen der Compiler und die JVM in <Pfad-wo> \ classes \ com \ apple \ computer nach .class-Dateien.

Ein Klassenpfad kann mehrere Pfade enthalten. Mehrere Pfade sollten durch ein Semikolon (Windows) oder einen Doppelpunkt (Unix) getrennt werden. Standardmäßig durchsuchen der Compiler und die JVM das aktuelle Verzeichnis und die JAR-Datei mit den Java-Plattformklassen, sodass sich diese Verzeichnisse automatisch im Klassenpfad befinden.

Legen Sie die CLASSPATH-Systemvariable fest

Verwenden Sie die folgenden Befehle in Windows und UNIX (Bourne-Shell), um die aktuelle CLASSPATH-Variable anzuzeigen:

• In Windows → C: \> setzen Sie CLASSPATH
• In UNIX →% echo $ CLASSPATH

Verwenden Sie -, um den aktuellen Inhalt der Variablen CLASSPATH zu löschen.

• In Windows → C: \> setzen Sie CLASSPATH =
• Unter UNIX →% nicht gesetzt CLASSPATH; CLASSPATH exportieren

So legen Sie die Variable CLASSPATH fest:

• Setzen Sie in Windows → CLASSPATH = C: \ users \ jack \ java \ classes
• Unter UNIX →% CLASSPATH = / home / jack / java / classes; CLASSPATH exportieren

Die vom Java-Dienstprogramm bereitgestellten Datenstrukturen sind sehr leistungsfähig und bieten eine Vielzahl von Funktionen. Diese Datenstrukturen bestehen aus folgenden Schnittstellen und Klassen:

• Enumeration
• BitSet
• Vector
• Stack
• Dictionary
• Hashtable
• Properties

Alle diese Klassen sind jetzt Legacy und Java-2 hat ein neues Framework namens Collections Framework eingeführt, das im nächsten Kapitel behandelt wird. - -

Die Aufzählung

Die Aufzählungsschnittstelle selbst ist keine Datenstruktur, aber im Kontext anderer Datenstrukturen sehr wichtig. Die Aufzählungsschnittstelle definiert ein Mittel zum Abrufen aufeinanderfolgender Elemente aus einer Datenstruktur.

Beispielsweise definiert Enumeration eine Methode namens nextElement, mit der das nächste Element in einer Datenstruktur abgerufen wird, die mehrere Elemente enthält.

Weitere Informationen zu dieser Schnittstelle finden Sie unter Die Aufzählung .

Das BitSet

Die BitSet-Klasse implementiert eine Gruppe von Bits oder Flags, die einzeln gesetzt und gelöscht werden können.

Diese Klasse ist sehr nützlich in Fällen, in denen Sie mit einer Reihe von Booleschen Werten Schritt halten müssen. Sie weisen jedem Wert einfach ein Bit zu und setzen oder löschen es entsprechend.

Weitere Informationen zu dieser Klasse finden Sie unter The BitSet .

Der Vektor

Die Vector-Klasse ähnelt einem herkömmlichen Java-Array, kann jedoch nach Bedarf erweitert werden, um neue Elemente aufzunehmen.

Wie bei einem Array kann auf Elemente eines Vektorobjekts über einen Index in den Vektor zugegriffen werden.

Das Schöne an der Verwendung der Vector-Klasse ist, dass Sie sich bei der Erstellung nicht darum kümmern müssen, sie auf eine bestimmte Größe festzulegen. es schrumpft und wächst bei Bedarf automatisch.

Weitere Informationen zu dieser Klasse finden Sie unter Der Vektor .

Der Stapel

Die Stack-Klasse implementiert einen LIFO-Stapel (Last-In-First-Out) von Elementen.

Sie können sich einen Stapel buchstäblich als vertikalen Stapel von Objekten vorstellen. Wenn Sie ein neues Element hinzufügen, wird es über den anderen gestapelt.

Wenn Sie ein Element vom Stapel ziehen, löst es sich von oben. Mit anderen Worten, das letzte Element, das Sie dem Stapel hinzugefügt haben, ist das erste, das wieder entfernt wird.

Weitere Informationen zu dieser Klasse finden Sie unter The Stack .

Das Wörterbuch

Die Dictionary-Klasse ist eine abstrakte Klasse, die eine Datenstruktur für die Zuordnung von Schlüsseln zu Werten definiert.

Dies ist nützlich, wenn Sie über einen bestimmten Schlüssel und nicht über einen Ganzzahlindex auf Daten zugreifen möchten.

Da die Dictionary-Klasse abstrakt ist, bietet sie nur das Framework für eine Datenstruktur mit Schlüsselzuordnung und nicht für eine bestimmte Implementierung.

Weitere Informationen zu dieser Klasse finden Sie im Wörterbuch .

Der Hashtable

Die Hashtable-Klasse bietet eine Möglichkeit zum Organisieren von Daten basierend auf einer benutzerdefinierten Schlüsselstruktur.

In einer Adresslisten-Hash-Tabelle können Sie beispielsweise Daten anhand eines Schlüssels wie der Postleitzahl und nicht anhand des Namens einer Person speichern und sortieren.

Die spezifische Bedeutung von Schlüsseln in Bezug auf Hash-Tabellen hängt vollständig von der Verwendung der Hash-Tabelle und den darin enthaltenen Daten ab.

Weitere Informationen zu dieser Klasse finden Sie unter The Hashtable .

Die Eigenschaften

Properties ist eine Unterklasse von Hashtable. Es wird verwendet, um Wertelisten zu verwalten, in denen der Schlüssel ein String und der Wert auch ein String ist.

Die Properties-Klasse wird von vielen anderen Java-Klassen verwendet. Dies ist beispielsweise der Objekttyp, der von System.getProperties () beim Abrufen von Umgebungswerten zurückgegeben wird.

Weitere Informationen zu dieser Klasse finden Sie unter Eigenschaften .

Vor Java 2 stellte Java Ad-hoc-Klassen wie z Dictionary, Vector, Stack, und Propertiesum Gruppen von Objekten zu speichern und zu bearbeiten. Obwohl diese Klassen sehr nützlich waren, fehlte ihnen ein zentrales, einheitliches Thema. Daher unterschied sich die Art und Weise, wie Sie Vector verwendet haben, von der Art und Weise, wie Sie Eigenschaften verwendet haben.

Das Sammlungs-Framework wurde entwickelt, um mehrere Ziele zu erreichen, wie z.

• Das Framework musste leistungsstark sein. Die Implementierungen für die grundlegenden Sammlungen (dynamische Arrays, verknüpfte Listen, Bäume und Hashtabellen) sollten hocheffizient sein.

• Das Framework musste es verschiedenen Arten von Sammlungen ermöglichen, auf ähnliche Weise und mit einem hohen Maß an Interoperabilität zu arbeiten.

• Das Framework musste eine Sammlung leicht erweitern und / oder anpassen können.

Zu diesem Zweck basiert das gesamte Sammlungsframework auf einer Reihe von Standardschnittstellen. Mehrere Standardimplementierungen wieLinkedList, HashSet, und TreeSetVon diesen Schnittstellen können Sie sie unverändert verwenden und bei Bedarf auch Ihre eigene Sammlung implementieren.

Ein Sammlungsframework ist eine einheitliche Architektur zum Darstellen und Bearbeiten von Sammlungen. Alle Sammlungsframeworks enthalten Folgendes:

• Interfaces- Dies sind abstrakte Datentypen, die Sammlungen darstellen. Mithilfe von Schnittstellen können Sammlungen unabhängig von den Details ihrer Darstellung bearbeitet werden. In objektorientierten Sprachen bilden Schnittstellen im Allgemeinen eine Hierarchie.

• Implementations, i.e., Classes- Dies sind die konkreten Implementierungen der Sammlungsschnittstellen. Im Wesentlichen handelt es sich um wiederverwendbare Datenstrukturen.

• Algorithms- Dies sind die Methoden, mit denen nützliche Berechnungen wie Suchen und Sortieren für Objekte durchgeführt werden, die Sammlungsschnittstellen implementieren. Die Algorithmen sollen polymorph sein: Das heißt, dieselbe Methode kann für viele verschiedene Implementierungen der entsprechenden Erfassungsschnittstelle verwendet werden.

Zusätzlich zu Sammlungen definiert das Framework mehrere Kartenschnittstellen und -klassen. Karten speichern Schlüssel / Wert-Paare. Karten sind zwar keine Sammlungen im richtigen Gebrauch des Begriffs, aber sie sind vollständig in Sammlungen integriert.

Die Sammlungsschnittstellen

Das Sammlungsframework definiert mehrere Schnittstellen. Dieser Abschnitt bietet einen Überblick über jede Schnittstelle -

Sr.Nr.	Schnittstelle & Beschreibung
1	Die Sammlungsschnittstelle Auf diese Weise können Sie mit Objektgruppen arbeiten. Es befindet sich ganz oben in der Sammlungshierarchie.
2	Die Listenschnittstelle Dies erstreckt sich Collection und eine Instanz von List speichert eine geordnete Sammlung von Elementen.
3	Der Satz Dadurch wird Collection auf Handle-Sets erweitert, die eindeutige Elemente enthalten müssen.
4	Das SortedSet Dies erweitert Set, um sortierte Sets zu verarbeiten.
5	Die Karte Dadurch werden eindeutige Schlüssel Werten zugeordnet.
6	Die Map.Entry Dies beschreibt ein Element (ein Schlüssel / Wert-Paar) in einer Karte. Dies ist eine innere Klasse von Map.
7	Die SortedMap Dadurch wird Map erweitert, sodass die Schlüssel in aufsteigender Reihenfolge verwaltet werden.
8	Die Aufzählung Diese Legacy-Schnittstelle definiert die Methoden, mit denen Sie die Elemente in einer Sammlung von Objekten auflisten (einzeln abrufen) können. Diese Legacy-Schnittstelle wurde von Iterator abgelöst.

Die Sammlungsklassen

Java bietet eine Reihe von Standard-Sammlungsklassen, die Sammlungsschnittstellen implementieren. Einige der Klassen bieten vollständige Implementierungen, die unverändert verwendet werden können, andere sind abstrakte Klassen und bieten Skelettimplementierungen, die als Ausgangspunkte für die Erstellung konkreter Sammlungen dienen.

Die Standard-Sammlungsklassen sind in der folgenden Tabelle zusammengefasst:

Sr.Nr.	Klasse & Beschreibung
1	AbstractCollection Implementiert den größten Teil der Collection-Oberfläche.
2	AbstractList Erweitert AbstractCollection und implementiert den größten Teil der List-Oberfläche.
3	AbstractSequentialList Erweitert AbstractList für die Verwendung durch eine Sammlung, die sequentiellen statt zufälligen Zugriff auf ihre Elemente verwendet.
4	LinkedList Implementiert eine verknüpfte Liste durch Erweitern von AbstractSequentialList.
5	Anordnungsliste Implementiert ein dynamisches Array durch Erweitern von AbstractList.
6	AbstractSet Erweitert AbstractCollection und implementiert den größten Teil der Set-Schnittstelle.
7	HashSet Erweitert AbstractSet für die Verwendung mit einer Hash-Tabelle.
8	LinkedHashSet Erweitert HashSet, um Iterationen in Einfügereihenfolge zu ermöglichen.
9	TreeSet Implementiert eine in einem Baum gespeicherte Menge. Erweitert AbstractSet.
10	AbstractMap Implementiert den größten Teil der Map-Oberfläche.
11	HashMap Erweitert AbstractMap um die Verwendung einer Hash-Tabelle.
12	Baumkarte Erweitert AbstractMap, um einen Baum zu verwenden.
13	WeakHashMap Erweitert AbstractMap, um eine Hash-Tabelle mit schwachen Schlüsseln zu verwenden.
14	LinkedHashMap Erweitert HashMap, um Iterationen in Einfügereihenfolge zu ermöglichen.
15	IdentityHashMap Erweitert AbstractMap und verwendet beim Vergleichen von Dokumenten die Referenzgleichheit.

Die Klassen AbstractCollection, AbstractSet, AbstractList, AbstractSequentialList und AbstractMap bieten Skelettimplementierungen der Kernsammlungsschnittstellen, um den Aufwand für deren Implementierung zu minimieren.

Die folgenden von java.util definierten Legacy-Klassen wurden im vorherigen Kapitel erläutert:

Sr.Nr.	Klasse & Beschreibung
1	Vektor Dies implementiert ein dynamisches Array. Es ähnelt ArrayList, weist jedoch einige Unterschiede auf.
2	Stapel Stack ist eine Unterklasse von Vector, die einen Standard-Last-In-First-Out-Stack implementiert.
3	Wörterbuch Dictionary ist eine abstrakte Klasse, die ein Schlüssel- / Wertspeicher-Repository darstellt und ähnlich wie Map funktioniert.
4	Hash-tabelle Hashtable war Teil der ursprünglichen java.util und ist eine konkrete Implementierung eines Wörterbuchs.
5	Eigenschaften Properties ist eine Unterklasse von Hashtable. Es wird verwendet, um Wertelisten zu verwalten, in denen der Schlüssel ein String und der Wert auch ein String ist.
6	BitSet Eine BitSet-Klasse erstellt einen speziellen Array-Typ, der Bitwerte enthält. Dieses Array kann bei Bedarf vergrößert werden.

Die Erfassungsalgorithmen

Das Sammlungsframework definiert mehrere Algorithmen, die auf Sammlungen und Karten angewendet werden können. Diese Algorithmen werden als statische Methoden innerhalb der Collections-Klasse definiert.

Einige der Methoden können a werfen ClassCastException, die auftritt, wenn versucht wird, inkompatible Typen zu vergleichen, oder ein UnsupportedOperationExceptionDies tritt auf, wenn versucht wird, eine nicht veränderbare Sammlung zu ändern.

Sammlungen definieren drei statische Variablen: EMPTY_SET, EMPTY_LIST und EMPTY_MAP. Alle sind unveränderlich.

Sr.Nr.	Algorithmus & Beschreibung
1	Die Erfassungsalgorithmen Hier ist eine Liste aller Algorithmenimplementierungen.

Wie benutzt man einen Iterator?

Oft möchten Sie die Elemente in einer Sammlung durchlaufen. Beispielsweise möchten Sie möglicherweise jedes Element anzeigen.

Der einfachste Weg, dies zu tun, besteht darin, einen Iterator zu verwenden, bei dem es sich um ein Objekt handelt, das entweder die Iterator- oder die ListIterator-Schnittstelle implementiert.

Mit Iterator können Sie eine Sammlung durchlaufen, Elemente abrufen oder entfernen. ListIterator erweitert Iterator, um das bidirektionale Durchlaufen einer Liste und das Ändern von Elementen zu ermöglichen.

Sr.Nr.	Iteratormethode & Beschreibung
1	Verwenden von Java Iterator Hier finden Sie eine Liste aller Methoden mit Beispielen, die von Iterator- und ListIterator-Schnittstellen bereitgestellt werden.

Wie benutze ich einen Komparator?

Sowohl TreeSet als auch TreeMap speichern Elemente in einer sortierten Reihenfolge. Es ist jedoch der Komparator, der genau definiert, was sortierte Reihenfolge bedeutet.

Über diese Schnittstelle können wir eine bestimmte Sammlung auf verschiedene Arten sortieren. Diese Schnittstelle kann auch verwendet werden, um Instanzen einer Klasse zu sortieren (auch Klassen, die wir nicht ändern können).

Sr.Nr.	Iteratormethode & Beschreibung
1	Verwenden von Java Comparator Hier finden Sie eine Liste aller Methoden mit Beispielen, die von Comparator Interface bereitgestellt werden.

Zusammenfassung

Das Java-Sammlungsframework bietet dem Programmierer Zugriff auf vorgefertigte Datenstrukturen sowie auf Algorithmen zu deren Bearbeitung.

Eine Sammlung ist ein Objekt, das Verweise auf andere Objekte enthalten kann. Die Sammlungsschnittstellen deklarieren die Operationen, die für jeden Sammlungstyp ausgeführt werden können.

Die Klassen und Schnittstellen des Sammlungsframeworks befinden sich im Paket java.util.

Es wäre schön, wenn wir eine einzelne Sortiermethode schreiben könnten, die die Elemente in einem Integer-Array, einem String-Array oder einem Array eines beliebigen Typs sortieren könnte, der die Reihenfolge unterstützt.

Java Generic Mithilfe von Methoden und generischen Klassen können Programmierer mit einer einzelnen Methodendeklaration eine Reihe verwandter Methoden bzw. mit einer einzelnen Klassendeklaration eine Reihe verwandter Typen angeben.

Generika bieten auch Typensicherheit zur Kompilierungszeit, mit der Programmierer ungültige Typen zur Kompilierungszeit abfangen können.

Unter Verwendung des generischen Java-Konzepts schreiben wir möglicherweise eine generische Methode zum Sortieren eines Arrays von Objekten und rufen dann die generische Methode mit Integer-Arrays, Double-Arrays, String-Arrays usw. auf, um die Array-Elemente zu sortieren.

Generische Methoden

Sie können eine einzelne generische Methodendeklaration schreiben, die mit Argumenten unterschiedlichen Typs aufgerufen werden kann. Basierend auf den Typen der Argumente, die an die generische Methode übergeben werden, behandelt der Compiler jeden Methodenaufruf entsprechend. Im Folgenden finden Sie die Regeln zum Definieren generischer Methoden:

• Alle generischen Methodendeklarationen haben einen Typparameterabschnitt, der durch spitze Klammern (<und>) begrenzt ist und vor dem Rückgabetyp der Methode steht (<E> im nächsten Beispiel).

• Jeder Typparameterabschnitt enthält einen oder mehrere durch Kommas getrennte Typparameter. Ein Typparameter, auch als Typvariable bezeichnet, ist ein Bezeichner, der einen generischen Typnamen angibt.

• Die Typparameter können verwendet werden, um den Rückgabetyp zu deklarieren und als Platzhalter für die Typen der an die generische Methode übergebenen Argumente zu fungieren, die als tatsächliche Typargumente bezeichnet werden.

• Der Körper einer generischen Methode wird wie der einer anderen Methode deklariert. Beachten Sie, dass Typparameter nur Referenztypen darstellen können, keine primitiven Typen (wie int, double und char).

Beispiel

Das folgende Beispiel zeigt, wie wir ein Array unterschiedlichen Typs mit einer einzigen generischen Methode drucken können.

public class GenericMethodTest {
   // generic method printArray
   public static < E > void printArray( E[] inputArray ) {
      // Display array elements
      for(E element : inputArray) {
         System.out.printf("%s ", element);
      }
      System.out.println();
   }

   public static void main(String args[]) {
      // Create arrays of Integer, Double and Character
      Integer[] intArray = { 1, 2, 3, 4, 5 };
      Double[] doubleArray = { 1.1, 2.2, 3.3, 4.4 };
      Character[] charArray = { 'H', 'E', 'L', 'L', 'O' };

      System.out.println("Array integerArray contains:");
      printArray(intArray);   // pass an Integer array

      System.out.println("\nArray doubleArray contains:");
      printArray(doubleArray);   // pass a Double array

      System.out.println("\nArray characterArray contains:");
      printArray(charArray);   // pass a Character array
   }
}

Dies führt zu folgendem Ergebnis:

Ausgabe

Array integerArray contains:
1 2 3 4 5 

Array doubleArray contains:
1.1 2.2 3.3 4.4 

Array characterArray contains:
H E L L O

Begrenzte Typparameter

Es kann vorkommen, dass Sie die Arten von Typen einschränken möchten, die an einen Typparameter übergeben werden dürfen. Beispielsweise möchte eine Methode, die mit Zahlen arbeitet, möglicherweise nur Instanzen von Number oder deren Unterklassen akzeptieren. Dafür sind begrenzte Typparameter gedacht.

Um einen begrenzten Typparameter zu deklarieren, listen Sie den Namen des Typparameters auf, gefolgt vom Schlüsselwort extens, gefolgt von seiner Obergrenze.

Beispiel

Das folgende Beispiel zeigt, wie Erweiterungen im Allgemeinen verwendet werden, um entweder "Erweiterungen" (wie in Klassen) oder "Implementierungen" (wie in Schnittstellen) zu bedeuten. Dieses Beispiel ist eine generische Methode, um das größte von drei vergleichbaren Objekten zurückzugeben.

public class MaximumTest {
   // determines the largest of three Comparable objects
   
   public static <T extends Comparable<T>> T maximum(T x, T y, T z) {
      T max = x;   // assume x is initially the largest
      
      if(y.compareTo(max) > 0) {
         max = y;   // y is the largest so far
      }
      
      if(z.compareTo(max) > 0) {
         max = z;   // z is the largest now                 
      }
      return max;   // returns the largest object   
   }
   
   public static void main(String args[]) {
      System.out.printf("Max of %d, %d and %d is %d\n\n", 
         3, 4, 5, maximum( 3, 4, 5 ));

      System.out.printf("Max of %.1f,%.1f and %.1f is %.1f\n\n",
         6.6, 8.8, 7.7, maximum( 6.6, 8.8, 7.7 ));

      System.out.printf("Max of %s, %s and %s is %s\n","pear",
         "apple", "orange", maximum("pear", "apple", "orange"));
   }
}

Dies führt zu folgendem Ergebnis:

Ausgabe

Max of 3, 4 and 5 is 5

Max of 6.6,8.8 and 7.7 is 8.8

Max of pear, apple and orange is pear

Generische Klassen

Eine generische Klassendeklaration sieht aus wie eine nicht generische Klassendeklaration, außer dass auf den Klassennamen ein Typparameterabschnitt folgt.

Wie bei generischen Methoden kann der Typparameterabschnitt einer generischen Klasse einen oder mehrere durch Kommas getrennte Typparameter aufweisen. Diese Klassen werden als parametrisierte Klassen oder parametrisierte Typen bezeichnet, da sie einen oder mehrere Parameter akzeptieren.

Beispiel

Das folgende Beispiel zeigt, wie wir eine generische Klasse definieren können -

public class Box<T> {
   private T t;

   public void add(T t) {
      this.t = t;
   }

   public T get() {
      return t;
   }

   public static void main(String[] args) {
      Box<Integer> integerBox = new Box<Integer>();
      Box<String> stringBox = new Box<String>();
    
      integerBox.add(new Integer(10));
      stringBox.add(new String("Hello World"));

      System.out.printf("Integer Value :%d\n\n", integerBox.get());
      System.out.printf("String Value :%s\n", stringBox.get());
   }
}

Dies führt zu folgendem Ergebnis:

Ausgabe

Integer Value :10
String Value :Hello World

Java bietet einen Mechanismus namens Objektserialisierung, bei dem ein Objekt als eine Folge von Bytes dargestellt werden kann, die die Daten des Objekts sowie Informationen über den Objekttyp und die im Objekt gespeicherten Datentypen enthält.

Nachdem ein serialisiertes Objekt in eine Datei geschrieben wurde, kann es aus der Datei gelesen und deserialisiert werden, dh die Typinformationen und Bytes, die das Objekt und seine Daten darstellen, können verwendet werden, um das Objekt im Speicher neu zu erstellen.

Am beeindruckendsten ist, dass der gesamte Prozess JVM-unabhängig ist, was bedeutet, dass ein Objekt auf einer Plattform serialisiert und auf einer völlig anderen Plattform deserialisiert werden kann.

Klassen ObjectInputStream und ObjectOutputStream sind Streams auf hoher Ebene, die die Methoden zum Serialisieren und Deserialisieren eines Objekts enthalten.

Die ObjectOutputStream-Klasse enthält viele Schreibmethoden zum Schreiben verschiedener Datentypen, wobei jedoch eine Methode besonders hervorzuheben ist:

public final void writeObject(Object x) throws IOException

Die obige Methode serialisiert ein Objekt und sendet es an den Ausgabestream. In ähnlicher Weise enthält die ObjectInputStream-Klasse die folgende Methode zum Deserialisieren eines Objekts:

public final Object readObject() throws IOException, ClassNotFoundException

Diese Methode ruft das nächste Objekt aus dem Stream ab und deserialisiert es. Der Rückgabewert ist Object, daher müssen Sie ihn in den entsprechenden Datentyp umwandeln.

Um zu demonstrieren, wie die Serialisierung in Java funktioniert, werde ich die Employee-Klasse verwenden, die wir zu Beginn des Buches besprochen haben. Angenommen, wir haben die folgende Employee-Klasse, die die serialisierbare Schnittstelle implementiert:

Beispiel

public class Employee implements java.io.Serializable {
   public String name;
   public String address;
   public transient int SSN;
   public int number;
   
   public void mailCheck() {
      System.out.println("Mailing a check to " + name + " " + address);
   }
}

Beachten Sie, dass zwei Bedingungen erfüllt sein müssen, damit eine Klasse erfolgreich serialisiert werden kann:

• Die Klasse muss die Schnittstelle java.io.Serializable implementieren.

• Alle Felder in der Klasse müssen serialisierbar sein. Wenn ein Feld nicht serialisierbar ist, muss es markiert werdentransient.

Wenn Sie neugierig sind, ob eine Java-Standardklasse serialisierbar ist oder nicht, lesen Sie die Dokumentation für die Klasse. Der Test ist einfach: Wenn die Klasse java.io.Serializable implementiert, ist sie serialisierbar. sonst ist es nicht.

Ein Objekt serialisieren

Die ObjectOutputStream-Klasse wird zum Serialisieren eines Objekts verwendet. Das folgende SerializeDemo-Programm instanziiert ein Employee-Objekt und serialisiert es in eine Datei.

Nach Abschluss der Programmausführung wird eine Datei mit dem Namen employee.ser erstellt. Das Programm generiert keine Ausgabe, studiert jedoch den Code und versucht festzustellen, was das Programm tut.

Note - Wenn Sie ein Objekt in eine Datei serialisieren, besteht die Standardkonvention in Java darin, der Datei eine zu geben .ser Erweiterung.

Beispiel

import java.io.*;
public class SerializeDemo {

   public static void main(String [] args) {
      Employee e = new Employee();
      e.name = "Reyan Ali";
      e.address = "Phokka Kuan, Ambehta Peer";
      e.SSN = 11122333;
      e.number = 101;
      
      try {
         FileOutputStream fileOut =
         new FileOutputStream("/tmp/employee.ser");
         ObjectOutputStream out = new ObjectOutputStream(fileOut);
         out.writeObject(e);
         out.close();
         fileOut.close();
         System.out.printf("Serialized data is saved in /tmp/employee.ser");
      } catch (IOException i) {
         i.printStackTrace();
      }
   }
}

Deserialisieren eines Objekts

Das folgende DeserializeDemo-Programm deserialisiert das im SerializeDemo-Programm erstellte Employee-Objekt. Studieren Sie das Programm und versuchen Sie, seine Ausgabe zu bestimmen -

Beispiel

import java.io.*;
public class DeserializeDemo {

   public static void main(String [] args) {
      Employee e = null;
      try {
         FileInputStream fileIn = new FileInputStream("/tmp/employee.ser");
         ObjectInputStream in = new ObjectInputStream(fileIn);
         e = (Employee) in.readObject();
         in.close();
         fileIn.close();
      } catch (IOException i) {
         i.printStackTrace();
         return;
      } catch (ClassNotFoundException c) {
         System.out.println("Employee class not found");
         c.printStackTrace();
         return;
      }
      
      System.out.println("Deserialized Employee...");
      System.out.println("Name: " + e.name);
      System.out.println("Address: " + e.address);
      System.out.println("SSN: " + e.SSN);
      System.out.println("Number: " + e.number);
   }
}

Dies führt zu folgendem Ergebnis:

Ausgabe

Deserialized Employee...
Name: Reyan Ali
Address:Phokka Kuan, Ambehta Peer
SSN: 0
Number:101

Hier sind folgende wichtige Punkte zu beachten:

• Der try / catch-Block versucht, eine ClassNotFoundException abzufangen, die von der readObject () -Methode deklariert wird. Damit eine JVM ein Objekt deserialisieren kann, muss sie den Bytecode für die Klasse finden können. Wenn die JVM während der Deserialisierung eines Objekts keine Klasse finden kann, löst sie eine ClassNotFoundException aus.

• Beachten Sie, dass der Rückgabewert von readObject () in eine Mitarbeiterreferenz umgewandelt wird.

• Der Wert des SSN-Felds war 11122333, als das Objekt serialisiert wurde. Da das Feld jedoch vorübergehend ist, wurde dieser Wert nicht an den Ausgabestream gesendet. Das SSN-Feld des deserialisierten Employee-Objekts ist 0.

Der Begriff Netzwerkprogrammierung bezieht sich auf das Schreiben von Programmen, die auf mehreren Geräten (Computern) ausgeführt werden, bei denen alle Geräte über ein Netzwerk miteinander verbunden sind.

Das java.net-Paket der J2SE-APIs enthält eine Sammlung von Klassen und Schnittstellen, die die Kommunikationsdetails auf niedriger Ebene bereitstellen, sodass Sie Programme schreiben können, die sich auf die Lösung des vorliegenden Problems konzentrieren.

Das java.net-Paket bietet Unterstützung für die beiden gängigen Netzwerkprotokolle -

• TCP- TCP steht für Transmission Control Protocol, das eine zuverlässige Kommunikation zwischen zwei Anwendungen ermöglicht. TCP wird normalerweise über das Internetprotokoll verwendet, das als TCP / IP bezeichnet wird.

• UDP - UDP steht für User Datagram Protocol, ein verbindungsloses Protokoll, mit dem Datenpakete zwischen Anwendungen übertragen werden können.

Dieses Kapitel vermittelt ein gutes Verständnis zu den folgenden beiden Themen:

• Socket Programming - Dies ist das am weitesten verbreitete Konzept in der Vernetzung und wurde sehr ausführlich erläutert.

• URL Processing- Dies würde separat behandelt. Klicken Sie hier, um mehr über die URL-Verarbeitung in Java zu erfahren .

Socket-Programmierung

Sockets stellen den Kommunikationsmechanismus zwischen zwei Computern mithilfe von TCP bereit. Ein Client-Programm erstellt am Ende der Kommunikation einen Socket und versucht, diesen Socket mit einem Server zu verbinden.

Wenn die Verbindung hergestellt ist, erstellt der Server am Ende der Kommunikation ein Socket-Objekt. Der Client und der Server können jetzt kommunizieren, indem sie in den Socket schreiben und von diesem lesen.

Die Klasse java.net.Socket stellt einen Socket dar, und die Klasse java.net.ServerSocket bietet einen Mechanismus für das Serverprogramm, um auf Clients zu warten und Verbindungen mit ihnen herzustellen.

Die folgenden Schritte werden ausgeführt, wenn eine TCP-Verbindung zwischen zwei Computern mithilfe von Sockets hergestellt wird:

• Der Server instanziiert ein ServerSocket-Objekt und gibt an, an welcher Portnummer die Kommunikation stattfinden soll.

• Der Server ruft die accept () -Methode der ServerSocket-Klasse auf. Diese Methode wartet, bis ein Client am angegebenen Port eine Verbindung zum Server herstellt.

• Nachdem der Server gewartet hat, instanziiert ein Client ein Socket-Objekt und gibt den Servernamen und die Portnummer an, zu der eine Verbindung hergestellt werden soll.

• Der Konstruktor der Socket-Klasse versucht, den Client mit dem angegebenen Server und der Portnummer zu verbinden. Wenn die Kommunikation hergestellt ist, verfügt der Client jetzt über ein Socket-Objekt, das mit dem Server kommunizieren kann.

• Auf der Serverseite gibt die accept () -Methode einen Verweis auf einen neuen Socket auf dem Server zurück, der mit dem Socket des Clients verbunden ist.

Nachdem die Verbindungen hergestellt wurden, kann die Kommunikation über E / A-Streams erfolgen. Jeder Socket hat sowohl einen OutputStream als auch einen InputStream. Der OutputStream des Clients ist mit dem InputStream des Servers verbunden, und der InputStream des Clients ist mit dem OutputStream des Servers verbunden.

TCP ist ein bidirektionales Kommunikationsprotokoll, daher können Daten gleichzeitig über beide Streams gesendet werden. Im Folgenden finden Sie die nützlichen Klassen, die einen vollständigen Satz von Methoden zum Implementieren von Sockets bereitstellen.

ServerSocket-Klassenmethoden

Das java.net.ServerSocket Die Klasse wird von Serveranwendungen verwendet, um einen Port abzurufen und auf Clientanforderungen zu warten.

Die ServerSocket-Klasse verfügt über vier Konstruktoren -

Sr.Nr.	Methode & Beschreibung
1	public ServerSocket(int port) throws IOException Es wird versucht, einen Server-Socket zu erstellen, der an den angegebenen Port gebunden ist. Eine Ausnahme tritt auf, wenn der Port bereits an eine andere Anwendung gebunden ist.
2	public ServerSocket(int port, int backlog) throws IOException Ähnlich wie beim vorherigen Konstruktor gibt der Parameter backlog an, wie viele eingehende Clients in einer Warteschlange gespeichert werden sollen.
3	public ServerSocket(int port, int backlog, InetAddress address) throws IOException Ähnlich wie beim vorherigen Konstruktor gibt der Parameter InetAddress die lokale IP-Adresse an, an die gebunden werden soll. Die InetAddress wird für Server verwendet, die möglicherweise mehrere IP-Adressen haben, sodass der Server angeben kann, auf welcher seiner IP-Adressen Clientanforderungen akzeptiert werden sollen.
4	public ServerSocket() throws IOException Erstellt einen ungebundenen Server-Socket. Verwenden Sie bei Verwendung dieses Konstruktors die Methode bind (), wenn Sie bereit sind, den Server-Socket zu binden.

Wenn der ServerSocket-Konstruktor keine Ausnahme auslöst, bedeutet dies, dass Ihre Anwendung erfolgreich an den angegebenen Port gebunden wurde und für Clientanforderungen bereit ist.

Im Folgenden sind einige der gängigen Methoden der ServerSocket-Klasse aufgeführt:

Sr.Nr.	Methode & Beschreibung
1	public int getLocalPort() Gibt den Port zurück, den der Server-Socket abhört. Diese Methode ist nützlich, wenn Sie in einem Konstruktor 0 als Portnummer übergeben und den Server einen Port für Sie finden lassen.
2	public Socket accept() throws IOException Wartet auf einen eingehenden Client. Diese Methode wird blockiert, bis entweder ein Client über den angegebenen Port eine Verbindung zum Server herstellt oder das Socket eine Zeitüberschreitung aufweist, vorausgesetzt, der Zeitlimitwert wurde mit der Methode setSoTimeout () festgelegt. Andernfalls wird diese Methode auf unbestimmte Zeit blockiert.
3	public void setSoTimeout(int timeout) Legt den Timeout-Wert fest, wie lange der Server-Socket während der Annahme () auf einen Client wartet.
4	public void bind(SocketAddress host, int backlog) Bindet den Socket an den angegebenen Server und Port im SocketAddress-Objekt. Verwenden Sie diese Methode, wenn Sie den ServerSocket mit dem Konstruktor ohne Argumente instanziiert haben.

Wenn der ServerSocket accept () aufruft, wird die Methode erst zurückgegeben, wenn ein Client eine Verbindung herstellt. Nachdem ein Client eine Verbindung hergestellt hat, erstellt der ServerSocket einen neuen Socket an einem nicht angegebenen Port und gibt einen Verweis auf diesen neuen Socket zurück. Zwischen dem Client und dem Server besteht jetzt eine TCP-Verbindung, und die Kommunikation kann beginnen.

Socket-Klassenmethoden

Das java.net.SocketKlasse stellt den Socket dar, über den sowohl der Client als auch der Server miteinander kommunizieren. Der Client erhält ein Socket-Objekt durch Instanziieren eines Objekts, während der Server ein Socket-Objekt aus dem Rückgabewert der accept () -Methode erhält.

Die Socket-Klasse verfügt über fünf Konstruktoren, mit denen ein Client eine Verbindung zu einem Server herstellt.

Sr.Nr.	Methode & Beschreibung
1	public Socket(String host, int port) throws UnknownHostException, IOException. Diese Methode versucht, am angegebenen Port eine Verbindung zum angegebenen Server herzustellen. Wenn dieser Konstruktor keine Ausnahme auslöst, ist die Verbindung erfolgreich und der Client ist mit dem Server verbunden.
2	public Socket(InetAddress host, int port) throws IOException Diese Methode ist identisch mit dem vorherigen Konstruktor, außer dass der Host durch ein InetAddress-Objekt gekennzeichnet ist.
3	public Socket(String host, int port, InetAddress localAddress, int localPort) throws IOException. Stellt eine Verbindung zum angegebenen Host und Port her und erstellt einen Socket auf dem lokalen Host unter der angegebenen Adresse und dem angegebenen Port.
4	public Socket(InetAddress host, int port, InetAddress localAddress, int localPort) throws IOException. Diese Methode ist identisch mit dem vorherigen Konstruktor, außer dass der Host durch ein InetAddress-Objekt anstelle eines Strings gekennzeichnet ist.
5	public Socket() Erstellt einen nicht verbundenen Socket. Verwenden Sie die connect () -Methode, um diesen Socket mit einem Server zu verbinden.

Wenn der Socket-Konstruktor zurückkehrt, instanziiert er nicht einfach ein Socket-Objekt, sondern versucht tatsächlich, eine Verbindung zum angegebenen Server und Port herzustellen.

Einige interessante Methoden in der Socket-Klasse sind hier aufgelistet. Beachten Sie, dass sowohl der Client als auch der Server über ein Socket-Objekt verfügen, sodass diese Methoden sowohl vom Client als auch vom Server aufgerufen werden können.

Sr.Nr.	Methode & Beschreibung
1	public void connect(SocketAddress host, int timeout) throws IOException Diese Methode verbindet den Socket mit dem angegebenen Host. Diese Methode wird nur benötigt, wenn Sie den Socket mit dem Konstruktor ohne Argumente instanziieren.
2	public InetAddress getInetAddress() Diese Methode gibt die Adresse des anderen Computers zurück, mit dem dieser Socket verbunden ist.
3	public int getPort() Gibt den Port zurück, an den der Socket auf dem Remotecomputer gebunden ist.
4	public int getLocalPort() Gibt den Port zurück, an den der Socket auf dem lokalen Computer gebunden ist.
5	public SocketAddress getRemoteSocketAddress() Gibt die Adresse des Remote-Sockets zurück.
6	public InputStream getInputStream() throws IOException Gibt den Eingabestream des Sockets zurück. Der Eingangsstrom ist mit dem Ausgangsstrom des Remote-Sockets verbunden.
7	public OutputStream getOutputStream() throws IOException Gibt den Ausgabestream des Sockets zurück. Der Ausgangsstrom ist mit dem Eingangsstrom des Remote-Sockets verbunden.
8	public void close() throws IOException Schließt den Socket, wodurch dieses Socket-Objekt keine Verbindung mehr zu einem Server herstellen kann.

InetAddress-Klassenmethoden

Diese Klasse repräsentiert eine IP-Adresse (Internet Protocol). Hier sind die folgenden nützlichen Methoden, die Sie für die Socket-Programmierung benötigen würden:

Sr.Nr.	Methode & Beschreibung
1	static InetAddress getByAddress(byte[] addr) Gibt ein InetAddress-Objekt mit der unformatierten IP-Adresse zurück.
2	static InetAddress getByAddress(String host, byte[] addr) Erstellt eine InetAddress basierend auf dem angegebenen Hostnamen und der IP-Adresse.
3	static InetAddress getByName(String host) Bestimmt die IP-Adresse eines Hosts anhand des Hostnamens.
4	String getHostAddress() Gibt die IP-Adresszeichenfolge in Textdarstellung zurück.
5	String getHostName() Ruft den Hostnamen für diese IP-Adresse ab.
6	static InetAddress InetAddress getLocalHost() Gibt den lokalen Host zurück.
7	String toString() Konvertiert diese IP-Adresse in einen String.

Beispiel für einen Socket-Client

Der folgende GreetingClient ist ein Client-Programm, das über einen Socket eine Verbindung zu einem Server herstellt, eine Begrüßung sendet und dann auf eine Antwort wartet.

Beispiel

// File Name GreetingClient.java
import java.net.*;
import java.io.*;

public class GreetingClient {

   public static void main(String [] args) {
      String serverName = args[0];
      int port = Integer.parseInt(args[1]);
      try {
         System.out.println("Connecting to " + serverName + " on port " + port);
         Socket client = new Socket(serverName, port);
         
         System.out.println("Just connected to " + client.getRemoteSocketAddress());
         OutputStream outToServer = client.getOutputStream();
         DataOutputStream out = new DataOutputStream(outToServer);
         
         out.writeUTF("Hello from " + client.getLocalSocketAddress());
         InputStream inFromServer = client.getInputStream();
         DataInputStream in = new DataInputStream(inFromServer);
         
         System.out.println("Server says " + in.readUTF());
         client.close();
      } catch (IOException e) {
         e.printStackTrace();
      }
   }
}

Beispiel für einen Socket-Server

Das folgende GreetingServer-Programm ist ein Beispiel für eine Serveranwendung, die mithilfe der Socket-Klasse auf Clients wartet, deren Portnummer durch ein Befehlszeilenargument angegeben wird.

Beispiel

// File Name GreetingServer.java
import java.net.*;
import java.io.*;

public class GreetingServer extends Thread {
   private ServerSocket serverSocket;
   
   public GreetingServer(int port) throws IOException {
      serverSocket = new ServerSocket(port);
      serverSocket.setSoTimeout(10000);
   }

   public void run() {
      while(true) {
         try {
            System.out.println("Waiting for client on port " + 
               serverSocket.getLocalPort() + "...");
            Socket server = serverSocket.accept();
            
            System.out.println("Just connected to " + server.getRemoteSocketAddress());
            DataInputStream in = new DataInputStream(server.getInputStream());
            
            System.out.println(in.readUTF());
            DataOutputStream out = new DataOutputStream(server.getOutputStream());
            out.writeUTF("Thank you for connecting to " + server.getLocalSocketAddress()
               + "\nGoodbye!");
            server.close();
            
         } catch (SocketTimeoutException s) {
            System.out.println("Socket timed out!");
            break;
         } catch (IOException e) {
            e.printStackTrace();
            break;
         }
      }
   }
   
   public static void main(String [] args) {
      int port = Integer.parseInt(args[0]);
      try {
         Thread t = new GreetingServer(port);
         t.start();
      } catch (IOException e) {
         e.printStackTrace();
      }
   }
}

Kompilieren Sie den Client und den Server und starten Sie den Server wie folgt:

$ java GreetingServer 6066
Waiting for client on port 6066...

Überprüfen Sie das Client-Programm wie folgt:

Ausgabe

$ java GreetingClient localhost 6066
Connecting to localhost on port 6066
Just connected to localhost/127.0.0.1:6066
Server says Thank you for connecting to /127.0.0.1:6066
Goodbye!

Das Senden einer E-Mail mit Ihrer Java-Anwendung ist einfach genug, sollte aber zunächst erfolgen JavaMail API und Java Activation Framework (JAF) auf Ihrem Computer installiert.

• Sie können die neueste Version von JavaMail (Version 1.2) von der Standard-Website von Java herunterladen.

• Sie können die neueste Version von JAF (Version 1.1.1) von der Standard-Website von Java herunterladen.

Laden Sie diese Dateien herunter und entpacken Sie sie. In den neu erstellten Verzeichnissen der obersten Ebene finden Sie eine Reihe von JAR-Dateien für beide Anwendungen. Sie müssen hinzufügenmail.jar und activation.jar Dateien in Ihrem CLASSPATH.

Senden Sie eine einfache E-Mail

Hier ist ein Beispiel zum Senden einer einfachen E-Mail von Ihrem Computer. Es wird davon ausgegangen, dass Ihrlocalhost ist mit dem Internet verbunden und in der Lage, eine E-Mail zu senden.

Beispiel

// File Name SendEmail.java

import java.util.*;
import javax.mail.*;
import javax.mail.internet.*;
import javax.activation.*;

public class SendEmail {

   public static void main(String [] args) {    
      // Recipient's email ID needs to be mentioned.
      String to = "[email protected]";

      // Sender's email ID needs to be mentioned
      String from = "[email protected]";

      // Assuming you are sending email from localhost
      String host = "localhost";

      // Get system properties
      Properties properties = System.getProperties();

      // Setup mail server
      properties.setProperty("mail.smtp.host", host);

      // Get the default Session object.
      Session session = Session.getDefaultInstance(properties);

      try {
         // Create a default MimeMessage object.
         MimeMessage message = new MimeMessage(session);

         // Set From: header field of the header.
         message.setFrom(new InternetAddress(from));

         // Set To: header field of the header.
         message.addRecipient(Message.RecipientType.TO, new InternetAddress(to));

         // Set Subject: header field
         message.setSubject("This is the Subject Line!");

         // Now set the actual message
         message.setText("This is actual message");

         // Send message
         Transport.send(message);
         System.out.println("Sent message successfully....");
      } catch (MessagingException mex) {
         mex.printStackTrace();
      }
   }
}

Kompilieren Sie dieses Programm und führen Sie es aus, um eine einfache E-Mail zu senden.

Ausgabe

$ java SendEmail
Sent message successfully....

Wenn Sie eine E-Mail an mehrere Empfänger senden möchten, werden die folgenden Methoden verwendet, um mehrere E-Mail-IDs anzugeben:

void addRecipients(Message.RecipientType type, Address[] addresses)
   throws MessagingException

Hier ist die Beschreibung der Parameter -

• type- Dies würde auf TO, CC oder BCC gesetzt. Hier steht CC für Carbon Copy und BCC für Black Carbon Copy. Beispiel: Message.RecipientType.TO

• addresses- Dies ist ein Array von E-Mail-IDs. Sie müssten die InternetAddress () -Methode verwenden, um E-Mail-IDs anzugeben.

Senden Sie eine HTML-E-Mail

Hier ist ein Beispiel zum Senden einer HTML-E-Mail von Ihrem Computer. Hier wird davon ausgegangen, dass Ihrlocalhost ist mit dem Internet verbunden und in der Lage, eine E-Mail zu senden.

Dieses Beispiel ist dem vorherigen sehr ähnlich, außer dass wir hier die setContent () -Methode verwenden, um Inhalte festzulegen, deren zweites Argument "text / html" ist, um anzugeben, dass der HTML-Inhalt in der Nachricht enthalten ist.

In diesem Beispiel können Sie so viel HTML-Inhalt senden, wie Sie möchten.

Beispiel

// File Name SendHTMLEmail.java

import java.util.*;
import javax.mail.*;
import javax.mail.internet.*;
import javax.activation.*;

public class SendHTMLEmail {

   public static void main(String [] args) {
      // Recipient's email ID needs to be mentioned.
      String to = "[email protected]";

      // Sender's email ID needs to be mentioned
      String from = "[email protected]";

      // Assuming you are sending email from localhost
      String host = "localhost";

      // Get system properties
      Properties properties = System.getProperties();

      // Setup mail server
      properties.setProperty("mail.smtp.host", host);

      // Get the default Session object.
      Session session = Session.getDefaultInstance(properties);

      try {
         // Create a default MimeMessage object.
         MimeMessage message = new MimeMessage(session);

         // Set From: header field of the header.
         message.setFrom(new InternetAddress(from));

         // Set To: header field of the header.
         message.addRecipient(Message.RecipientType.TO, new InternetAddress(to));

         // Set Subject: header field
         message.setSubject("This is the Subject Line!");

         // Send the actual HTML message, as big as you like
         message.setContent("<h1>This is actual message</h1>", "text/html");

         // Send message
         Transport.send(message);
         System.out.println("Sent message successfully....");
      } catch (MessagingException mex) {
         mex.printStackTrace();
      }
   }
}

Kompilieren Sie dieses Programm und führen Sie es aus, um eine HTML-E-Mail zu senden.

Ausgabe

$ java SendHTMLEmail
Sent message successfully....

Anhang per E-Mail senden

Hier ist ein Beispiel zum Senden einer E-Mail mit Anhang von Ihrem Computer. Hier wird davon ausgegangen, dass Ihrlocalhost ist mit dem Internet verbunden und in der Lage, eine E-Mail zu senden.

Beispiel

// File Name SendFileEmail.java

import java.util.*;
import javax.mail.*;
import javax.mail.internet.*;
import javax.activation.*;

public class SendFileEmail {

   public static void main(String [] args) {     
      // Recipient's email ID needs to be mentioned.
      String to = "[email protected]";

      // Sender's email ID needs to be mentioned
      String from = "[email protected]";

      // Assuming you are sending email from localhost
      String host = "localhost";

      // Get system properties
      Properties properties = System.getProperties();

      // Setup mail server
      properties.setProperty("mail.smtp.host", host);

      // Get the default Session object.
      Session session = Session.getDefaultInstance(properties);

      try {
         // Create a default MimeMessage object.
         MimeMessage message = new MimeMessage(session);

         // Set From: header field of the header.
         message.setFrom(new InternetAddress(from));

         // Set To: header field of the header.
         message.addRecipient(Message.RecipientType.TO,new InternetAddress(to));

         // Set Subject: header field
         message.setSubject("This is the Subject Line!");

         // Create the message part 
         BodyPart messageBodyPart = new MimeBodyPart();

         // Fill the message
         messageBodyPart.setText("This is message body");
         
         // Create a multipar message
         Multipart multipart = new MimeMultipart();

         // Set text message part
         multipart.addBodyPart(messageBodyPart);

         // Part two is attachment
         messageBodyPart = new MimeBodyPart();
         String filename = "file.txt";
         DataSource source = new FileDataSource(filename);
         messageBodyPart.setDataHandler(new DataHandler(source));
         messageBodyPart.setFileName(filename);
         multipart.addBodyPart(messageBodyPart);

         // Send the complete message parts
         message.setContent(multipart );

         // Send message
         Transport.send(message);
         System.out.println("Sent message successfully....");
      } catch (MessagingException mex) {
         mex.printStackTrace();
      }
   }
}

Kompilieren Sie dieses Programm und führen Sie es aus, um eine HTML-E-Mail zu senden.

Ausgabe

$ java SendFileEmail
Sent message successfully....

Benutzerauthentifizierungsteil

Wenn dem E-Mail-Server zur Authentifizierung Benutzer-ID und Kennwort angegeben werden müssen, können Sie diese Eigenschaften wie folgt festlegen:

props.setProperty("mail.user", "myuser");
props.setProperty("mail.password", "mypwd");

Der Rest des E-Mail-Versandmechanismus bleibt wie oben erläutert.

Java ist eine Multithread-Programmiersprache, was bedeutet, dass wir Multithread-Programme mit Java entwickeln können. Ein Multithread-Programm enthält zwei oder mehr Teile, die gleichzeitig ausgeführt werden können, und jeder Teil kann gleichzeitig eine andere Aufgabe ausführen und die verfügbaren Ressourcen optimal nutzen, insbesondere wenn Ihr Computer über mehrere CPUs verfügt.

Multitasking ist per Definition, wenn mehrere Prozesse gemeinsame Verarbeitungsressourcen wie eine CPU gemeinsam nutzen. Multithreading erweitert die Idee des Multitasking auf Anwendungen, bei denen Sie bestimmte Vorgänge innerhalb einer einzelnen Anwendung in einzelne Threads unterteilen können. Jeder der Threads kann parallel ausgeführt werden. Das Betriebssystem teilt die Verarbeitungszeit nicht nur auf verschiedene Anwendungen auf, sondern auch auf jeden Thread innerhalb einer Anwendung.

Mit Multithreading können Sie so schreiben, dass mehrere Aktivitäten gleichzeitig im selben Programm ausgeführt werden können.

Lebenszyklus eines Threads

Ein Thread durchläuft verschiedene Phasen seines Lebenszyklus. Beispielsweise wird ein Thread geboren, gestartet, ausgeführt und stirbt dann. Das folgende Diagramm zeigt den gesamten Lebenszyklus eines Threads.

Es folgen die Phasen des Lebenszyklus -

• New- Ein neuer Thread beginnt seinen Lebenszyklus im neuen Zustand. Es bleibt in diesem Zustand, bis das Programm den Thread startet. Es wird auch als bezeichnetborn thread.

• Runnable- Nachdem ein neu geborener Thread gestartet wurde, kann der Thread ausgeführt werden. Ein Thread in diesem Status führt seine Aufgabe aus.

• Waiting- Manchmal wechselt ein Thread in den Wartezustand, während der Thread darauf wartet, dass ein anderer Thread eine Aufgabe ausführt. Ein Thread wechselt nur dann in den ausführbaren Zustand zurück, wenn ein anderer Thread dem wartenden Thread signalisiert, die Ausführung fortzusetzen.

• Timed Waiting- Ein ausführbarer Thread kann für ein bestimmtes Zeitintervall in den zeitgesteuerten Wartezustand wechseln. Ein Thread in diesem Zustand wechselt zurück in den ausführbaren Zustand, wenn dieses Zeitintervall abläuft oder wenn das Ereignis auftritt, auf das er wartet.

• Terminated (Dead) - Ein ausführbarer Thread wechselt in den Status "Beendet", wenn er seine Aufgabe abgeschlossen oder auf andere Weise beendet hat.

Thread-Prioritäten

Jeder Java-Thread hat eine Priorität, mit deren Hilfe das Betriebssystem die Reihenfolge bestimmen kann, in der Threads geplant sind.

Java-Thread-Prioritäten liegen im Bereich zwischen MIN_PRIORITY (Konstante 1) und MAX_PRIORITY (Konstante 10). Standardmäßig erhält jeder Thread die Priorität NORM_PRIORITY (eine Konstante von 5).

Threads mit höherer Priorität sind für ein Programm wichtiger und sollten vor Threads mit niedrigerer Priorität Prozessorzeit zugewiesen bekommen. Thread-Prioritäten können jedoch nicht die Reihenfolge garantieren, in der Threads ausgeführt werden, und sind stark plattformabhängig.

Erstellen Sie einen Thread, indem Sie eine ausführbare Schnittstelle implementieren

Wenn Ihre Klasse als Thread ausgeführt werden soll, können Sie dies erreichen, indem Sie a implementieren RunnableSchnittstelle. Sie müssen drei grundlegende Schritte ausführen:

Schritt 1

Als ersten Schritt müssen Sie eine run () -Methode implementieren, die von a bereitgestellt wird RunnableSchnittstelle. Diese Methode bietet einen Einstiegspunkt für den Thread und Sie werden Ihre vollständige Geschäftslogik in diese Methode einfügen. Es folgt eine einfache Syntax der Methode run () -

public void run( )

Schritt 2

In einem zweiten Schritt instanziieren Sie a Thread Objekt mit dem folgenden Konstruktor -

Thread(Runnable threadObj, String threadName);

Wobei threadObj eine Instanz einer Klasse ist, die das implementiertRunnable Schnittstelle und threadName ist der Name des neuen Threads.

Schritt 3

Sobald ein Thread-Objekt erstellt wurde, können Sie es durch Aufrufen starten start()Methode, die einen Aufruf der run () -Methode ausführt. Es folgt eine einfache Syntax der start () -Methode -

void start();

Beispiel

Hier ist ein Beispiel, das einen neuen Thread erstellt und ihn ausführt -

class RunnableDemo implements Runnable {
   private Thread t;
   private String threadName;
   
   RunnableDemo( String name) {
      threadName = name;
      System.out.println("Creating " +  threadName );
   }
   
   public void run() {
      System.out.println("Running " +  threadName );
      try {
         for(int i = 4; i > 0; i--) {
            System.out.println("Thread: " + threadName + ", " + i);
            // Let the thread sleep for a while.
            Thread.sleep(50);
         }
      } catch (InterruptedException e) {
         System.out.println("Thread " +  threadName + " interrupted.");
      }
      System.out.println("Thread " +  threadName + " exiting.");
   }
   
   public void start () {
      System.out.println("Starting " +  threadName );
      if (t == null) {
         t = new Thread (this, threadName);
         t.start ();
      }
   }
}

public class TestThread {

   public static void main(String args[]) {
      RunnableDemo R1 = new RunnableDemo( "Thread-1");
      R1.start();
      
      RunnableDemo R2 = new RunnableDemo( "Thread-2");
      R2.start();
   }   
}

Dies führt zu folgendem Ergebnis:

Ausgabe

Creating Thread-1
Starting Thread-1
Creating Thread-2
Starting Thread-2
Running Thread-1
Thread: Thread-1, 4
Running Thread-2
Thread: Thread-2, 4
Thread: Thread-1, 3
Thread: Thread-2, 3
Thread: Thread-1, 2
Thread: Thread-2, 2
Thread: Thread-1, 1
Thread: Thread-2, 1
Thread Thread-1 exiting.
Thread Thread-2 exiting.

Erstellen Sie einen Thread, indem Sie eine Thread-Klasse erweitern

Die zweite Möglichkeit, einen Thread zu erstellen, besteht darin, eine neue Klasse zu erstellen, die erweitert wird ThreadKlasse mit den folgenden zwei einfachen Schritten. Dieser Ansatz bietet mehr Flexibilität bei der Verarbeitung mehrerer Threads, die mit verfügbaren Methoden in der Thread-Klasse erstellt wurden.

Schritt 1

Sie müssen überschreiben run( )Methode in der Thread-Klasse verfügbar. Diese Methode bietet einen Einstiegspunkt für den Thread und Sie werden Ihre vollständige Geschäftslogik in diese Methode einfügen. Es folgt eine einfache Syntax der run () -Methode -

public void run( )

Schritt 2

Sobald das Thread-Objekt erstellt wurde, können Sie es durch Aufrufen starten start()Methode, die einen Aufruf der run () -Methode ausführt. Es folgt eine einfache Syntax der start () -Methode -

void start( );

Beispiel

Hier ist das vorhergehende Programm umgeschrieben, um den Thread zu erweitern -

class ThreadDemo extends Thread {
   private Thread t;
   private String threadName;
   
   ThreadDemo( String name) {
      threadName = name;
      System.out.println("Creating " +  threadName );
   }
   
   public void run() {
      System.out.println("Running " +  threadName );
      try {
         for(int i = 4; i > 0; i--) {
            System.out.println("Thread: " + threadName + ", " + i);
            // Let the thread sleep for a while.
            Thread.sleep(50);
         }
      } catch (InterruptedException e) {
         System.out.println("Thread " +  threadName + " interrupted.");
      }
      System.out.println("Thread " +  threadName + " exiting.");
   }
   
   public void start () {
      System.out.println("Starting " +  threadName );
      if (t == null) {
         t = new Thread (this, threadName);
         t.start ();
      }
   }
}

public class TestThread {

   public static void main(String args[]) {
      ThreadDemo T1 = new ThreadDemo( "Thread-1");
      T1.start();
      
      ThreadDemo T2 = new ThreadDemo( "Thread-2");
      T2.start();
   }   
}

Dies führt zu folgendem Ergebnis:

Ausgabe

Creating Thread-1
Starting Thread-1
Creating Thread-2
Starting Thread-2
Running Thread-1
Thread: Thread-1, 4
Running Thread-2
Thread: Thread-2, 4
Thread: Thread-1, 3
Thread: Thread-2, 3
Thread: Thread-1, 2
Thread: Thread-2, 2
Thread: Thread-1, 1
Thread: Thread-2, 1
Thread Thread-1 exiting.
Thread Thread-2 exiting.

Thread-Methoden

Im Folgenden finden Sie eine Liste wichtiger Methoden, die in der Thread-Klasse verfügbar sind.

Sr.Nr.	Methode & Beschreibung
1	public void start() Startet den Thread in einem separaten Ausführungspfad und ruft dann die run () -Methode für dieses Thread-Objekt auf.
2	public void run() Wenn dieses Thread-Objekt mithilfe eines separaten ausführbaren Ziels instanziiert wurde, wird die run () -Methode für dieses ausführbare Objekt aufgerufen.
3	public final void setName(String name) Ändert den Namen des Thread-Objekts. Es gibt auch eine getName () -Methode zum Abrufen des Namens.
4	public final void setPriority(int priority) Legt die Priorität dieses Thread-Objekts fest. Die möglichen Werte liegen zwischen 1 und 10.
5	public final void setDaemon(boolean on) Ein Parameter von true bezeichnet diesen Thread als Daemon-Thread.
6	public final void join(long millisec) Der aktuelle Thread ruft diese Methode für einen zweiten Thread auf, wodurch der aktuelle Thread blockiert wird, bis der zweite Thread beendet wird oder die angegebene Anzahl von Millisekunden vergeht.
7	public void interrupt() Unterbricht diesen Thread und führt dazu, dass die Ausführung fortgesetzt wird, wenn er aus irgendeinem Grund blockiert wurde.
8	public final boolean isAlive() Gibt true zurück, wenn der Thread aktiv ist. Dies ist jederzeit möglich, nachdem der Thread gestartet wurde, aber bevor er vollständig ausgeführt wird.

Die vorherigen Methoden werden für ein bestimmtes Thread-Objekt aufgerufen. Die folgenden Methoden in der Thread-Klasse sind statisch. Durch Aufrufen einer der statischen Methoden wird die Operation für den aktuell ausgeführten Thread ausgeführt.

Sr.Nr.	Methode & Beschreibung
1	public static void yield() Bewirkt, dass der aktuell ausgeführte Thread anderen Threads mit derselben Priorität nachgibt, die darauf warten, geplant zu werden.
2	public static void sleep(long millisec) Bewirkt, dass der aktuell ausgeführte Thread mindestens für die angegebene Anzahl von Millisekunden blockiert.
3	public static boolean holdsLock(Object x) Gibt true zurück, wenn der aktuelle Thread die Sperre für das angegebene Objekt enthält.
4	public static Thread currentThread() Gibt einen Verweis auf den aktuell ausgeführten Thread zurück, bei dem es sich um den Thread handelt, der diese Methode aufruft.
5	public static void dumpStack() Druckt den Stack-Trace für den aktuell ausgeführten Thread. Dies ist hilfreich beim Debuggen einer Multithread-Anwendung.

Beispiel

Das folgende ThreadClassDemo-Programm demonstriert einige dieser Methoden der Thread-Klasse. Betrachten Sie eine KlasseDisplayMessage welche implementiert Runnable - -

// File Name : DisplayMessage.java
// Create a thread to implement Runnable

public class DisplayMessage implements Runnable {
   private String message;
   
   public DisplayMessage(String message) {
      this.message = message;
   }
   
   public void run() {
      while(true) {
         System.out.println(message);
      }
   }
}

Es folgt eine weitere Klasse, die die Thread-Klasse erweitert -

// File Name : GuessANumber.java
// Create a thread to extentd Thread

public class GuessANumber extends Thread {
   private int number;
   public GuessANumber(int number) {
      this.number = number;
   }
   
   public void run() {
      int counter = 0;
      int guess = 0;
      do {
         guess = (int) (Math.random() * 100 + 1);
         System.out.println(this.getName() + " guesses " + guess);
         counter++;
      } while(guess != number);
      System.out.println("** Correct!" + this.getName() + "in" + counter + "guesses.**");
   }
}

Es folgt das Hauptprogramm, das die oben definierten Klassen verwendet -

// File Name : ThreadClassDemo.java
public class ThreadClassDemo {

   public static void main(String [] args) {
      Runnable hello = new DisplayMessage("Hello");
      Thread thread1 = new Thread(hello);
      thread1.setDaemon(true);
      thread1.setName("hello");
      System.out.println("Starting hello thread...");
      thread1.start();
      
      Runnable bye = new DisplayMessage("Goodbye");
      Thread thread2 = new Thread(bye);
      thread2.setPriority(Thread.MIN_PRIORITY);
      thread2.setDaemon(true);
      System.out.println("Starting goodbye thread...");
      thread2.start();

      System.out.println("Starting thread3...");
      Thread thread3 = new GuessANumber(27);
      thread3.start();
      try {
         thread3.join();
      } catch (InterruptedException e) {
         System.out.println("Thread interrupted.");
      }
      System.out.println("Starting thread4...");
      Thread thread4 = new GuessANumber(75);
      
      thread4.start();
      System.out.println("main() is ending...");
   }
}

Dies führt zu folgendem Ergebnis. Sie können dieses Beispiel immer wieder versuchen und erhalten jedes Mal ein anderes Ergebnis.

Ausgabe

Starting hello thread...
Starting goodbye thread...
Hello
Hello
Hello
Hello
Hello
Hello
Goodbye
Goodbye
Goodbye
Goodbye
Goodbye
.......

Wichtige Java-Multithreading-Konzepte

Wenn Sie Multithreading in Java programmieren, müssen Sie die folgenden Konzepte sehr praktisch haben:

• Was ist Thread-Synchronisation?

• Umgang mit Interthread-Kommunikation

• Umgang mit Thread Deadlock

• Wichtige Thread-Operationen

Ein appletist ein Java-Programm, das in einem Webbrowser ausgeführt wird. Ein Applet kann eine voll funktionsfähige Java-Anwendung sein, da es über die gesamte Java-API verfügt.

Es gibt einige wichtige Unterschiede zwischen einem Applet und einer eigenständigen Java-Anwendung, einschließlich der folgenden:

• Ein Applet ist eine Java-Klasse, die die Klasse java.applet.Applet erweitert.

• Eine main () -Methode wird für ein Applet nicht aufgerufen, und eine Applet-Klasse definiert main () nicht.

• Applets können in eine HTML-Seite eingebettet werden.

• Wenn ein Benutzer eine HTML-Seite anzeigt, die ein Applet enthält, wird der Code für das Applet auf den Computer des Benutzers heruntergeladen.

• Zum Anzeigen eines Applets ist eine JVM erforderlich. Die JVM kann entweder ein Plug-In des Webbrowsers oder eine separate Laufzeitumgebung sein.

• Die JVM auf dem Computer des Benutzers erstellt eine Instanz der Applet-Klasse und ruft während der Lebensdauer des Applets verschiedene Methoden auf.

• Applets haben strenge Sicherheitsregeln, die vom Webbrowser durchgesetzt werden. Die Sicherheit eines Applets wird häufig als Sandbox-Sicherheit bezeichnet. Dabei wird das Applet mit einem Kind verglichen, das in einer Sandbox spielt, wobei verschiedene Regeln beachtet werden müssen.

• Andere Klassen, die das Applet benötigt, können in einer einzigen Java Archive (JAR) -Datei heruntergeladen werden.

Lebenszyklus eines Applets

Vier Methoden in der Applet-Klasse geben Ihnen das Framework, auf dem Sie ein seriöses Applet erstellen -

• init- Diese Methode ist für jede Initialisierung vorgesehen, die für Ihr Applet erforderlich ist. Es wird aufgerufen, nachdem die param-Tags im Applet-Tag verarbeitet wurden.

• start- Diese Methode wird automatisch aufgerufen, nachdem der Browser die init-Methode aufgerufen hat. Es wird auch aufgerufen, wenn der Benutzer zu der Seite zurückkehrt, die das Applet enthält, nachdem er zu anderen Seiten gewechselt ist.

• stop- Diese Methode wird automatisch aufgerufen, wenn der Benutzer die Seite verlässt, auf der sich das Applet befindet. Es kann daher wiederholt im selben Applet aufgerufen werden.

• destroy- Diese Methode wird nur aufgerufen, wenn der Browser normal heruntergefahren wird. Da Applets auf einer HTML-Seite gespeichert werden sollen, sollten Sie normalerweise keine Ressourcen zurücklassen, nachdem ein Benutzer die Seite verlassen hat, die das Applet enthält.

• paint- Wird unmittelbar nach der start () -Methode aufgerufen und auch immer dann, wenn sich das Applet im Browser neu malen muss. Die paint () -Methode wird tatsächlich von java.awt geerbt.

Ein Applet "Hallo Welt"

Es folgt ein einfaches Applet mit dem Namen HelloWorldApplet.java -

import java.applet.*;
import java.awt.*;

public class HelloWorldApplet extends Applet {
   public void paint (Graphics g) {
      g.drawString ("Hello World", 25, 50);
   }
}

Diese Importanweisungen bringen die Klassen in den Bereich unserer Applet-Klasse -

• java.applet.Applet
• java.awt.Graphics

Ohne diese Importanweisungen würde der Java-Compiler die Klassen Applet und Graphics, auf die sich die Applet-Klasse bezieht, nicht erkennen.

Die Applet-Klasse

Jedes Applet ist eine Erweiterung der Klasse java.applet.Applet . Die Basis-Applet-Klasse bietet Methoden, die eine abgeleitete Applet-Klasse aufrufen kann, um Informationen und Dienste aus dem Browserkontext abzurufen.

Dazu gehören Methoden, die Folgendes tun:

• Applet-Parameter abrufen
• Rufen Sie den Netzwerkspeicherort der HTML-Datei ab, die das Applet enthält
• Rufen Sie den Netzwerkspeicherort des Applet-Klassenverzeichnisses ab
• Drucken Sie eine Statusmeldung im Browser
• Holen Sie sich ein Bild
• Holen Sie sich einen Audioclip
• Spielen Sie einen Audioclip ab
• Ändern Sie die Größe des Applets

Darüber hinaus bietet die Applet-Klasse eine Schnittstelle, über die der Viewer oder Browser Informationen zum Applet abruft und die Ausführung des Applets steuert. Der Betrachter kann -

• Fordern Sie Informationen zum Autor, zur Version und zum Copyright des Applets an
• Fordern Sie eine Beschreibung der vom Applet erkannten Parameter an
• Initialisieren Sie das Applet
• Zerstöre das Applet
• Starten Sie die Ausführung des Applets
• Stoppen Sie die Ausführung des Applets

Die Applet-Klasse bietet Standardimplementierungen für jede dieser Methoden. Diese Implementierungen können bei Bedarf überschrieben werden.

Das Applet "Hallo Welt" ist in seiner jetzigen Form vollständig. Die einzige überschriebene Methode ist die Malmethode.

Applet aufrufen

Ein Applet kann aufgerufen werden, indem Anweisungen in eine HTML-Datei eingebettet und die Datei über einen Applet-Viewer oder einen Java-fähigen Browser angezeigt werden.

Das <applet> -Tag ist die Basis für die Einbettung eines Applets in eine HTML-Datei. Das folgende Beispiel ruft das Applet "Hallo Welt" auf.

<html>
   <title>The Hello, World Applet</title>
   <hr>
   <applet code = "HelloWorldApplet.class" width = "320" height = "120">
      If your browser was Java-enabled, a "Hello, World"
      message would appear here.
   </applet>
   <hr>
</html>

Note- Weitere Informationen zum Aufrufen von Applets aus HTML finden Sie unter HTML-Applet-Tag .

Das Code-Attribut des <applet> -Tags ist erforderlich. Es gibt die auszuführende Applet-Klasse an. Breite und Höhe sind auch erforderlich, um die Anfangsgröße des Panels anzugeben, in dem ein Applet ausgeführt wird. Die Applet-Direktive muss mit einem </ applet> -Tag geschlossen werden.

Wenn ein Applet Parameter akzeptiert, können Werte für die Parameter übergeben werden, indem <param> -Tags zwischen <applet> und </ applet> hinzugefügt werden. Der Browser ignoriert Text und andere Tags zwischen den Applet-Tags.

Nicht Java-fähige Browser verarbeiten <applet> und </ applet> nicht. Daher ist alles, was zwischen den Tags angezeigt wird und nicht mit dem Applet zusammenhängt, in nicht Java-fähigen Browsern sichtbar.

Der Viewer oder Browser sucht am Speicherort des Dokuments nach dem kompilierten Java-Code. Um etwas anderes anzugeben, verwenden Sie das Codebasisattribut des <applet> -Tags wie gezeigt -

<applet codebase = "https://amrood.com/applets" code = "HelloWorldApplet.class"
   width = "320" height = "120">

Wenn sich ein Applet in einem anderen als dem Standardpaket befindet, muss das Haltepaket im Codeattribut mit dem Punkt (.) Angegeben werden, um Paket- / Klassenkomponenten zu trennen. Zum Beispiel -

<applet  = "mypackage.subpackage.TestApplet.class" 
   width = "320" height = "120">

Applet-Parameter abrufen

Das folgende Beispiel zeigt, wie ein Applet auf die im Dokument angegebenen Setup-Parameter reagiert. Dieses Applet zeigt ein Schachbrettmuster aus Schwarz und einer zweiten Farbe an.

Die zweite Farbe und die Größe jedes Quadrats können als Parameter für das Applet im Dokument angegeben werden.

CheckerApplet erhält seine Parameter in der init () -Methode. Es kann auch seine Parameter in der paint () -Methode erhalten. Das Abrufen der Werte und das einmalige Speichern der Einstellungen zu Beginn des Applets anstelle jeder Aktualisierung ist jedoch bequem und effizient.

Der Applet-Viewer oder Browser ruft die init () -Methode jedes von ihm ausgeführten Applets auf. Der Viewer ruft init () unmittelbar nach dem Laden des Applets einmal auf. (Applet.init () wird implementiert, um nichts zu tun.) Überschreiben Sie die Standardimplementierung, um benutzerdefinierten Initialisierungscode einzufügen.

Die Applet.getParameter () -Methode ruft einen Parameter unter Angabe des Parameternamens ab (der Wert eines Parameters ist immer eine Zeichenfolge). Wenn der Wert numerische oder andere Nicht-Zeichendaten sind, muss die Zeichenfolge analysiert werden.

Das Folgende ist ein Skelett von CheckerApplet.java -

import java.applet.*;
import java.awt.*;

public class CheckerApplet extends Applet {
   int squareSize = 50;   // initialized to default size
   public void init() {}
   private void parseSquareSize (String param) {}
   private Color parseColor (String param) {}
   public void paint (Graphics g) {}
}

Hier sind die Methoden init () und private parseSquareSize () von CheckerApplet:

public void init () {
   String squareSizeParam = getParameter ("squareSize");
   parseSquareSize (squareSizeParam);
   
   String colorParam = getParameter ("color");
   Color fg = parseColor (colorParam);
   
   setBackground (Color.black);
   setForeground (fg);
}

private void parseSquareSize (String param) {
   if (param == null) return;
   try {
      squareSize = Integer.parseInt (param);
   } catch (Exception e) {
      // Let default value remain
   }
}

Das Applet ruft parseSquareSize () auf, um den Parameter squareSize zu analysieren. parseSquareSize () ruft die Bibliotheksmethode Integer.parseInt () auf, die eine Zeichenfolge analysiert und eine Ganzzahl zurückgibt. Integer.parseInt () löst eine Ausnahme aus, wenn sein Argument ungültig ist.

Daher fängt parseSquareSize () Ausnahmen ab, anstatt zuzulassen, dass das Applet bei fehlerhafter Eingabe fehlschlägt.

Das Applet ruft parseColor () auf, um den Farbparameter in einen Farbwert zu analysieren. parseColor () führt eine Reihe von Zeichenfolgenvergleichen durch, um den Parameterwert mit dem Namen einer vordefinierten Farbe abzugleichen. Sie müssen diese Methoden implementieren, damit dieses Applet funktioniert.

Angeben von Applet-Parametern

Das folgende Beispiel zeigt eine HTML-Datei mit einem darin eingebetteten CheckerApplet. Die HTML-Datei gibt beide Parameter für das Applet mithilfe des <param> -Tags an.

<html>
   <title>Checkerboard Applet</title>
   <hr>
   <applet code = "CheckerApplet.class" width = "480" height = "320">
      <param name = "color" value = "blue">
      <param name = "squaresize" value = "30">
   </applet>
   <hr>
</html>

Note - Parameternamen unterscheiden nicht zwischen Groß- und Kleinschreibung.

Anwendungskonvertierung in Applets

Es ist einfach, eine grafische Java-Anwendung (dh eine Anwendung, die AWT verwendet und mit dem Java-Programmstarter beginnen kann) in ein Applet zu konvertieren, das Sie in eine Webseite einbetten können.

Im Folgenden finden Sie die spezifischen Schritte zum Konvertieren einer Anwendung in ein Applet.

• Erstellen Sie eine HTML-Seite mit dem entsprechenden Tag, um den Applet-Code zu laden.

• Geben Sie eine Unterklasse der JApplet-Klasse an. Machen Sie diese Klasse öffentlich. Andernfalls kann das Applet nicht geladen werden.

• Beseitigen Sie die Hauptmethode in der Anwendung. Erstellen Sie kein Rahmenfenster für die Anwendung. Ihre Anwendung wird im Browser angezeigt.

• Verschieben Sie einen beliebigen Initialisierungscode vom Frame-Fenster-Konstruktor in die Init-Methode des Applets. Sie müssen das Applet-Objekt nicht explizit erstellen. Der Browser instanziiert es für Sie und ruft die init-Methode auf.

• Entfernen Sie den Aufruf von setSize. Bei Applets erfolgt die Größenbestimmung mit den Parametern width und height in der HTML-Datei.

• Entfernen Sie den Aufruf von setDefaultCloseOperation. Ein Applet kann nicht geschlossen werden. Es wird beendet, wenn der Browser beendet wird.

• Wenn die Anwendung setTitle aufruft, entfernen Sie den Aufruf der Methode. Applets dürfen keine Titelleisten haben. (Sie können die Webseite natürlich auch mit dem HTML-Titel-Tag selbst betiteln.)

• Rufen Sie setVisible (true) nicht auf. Das Applet wird automatisch angezeigt.

Handhabung des Events

Applets erben eine Gruppe von Methoden zur Ereignisbehandlung von der Container-Klasse. Die Container-Klasse definiert mehrere Methoden wie processKeyEvent und processMouseEvent für die Behandlung bestimmter Ereignistypen und anschließend eine Catch-All-Methode namens processEvent.

Um auf ein Ereignis reagieren zu können, muss ein Applet die entsprechende ereignisspezifische Methode überschreiben.

import java.awt.event.MouseListener;
import java.awt.event.MouseEvent;
import java.applet.Applet;
import java.awt.Graphics;

public class ExampleEventHandling extends Applet implements MouseListener {
   StringBuffer strBuffer;

   public void init() {
      addMouseListener(this);
      strBuffer = new StringBuffer();
      addItem("initializing the apple ");
   }

   public void start() {
      addItem("starting the applet ");
   }

   public void stop() {
      addItem("stopping the applet ");
   }

   public void destroy() {
      addItem("unloading the applet");
   }

   void addItem(String word) {
      System.out.println(word);
      strBuffer.append(word);
      repaint();
   }

   public void paint(Graphics g) {
      // Draw a Rectangle around the applet's display area.
      g.drawRect(0, 0, 
      getWidth() - 1,
      getHeight() - 1);

      // display the string inside the rectangle.
      g.drawString(strBuffer.toString(), 10, 20);
   }

   
   public void mouseEntered(MouseEvent event) {
   }
   public void mouseExited(MouseEvent event) {
   }
   public void mousePressed(MouseEvent event) {
   }
   public void mouseReleased(MouseEvent event) {
   }
   public void mouseClicked(MouseEvent event) {
      addItem("mouse clicked! ");
   }
}

Nennen wir dieses Applet nun wie folgt:

<html>
   <title>Event Handling</title>
   <hr>
   <applet code = "ExampleEventHandling.class" 
      width = "300" height = "300">
   </applet>
   <hr>
</html>

Zu Beginn zeigt das Applet "Initialisieren des Applets. Starten des Applets" an. Sobald Sie in das Rechteck klicken, wird auch "Mausklick" angezeigt.

Bilder anzeigen

Ein Applet kann Bilder im Format GIF, JPEG, BMP und anderen anzeigen. Um ein Bild im Applet anzuzeigen, verwenden Sie die drawImage () -Methode in der Klasse java.awt.Graphics.

Das folgende Beispiel zeigt alle Schritte zum Anzeigen von Bildern:

import java.applet.*;
import java.awt.*;
import java.net.*;

public class ImageDemo extends Applet {
   private Image image;
   private AppletContext context;
   
   public void init() {
      context = this.getAppletContext();
      String imageURL = this.getParameter("image");
      if(imageURL == null) {
         imageURL = "java.jpg";
      }
      try {
         URL url = new URL(this.getDocumentBase(), imageURL);
         image = context.getImage(url);
      } catch (MalformedURLException e) {
         e.printStackTrace();
         // Display in browser status bar
         context.showStatus("Could not load image!");
      }
   }
   
   public void paint(Graphics g) {
      context.showStatus("Displaying image");
      g.drawImage(image, 0, 0, 200, 84, null);
      g.drawString("www.javalicense.com", 35, 100);
   }  
}

Nennen wir dieses Applet nun wie folgt:

<html>
   <title>The ImageDemo applet</title>
   <hr>
   <applet code = "ImageDemo.class" width = "300" height = "200">
      <param name = "image" value = "java.jpg">
   </applet>
   <hr>
</html>

Audio abspielen

Ein Applet kann eine Audiodatei abspielen, die von der AudioClip-Schnittstelle im Paket java.applet dargestellt wird. Die AudioClip-Oberfläche verfügt über drei Methoden, darunter:

• public void play() - Spielt den Audioclip von Anfang an einmal ab.

• public void loop() - Bewirkt, dass der Audioclip kontinuierlich wiedergegeben wird.

• public void stop() - Stoppt die Wiedergabe des Audioclips.

Um ein AudioClip-Objekt zu erhalten, müssen Sie die Methode getAudioClip () der Applet-Klasse aufrufen. Die Methode getAudioClip () gibt sofort zurück, unabhängig davon, ob die URL in eine tatsächliche Audiodatei aufgelöst wird oder nicht. Die Audiodatei wird erst heruntergeladen, wenn versucht wird, den Audioclip abzuspielen.

Das folgende Beispiel zeigt alle Schritte zum Abspielen eines Audios -

import java.applet.*;
import java.awt.*;
import java.net.*;

public class AudioDemo extends Applet {
   private AudioClip clip;
   private AppletContext context;
   
   public void init() {
      context = this.getAppletContext();
      String audioURL = this.getParameter("audio");
      if(audioURL == null) {
         audioURL = "default.au";
      }
      try {
         URL url = new URL(this.getDocumentBase(), audioURL);
         clip = context.getAudioClip(url);
      } catch (MalformedURLException e) {
         e.printStackTrace();
         context.showStatus("Could not load audio file!");
      }
   }
   
   public void start() {
      if(clip != null) {
         clip.loop();
      }
   }
   
   public void stop() {
      if(clip != null) {
         clip.stop();
      }
   }
}

Nennen wir dieses Applet nun wie folgt:

<html>
   <title>The ImageDemo applet</title>
   <hr>
   <applet code = "ImageDemo.class" width = "0" height = "0">
      <param name = "audio" value = "test.wav">
   </applet>
   <hr>
</html>

Sie können test.wav auf Ihrem PC verwenden, um das obige Beispiel zu testen.

Die Java-Sprache unterstützt drei Arten von Kommentaren:

Sr.Nr.	Kommentar & Beschreibung
1	/* text */ Der Compiler ignoriert alles von / * bis * /.
2	//text Der Compiler ignoriert alles von // bis zum Ende der Zeile.
3	/** documentation */ Dies ist ein Dokumentationskommentar und wird im Allgemeinen aufgerufen doc comment. DasJDK javadocDas Tool verwendet Dokumentkommentare, wenn automatisch generierte Dokumentationen erstellt werden.

In diesem Kapitel geht es darum, Javadoc zu erklären. Wir werden sehen, wie wir Javadoc verwenden können, um nützliche Dokumentation für Java-Code zu generieren.

Was ist Javadoc?

Javadoc ist ein Tool, das mit JDK geliefert wird und zum Generieren von Java-Codedokumentation im HTML-Format aus Java-Quellcode verwendet wird, für die Dokumentation in einem vordefinierten Format erforderlich ist.

Es folgt ein einfaches Beispiel, in dem die Zeilen in /*….*/ mehrzeilige Java-Kommentare sind. In ähnlicher Weise ist die Zeile, die // vorausgeht, ein einzeiliger Java-Kommentar.

Beispiel

/**
* The HelloWorld program implements an application that
* simply displays "Hello World!" to the standard output.
*
* @author  Zara Ali
* @version 1.0
* @since   2014-03-31 
*/
public class HelloWorld {

   public static void main(String[] args) {
      // Prints Hello, World! on standard output.
      System.out.println("Hello World!");
   }
}

Sie können die erforderlichen HTML-Tags in den Beschreibungsteil aufnehmen. Im folgenden Beispiel wird beispielsweise <h1> .... </ h1> als Überschrift verwendet, und <p> wurde zum Erstellen von Absatzumbrüchen verwendet.

Beispiel

/**
* <h1>Hello, World!</h1>
* The HelloWorld program implements an application that
* simply displays "Hello World!" to the standard output.
* <p>
* Giving proper comments in your program makes it more
* user friendly and it is assumed as a high quality code.
* 
*
* @author  Zara Ali
* @version 1.0
* @since   2014-03-31 
*/
public class HelloWorld {

   public static void main(String[] args) {
      // Prints Hello, World! on standard output.
      System.out.println("Hello World!");
   }
}

Die Javadoc-Tags

Das Javadoc-Tool erkennt die folgenden Tags:

Etikett	Beschreibung	Syntax
@Autor	Fügt den Autor einer Klasse hinzu.	@author name-text
{@Code}	Zeigt Text in Codeschrift an, ohne den Text als HTML-Markup oder verschachtelte Javadoc-Tags zu interpretieren.	{@code text}
{@docRoot}	Stellt den relativen Pfad zum Stammverzeichnis des generierten Dokuments von einer generierten Seite dar.	{@docRoot}
@deprecated	Fügt einen Kommentar hinzu, der angibt, dass diese API nicht mehr verwendet werden soll.	@deprecated veralteter Text
@Ausnahme	Fügt a hinzu Throws Unterüberschrift der generierten Dokumentation mit dem Klassennamen und dem Beschreibungstext.	@exception Klassenname Beschreibung
{@inheritDoc}	Erbt einen Kommentar von der nearest vererbbare Klasse oder implementierbare Schnittstelle.	Erbt einen Kommentar aus der unmittelbaren Oberklasse.
{@Verknüpfung}	Fügt einen Inline-Link mit der sichtbaren Textbezeichnung ein, der auf die Dokumentation für das angegebene Paket, die Klasse oder den Mitgliedsnamen einer referenzierten Klasse verweist.	{@link package.class # member label}
{@linkplain}	Identisch mit {@link}, außer dass die Beschriftung des Links im Klartext als Code-Schrift angezeigt wird.	{@linkplain package.class # member label}
@param	Fügt dem Abschnitt "Parameter" einen Parameter mit dem angegebenen Parameternamen gefolgt von der angegebenen Beschreibung hinzu.	@param Parametername Beschreibung
@Rückkehr	Fügt einen Abschnitt "Rückgabe" mit dem Beschreibungstext hinzu.	@ Rückgabe Beschreibung
@sehen	Fügt eine Überschrift "Siehe auch" mit einem Link oder Texteintrag hinzu, der auf eine Referenz verweist.	@ Siehe Referenz
@serial	Wird im Dokumentkommentar für ein standardmäßiges serialisierbares Feld verwendet.	@serielle Feldbeschreibung | include | ausschließen
@serialData	Dokumentiert die Daten, die mit den Methoden writeObject () oder writeExternal () geschrieben wurden.	@serialData Datenbeschreibung
@serialField	Dokumentiert eine ObjectStreamField-Komponente.	@serialField Feldname Feldtyp Feldbeschreibung
@schon seit	Fügt der generierten Dokumentation eine Überschrift "Seit" mit dem angegebenen Seit-Text hinzu.	@ seit Veröffentlichung
@ wirft	Die Tags @throws und @exception sind Synonyme.	@throws Klassenname Beschreibung
{@Wert}	Wenn {@value} im Dokumentkommentar eines statischen Felds verwendet wird, wird der Wert dieser Konstante angezeigt.	{@value package.class # field}
@Ausführung	Fügt den generierten Dokumenten eine Unterüberschrift "Version" mit dem angegebenen Versionstext hinzu, wenn die Option -version verwendet wird.	@version version-text

Beispiel

Das folgende Programm verwendet einige der wichtigen Tags, die für Dokumentationskommentare verfügbar sind. Sie können je nach Ihren Anforderungen andere Tags verwenden.

Die Dokumentation zur AddNum-Klasse wird in der HTML-Datei AddNum.html erstellt, gleichzeitig wird jedoch auch eine Master-Datei mit dem Namen index.html erstellt.

import java.io.*;

/**
* <h1>Add Two Numbers!</h1>
* The AddNum program implements an application that
* simply adds two given integer numbers and Prints
* the output on the screen.
* <p>
* <b>Note:</b> Giving proper comments in your program makes it more
* user friendly and it is assumed as a high quality code.
*
* @author  Zara Ali
* @version 1.0
* @since   2014-03-31
*/
public class AddNum {
   /**
   * This method is used to add two integers. This is
   * a the simplest form of a class method, just to
   * show the usage of various javadoc Tags.
   * @param numA This is the first paramter to addNum method
   * @param numB  This is the second parameter to addNum method
   * @return int This returns sum of numA and numB.
   */
   public int addNum(int numA, int numB) {
      return numA + numB;
   }

   /**
   * This is the main method which makes use of addNum method.
   * @param args Unused.
   * @return Nothing.
   * @exception IOException On input error.
   * @see IOException
   */

   public static void main(String args[]) throws IOException {
      AddNum obj = new AddNum();
      int sum = obj.addNum(10, 20);

      System.out.println("Sum of 10 and 20 is :" + sum);
   }
}

Verarbeiten Sie nun die obige Datei AddNum.java mit dem Dienstprogramm javadoc wie folgt:

$ javadoc AddNum.java
Loading source file AddNum.java...
Constructing Javadoc information...
Standard Doclet version 1.7.0_51
Building tree for all the packages and classes...
Generating /AddNum.html...
AddNum.java:36: warning - @return tag cannot be used in method with void return type.
Generating /package-frame.html...
Generating /package-summary.html...
Generating /package-tree.html...
Generating /constant-values.html...
Building index for all the packages and classes...
Generating /overview-tree.html...
Generating /index-all.html...
Generating /deprecated-list.html...
Building index for all classes...
Generating /allclasses-frame.html...
Generating /allclasses-noframe.html...
Generating /index.html...
Generating /help-doc.html...
1 warning
$

Sie können die gesamte generierte Dokumentation hier überprüfen - AddNum . Wenn Sie JDK 1.7 verwenden, generiert javadoc kein großartiges Ergebnisstylesheet.cssWir empfehlen daher, das Standard-Stylesheet von herunterzuladen und zu verwenden https://docs.oracle.com/javase/7/docs/api/stylesheet.css