Bevor wir Java-Klassen und -Objekte verstehen, führen wir kurz die objektorientierte Programmierung ein. Beim Programmieren handelt es sich um die Gestaltung von Programmen durch Objekte. Das Objekt stellt eine Entität dar und die Entität kann eindeutig identifiziert werden.
Java als objektorientierte Sprache. Folgende Grundkonzepte werden unterstützt:
Polymorphismus
erben
Verkapselung
Abstrakt
Art
Objekt
Beispiel
Verfahren
Nachrichtenanalyse
In diesem Abschnitt konzentrieren wir uns auf die Konzepte von Objekten und Klassen.
Objekt : Ein Objekt ist eine Instanz einer Klasse und hat Status und Verhalten. Zu seinem Status gehören beispielsweise: Farbe, Name und Rasse; zu seinen Verhaltensweisen gehören: Schwanzwedeln, Bellen, Fressen usw.
Klasse : Eine Klasse ist eine Vorlage, die das Verhalten und den Status einer Objektklasse beschreibt.
Schauen wir uns nun genauer an, was ein Objekt ist. Wenn Sie die reale Welt um Sie herum betrachten, werden Sie feststellen, dass sich um Sie herum viele Objekte befinden, wie zum Beispiel Autos, Hunde, Menschen usw. Alle diese Objekte haben ihren eigenen Zustand und ihr eigenes Verhalten.
Nehmen wir als Beispiel einen Hund. Zu seinem Status gehören: Name, Rasse und Farbe, und zu seinen Verhaltensweisen gehören: Bellen, Schwanzwedeln und Laufen.
Vergleicht man reale Objekte und Softwareobjekte, sind sie sich sehr ähnlich.
Softwareobjekte haben auch einen Zustand und ein Verhalten. Der Zustand eines Softwareobjekts ist sein Attribut, und sein Verhalten wird durch Methoden widergespiegelt.
In der Softwareentwicklung wirken sich Methoden auf Änderungen im internen Zustand von Objekten aus, und auch gegenseitige Aufrufe zwischen Objekten werden durch Methoden bewerkstelligt.
Klassen können als Vorlagen zum Erstellen von Java-Objekten betrachtet werden.
Lassen Sie uns die Definition von Klassen in Java anhand der folgenden einfachen Klasse verstehen:
öffentliche Klasse Hund{
Schnurrasse;
int Alter;
Saitenfarbe;
void belling(){
}
void hungrig(){
}
void Sleeping(){
}
}Eine Klasse kann Variablen der folgenden Typen enthalten:
Lokale Variablen : Variablen, die in Methoden, Konstruktoren oder Anweisungsblöcken definiert sind, werden lokale Variablen genannt. Die Variablendeklaration und -initialisierung erfolgt alle in Methoden. Nach Beendigung der Methode werden die Variablen automatisch zerstört.
Mitgliedsvariablen : Mitgliedsvariablen sind Variablen, die in der Klasse und außerhalb des Methodenkörpers definiert sind. Solche Variablen werden beim Erstellen des Objekts instanziiert. Auf Mitgliedsvariablen kann über Klassenmethoden, Konstruktoren und klassenspezifische Anweisungsblöcke zugegriffen werden.
Klassenvariablen : Klassenvariablen werden auch in der Klasse außerhalb des Methodenkörpers deklariert, müssen jedoch als statischer Typ deklariert werden.
Eine Klasse kann mehrere Methoden haben: barking() , hungry() und sleeping() sind alles Methoden der Dog-Klasse.
Jede Klasse verfügt über Konstruktormethoden. Wenn für eine Klasse kein Konstruktor explizit definiert ist, stellt der Java-Compiler einen Standardkonstruktor für die Klasse bereit.
Beim Erstellen eines Objekts muss mindestens eine Konstruktormethode aufgerufen werden. Der Name des Konstruktors muss mit dem der Klasse identisch sein. Eine Klasse kann mehrere Konstruktoren haben.
Hier ist ein Beispielkonstruktor:
öffentliche Klasse Welpe{
publicPuppy(){
}
public Puppy(String name){
// Dieser Konstruktor hat nur einen Parameter: Name
}
} Objekte werden basierend auf Klassen erstellt. Verwenden Sie in Java das Schlüsselwort new um ein neues Objekt zu erstellen. Das Erstellen eines Objekts erfordert die folgenden drei Schritte:
Deklaration : Deklarieren Sie ein Objekt, einschließlich Objektname und Objekttyp.
Instanziierung : Verwenden Sie das Schlüsselwort new um ein Objekt zu erstellen.
Initialisierung : Wenn Sie zum Erstellen eines Objekts new verwenden, wird die Konstruktormethode aufgerufen, um das Objekt zu initialisieren.
Hier ist ein Beispiel für die Erstellung eines Objekts:
öffentliche Klasse Welpe{
public Puppy(String name){
//Dieser Konstruktor hat nur einen Parameter: Name
System.out.println("Welpenname ist:" + Name);
}
public static void main(String []args){
//Die folgende Anweisung erstellt ein Puppy-Objekt Puppy myPuppy = new Puppy( "tommy" );
}
}Kompilieren Sie das obige Programm und führen Sie es aus. Die folgenden Ergebnisse werden gedruckt:
Der Name des Welpen ist :tommyGreifen Sie über das erstellte Objekt wie folgt auf Mitgliedsvariablen und Mitgliedsmethoden zu:
/* Objekt instanziieren */
ObjectReference = new Constructor();
/* Auf die Variablen zugreifen */
ObjectReference.variableName;
/* Zugriffsmethoden in der Klasse */
ObjectReference.MethodName();Das folgende Beispiel zeigt, wie auf Instanzvariablen zugegriffen und Mitgliedsmethoden aufgerufen wird:
öffentliche Klasse Welpe{
int PuppyAge;
public Puppy(String name){
// Dieser Konstruktor hat nur einen Parameter: Name
System.out.println("Übergebener Name ist:" + Name);
}
public void setAge( int age ){
PuppyAge = Alter;
}
public int getAge( ){
System.out.println("Das Alter des Welpen ist:" + PuppyAge);
return PuppyAge;
}
public static void main(String []args){
/* Objekt erstellen */
Welpe myPuppy = neuer Welpe( „tommy“ );
/* Alter durch Methoden festlegen */
myPuppy.setAge(2);
/* Rufen Sie eine andere Methode auf, um das Alter zu ermitteln */
myPuppy.getAge( );
/*Sie können auch wie folgt auf Mitgliedsvariablen zugreifen */
System.out.println("Variablenwert:" + myPuppy.puppyAge);
}
}Das Kompilieren und Ausführen des obigen Programms führt zu folgenden Ergebnissen:
Der übergebene Name ist :tommy
Das Alter des Welpen beträgt: 2
Variablenwert:2 Im letzten Teil dieses Abschnitts erfahren Sie mehr über die Deklarationsregeln für Quelldateien. Achten Sie besonders auf diese Regeln, wenn Sie mehrere Klassen in einer Quelldatei definieren und wenn import und package vorhanden sind.
In einer Quelldatei kann es nur eine public Klasse geben
Eine Quelldatei kann mehrere nicht public Klassen haben
Der Name der Quelldatei sollte mit dem Klassennamen der public Klasse übereinstimmen. Beispiel: Der Klassenname der public Klasse in der Quelldatei lautet Employee , dann sollte die Quelldatei Employee.java heißen.
Wenn eine Klasse in einem Paket definiert ist, sollte die package in der ersten Zeile der Quelldatei stehen.
Wenn die Quelldatei eine import enthält, sollte diese zwischen der package und der Klassendefinition platziert werden. Wenn keine package vorhanden ist, sollte die import an erster Stelle in der Quelldatei stehen.
Die import und package gelten für alle in der Quelldatei definierten Klassen. In derselben Quelldatei können unterschiedliche Paketdeklarationen nicht für verschiedene Klassen angegeben werden.
Klassen haben mehrere Zugriffsebenen und sind auch in verschiedene Typen unterteilt: abstrakte Klassen, final Klassen usw. Diese werden im Kapitel Zugangskontrolle vorgestellt.
Zusätzlich zu den oben genannten Typen gibt es in Java auch einige spezielle Klassen, wie zum Beispiel innere Klassen und anonyme Klassen.
Pakete werden hauptsächlich zur Klassifizierung von Klassen und Schnittstellen verwendet. Bei der Entwicklung von Java-Programmen schreiben Sie möglicherweise Hunderte oder Tausende von Klassen. Daher ist es erforderlich, Klassen und Schnittstellen zu klassifizieren.
Wenn in Java ein vollständiger qualifizierter Name angegeben wird, einschließlich des Paketnamens und des Klassennamens, kann der Java-Compiler den Quellcode oder die Klasse leicht finden. Die Import Anweisung wird verwendet, um einen sinnvollen Pfad bereitzustellen, damit der Compiler eine bestimmte Klasse finden kann.
Die folgende Befehlszeile weist den Compiler beispielsweise an, alle Klassen im Pfad java_installation/java/io zu laden
java.io.* importieren;In diesem Beispiel erstellen wir zwei Klassen: Employee und EmployeeTest.
Öffnen Sie zunächst einen Texteditor und fügen Sie den folgenden Code ein. Beachten Sie, dass die Datei als Employee.java gespeichert wird.
Die Employee-Klasse verfügt über vier Mitgliedsvariablen: Name, Alter, Bezeichnung und Gehalt. Die Klasse deklariert explizit eine Konstruktormethode mit nur einem Parameter.
java.io.* importieren;
öffentliche Klasse Mitarbeiter{
Stringname;
int Alter;
String-Bezeichnung;
doppeltes Gehalt;
// Konstruktor der Employee-Klasse public Employee(String name){
this.name = Name;
}
//Legen Sie den Wert des Alters fest public void empAge(int empAge){
Alter = empAge;
}
/*Legen Sie den Wert der Bezeichnung fest*/
public void empDesignation(String empDesig){
Bezeichnung = empDesig;
}
/*Gehaltswert festlegen*/
öffentliche Annullierung empSalary(double empSalary){
Gehalt = empSalary;
}
/* Informationen drucken */
public void printEmployee(){
System.out.println("Name:"+ name );
System.out.println("Alter:" + Alter);
System.out.println("Bezeichnung:" + Bezeichnung );
System.out.println("Gehalt:" + Gehalt);
}
} Die Programmausführung beginnt mit der main . Um dieses Programm auszuführen, muss die main eingebunden und ein Instanzobjekt erstellt werden.
Unten ist die EmployeeTest-Klasse angegeben, die zwei Instanzen der Employee-Klasse instanziiert und Methoden aufruft, um die Werte von Variablen festzulegen.
Speichern Sie den folgenden Code in der Datei EmployeeTest.java.
java.io.* importieren;
öffentliche Klasse EmployeeTest{
public static void main(String args[]){
/* Erstelle zwei Objekte mit dem Konstruktor */
Mitarbeiter empOne = neuer Mitarbeiter("James Smith");
Mitarbeiter empTwo = neuer Mitarbeiter("Mary Anne");
// Rufen Sie die Mitgliedsmethoden dieser beiden Objekte auf 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 diese beiden Dateien und führen Sie die EmployeeTest-Klasse aus. Sie können die folgenden Ergebnisse sehen:
C:>javacEmployee.java
C :> vi EmployeeTest.java
C:>javacEmployeeTest.java
C:>javaEmployeeTest
Name: James Smith
Alter:26
Bezeichnung:Senior Software Engineer
Gehalt: 1000,0
Name:Mary Anne
Alter:21
Bezeichnung: Softwareentwickler
Gehalt: 500,0