Java-Objekte und Klassen

Als objektorientierte Programmiersprache unterstützt Java die folgenden grundlegenden Konzepte:

1, Klasse：

  • Ein Bauplan, der Objekte definiert, einschließlich Attributen und Methoden.
  • Beispiel:public class Car { ... }

2. Objekt：

  • Eine Instanz einer Klasse, die Zustand und Verhalten besitzt.
  • Beispiel:Car myCar = new Car();

3. Vererbung：

  • Eine Klasse kann die Attribute und Methoden einer anderen Klasse erben.
  • Beispiel:public class Dog extends Animal { ... }

4. Kapselung：

  • Machen Sie den Zustand des Objekts (Felder) privat und greifen Sie über öffentliche Methoden darauf zu.
  • Beispiel:
    private String name; 
public String getName() { return name; }

5. Polymorphismus：

  • Objekte können in mehreren Formen auftreten, hauptsächlich umgesetzt durch Methodenüberladung und Methodenüberschreibung.
  • Beispiel:
    • Methodenüberladung:public int add(int a, int b) { ... }undpublic double add(double a, double b) { ... }
    • Methodenüberschreibung:@Override public void makeSound() { System.out.println("Meow"); }

6. Abstraktion：

  • Verwenden Sie abstrakte Klassen und Schnittstellen, um Methoden zu definieren, die implementiert werden müssen, ohne konkrete Implementierungen bereitzustellen.
  • Beispiel:
    • Abstrakte Klasse:public abstract class Shape { abstract void draw(); }
    • Schnittstelle:public interface Animal { void eat(); }

7. Schnittstelle：

  • Definiert Methoden, die eine Klasse implementieren muss, und unterstützt Mehrfachvererbung.
  • Beispiel:public interface Drivable { void drive(); }

8. Methode：

  • Definiert das Verhalten einer Klasse; in einer Klasse enthaltene Funktionen.
  • Beispiel:public void displayInfo() { System.out.println("Info"); }

9. Methodenüberladung：

  • Dieselbe Klasse kann mehrere Methoden mit demselben Namen, aber unterschiedlichen Parametern haben.
  • Beispiel:
    public class MathUtils {
    public int add(int a, int b) {
        return a + b;
    }

    public double add(double a, double b) {
        return a + b;
    }
}

In diesem Abschnitt konzentrieren wir uns auf die Konzepte von Objekten und Klassen.

  • Objekt: Ein Objekt ist eine Instanz einer Klasse (bei einem Objekt geht es nicht um die Suche nach einer Freundin), und es hat Zustand und Verhalten.
  • Klasse: Eine Klasse ist eine Vorlage, die das Verhalten und den Zustand eines Objekttyps beschreibt.

In der folgenden AbbildungJunge、MädchenistKlasse, und jede konkrete Person ist einObjekt：

In der folgenden AbbildungAutoistKlasse, und jedes konkrete Auto ist einAutoKlassen-Objekt, und das Objekt enthält die Farbe, Marke, den Namen usw. des Autos.

Objekte in Java

Lass uns nun ein tieferes Verständnis dafür gewinnen, was ein Objekt ist. Schau dich in der realen Welt um; du wirst viele Objekte um dich herum finden, wie Autos, Hunde, Menschen und so weiter. All diese Objekte haben ihren eigenen Zustand und ihr eigenes Verhalten.

Nimm einen Hund als Beispiel: Sein Zustand umfasst Name, Rasse und Farbe, und sein Verhalten umfasst Bellen, Schwanzwedeln und Laufen.

Vergleicht man Objekte der realen Welt mit Softwareobjekten, sind sie sich sehr ähnlich.

Auch Softwareobjekte haben Zustand und Verhalten. Der Zustand eines Softwareobjekts sind seine Attribute, und sein Verhalten zeigt sich durch Methoden.

In der Softwareentwicklung wirken Methoden auf Änderungen des internen Zustands von Objekten, und der gegenseitige Aufruf von Objekten erfolgt ebenfalls durch Methoden.

Klassen in Java

Eine Klasse kann als Vorlage zum Erstellen von Java-Objekten angesehen werden.

Erstelle eine einfache Klasse wie in der obigen Abbildung gezeigt, um die Definition einer Klasse in Java zu verstehen:

public class Dog { String breed; int size; String colour; int age; void eat() { } void run() { } void sleep(){ } void name(){ } }

Eine Klasse kann die folgenden Arten von Variablen enthalten:

  • Lokale Variablen: Variablen, die in Methoden, Konstruktoren oder Anweisungsblöcken definiert sind, werden als lokale Variablen bezeichnet. Die Deklaration und Initialisierung der Variablen erfolgen beide in der Methode, und wenn die Methode endet, wird die Variable automatisch zerstört.
  • Mitgliedsvariablen: Mitgliedsvariablen sind Variablen, die in einer Klasse, aber außerhalb der Methodenkörper definiert sind. Solche Variablen werden instanziiert, wenn ein Objekt erstellt wird. Auf Mitgliedsvariablen kann durch Methoden, Konstruktoren und Anweisungsblöcke einer bestimmten Klasse zugegriffen werden.
  • Klassenvariablen: Klassenvariablen werden ebenfalls in einer Klasse, außerhalb von Methodenkörpern deklariert, aber sie müssen als static deklariert werden.

Eine Klasse kann mehrere Methoden haben. Im obigen Beispiel sind eat(), run(), sleep() und name() alle Methoden der Klasse Dog.

Konstruktormethoden

Jede Klasse hat einen Konstruktor. Wenn für eine Klasse kein Konstruktor explizit definiert wird, stellt der Java-Compiler einen Standardkonstruktor für diese Klasse bereit.

Beim Erstellen eines Objekts muss mindestens ein Konstruktor aufgerufen werden. Der Name des Konstruktors muss mit dem Klassennamen übereinstimmen, und eine Klasse kann mehrere Konstruktoren haben.

Nachfolgend ist ein Beispiel für einen Konstruktor:

public class Puppy{ public Puppy(){ } public Puppy(String name){ //Dieser Konstruktor hat nur einen Parameter: name } }

Objekte erstellen

Objekte werden aus Klassen erstellt. In Java wird das Schlüsselwort new verwendet, um ein neues Objekt zu erstellen. Das Erstellen eines Objekts erfordert die folgenden drei Schritte:

  • Deklaration: Deklariere ein Objekt, einschließlich des Objektnamens und des Objekttyps.
  • Instanziierung: Verwende das Schlüsselwort new, um ein Objekt zu erstellen.
  • Initialisierung: Wenn ein Objekt mit new erstellt wird, wird der Konstruktor aufgerufen, um das Objekt zu initialisieren.

Nachfolgend ist ein Beispiel für das Erstellen eines Objekts:

public class Puppy{ public Puppy(String name){ //Dieser Konstruktor hat nur einen Parameter: name System.out.println("Der Name des Welpen ist:" + name ); } public static void main(String[] args){ //Die folgende Anweisung erstellt ein Puppy-Objekt Puppy myPuppy = new Puppy( "tommy" ); } }

Kompilieren und führen Sie das obige Programm aus, und es wird das folgende Ergebnis ausgeben:

小狗的名字是 : tommy

Zugriff auf Instanzvariablen und Methoden

Greifen Sie über das erstellte Objekt, wie unten gezeigt, auf Membervariablen und Membermethoden zu:

/*Objekt instanziieren*/ Object referenceVariable = new Konstruktor(); /*Zugriff auf Variablen in der Klasse*/ referenceVariable.variableName; /*Zugriff auf Methoden in der Klasse*/ referenceVariable.methodName();

Wenn Sie eine Variable mit dem Typ Object deklarieren, können Sie zur Kompilierzeit nur auf die Methoden und Eigenschaften der Klasse Object zugreifen, aber zur Laufzeit können Sie sie in einen spezifischen Typ umwandeln, um eine Typkonvertierung durchzuführen, sodass Sie auf die Methoden und Eigenschaften dieses spezifischen Typs zugreifen können.

Beispiel

Das folgende Beispiel zeigt, wie Sie auf Instanzvariablen zugreifen und Membermethoden aufrufen:

Code der Datei Puppy.java:

public class Puppy { private int age; private String name; //Konstruktor public Puppy(String name) { this.name = name; System.out.println("Der Name des Welpen ist:" + name); } //Wert von age festlegen public void setAge(int age) { this.age = age; } //Wert von age abrufen public int getAge() { return age; } //Wert von name abrufen public String getName() { return name; } //Main-Methode public static void main(String[] args) { //Ein Objekt erstellen Puppy myPuppy = new Puppy("Tommy"); //Alter über eine Methode festlegen myPuppy.setAge(2); //Eine andere Methode aufrufen, um das Alter abzurufen int age = myPuppy.getAge(); System.out.println("Das Alter des Welpen ist:" + age); //Sie können auch direkt auf Mitgliedsvariablen zugreifen (über Getter-Methoden) System.out.println("Variablenwert:" + myPuppy.getAge()); } }

Kompilieren und führen Sie das obige Programm aus, wodurch das folgende Ergebnis entsteht:

小狗的名字是 : tommy
小狗的年龄为 : 2
变量值 : 2

Deklarationsregeln für Quelldateien

Im letzten Teil dieses Abschnitts lernen wir die Deklarationsregeln für Quelldateien kennen. Wenn mehrere Klassen in einer Quelldatei definiert sind und außerdem import-Anweisungen und package-Anweisungen vorhanden sind, sollte diesen Regeln besondere Aufmerksamkeit geschenkt werden.

  • Eine Quelldatei kann nur eine öffentliche Klasse enthalten
  • Eine Quelldatei kann mehrere nicht-öffentliche Klassen enthalten
  • Der Name der Quelldatei sollte mit dem Klassennamen der öffentlichen Klasse übereinstimmen. Wenn die öffentliche Klasse in der Quelldatei beispielsweise Employee heißt, dann sollte die Quelldatei Employee.java heißen.
  • Wenn eine Klasse in einem Paket definiert ist, dann sollte die package-Anweisung die erste Zeile der Quelldatei sein.
  • Wenn eine Quelldatei import-Anweisungen enthält, sollten diese zwischen der package-Anweisung und der Klassendefinition stehen. Wenn es keine package-Anweisung gibt, sollten die import-Anweisungen ganz am Anfang der Quelldatei stehen.
  • Die import-Anweisungen und die package-Anweisung gelten für alle in der Quelldatei definierten Klassen. In derselben Quelldatei können Sie verschiedenen Klassen keine unterschiedlichen package-Deklarationen geben.

Klassen haben mehrere Zugriffsebenen, und Klassen werden auch in verschiedene Typen unterteilt: abstrakte Klassen, finale Klassen und so weiter. Diese werden im Kapitel zur Zugriffskontrolle vorgestellt.

Zusätzlich zu den oben genannten Typen gibt es in Java auch einige spezielle Klassen, wie zum Beispiel:Innere Klassen、Anonyme Klassen。

Java-Pakete

Pakete werden hauptsächlich verwendet, um Klassen und Schnittstellen zu kategorisieren. Bei der Entwicklung von Java-Programmen schreiben Sie möglicherweise Hunderte oder Tausende von Klassen, daher ist es notwendig, Klassen und Schnittstellen zu kategorisieren.

import-Anweisungen

In Java kann der Java-Compiler, wenn ein vollständig qualifizierter Name angegeben wird, einschließlich des Paketnamens und des Klassennamens, den Quellcode oder die Klasse leicht finden. Die import-Anweisung wird verwendet, um einen geeigneten Pfad bereitzustellen, damit der Compiler eine bestimmte Klasse finden kann.

Beispielsweise weist die folgende Befehlszeile den Compiler an, alle Klassen unter dem Pfad java_installation/java/io zu laden.

import java.io.*;

Ein einfaches Beispiel

In diesem Beispiel erstellen wir zwei Klassen:EmployeeundEmployeeTest。

Öffnen Sie zuerst den Code-Editor, fügen Sie den folgenden Code ein und speichern Sie die Datei alsEmployee.java。

Die Klasse Employee hat vier Mitgliedsvariablen: name, age, designation und salary. Diese Klasse deklariert explizit eine Konstruktormethode, die nur einen Parameter hat.

Code der Datei Employee.java:

import java.io.*; public class Employee { private String name; private int age; private String designation; private double salary; //Konstruktor der Klasse Employee public Employee(String name) { this.name = name; } //Setzen Sie den Wert von age public void setAge(int age) { this.age = age; } //Ruft den Wert von age ab public int getAge() { return age; } //Setzt den Wert von designation public void setDesignation(String designation) { this.designation = designation; } //Ruft den Wert von designation ab public String getDesignation() { return designation; } //Setzt den Wert von salary public void setSalary(double salary) { this.salary = salary; } //Ruft den Wert von salary ab public double getSalary() { return salary; } //Informationen ausgeben public void printEmployee() { System.out.println(this); } //Überschreiben Sie die toString-Methode @Override public String toString() { return "Name:" + name + "\n" + "Alter:" + age + "\n" + "Position:" + designation + "\n" + "Gehalt:" + salary; } }

Java-Programme beginnen die Ausführung immer bei dermain-Methode. Um dieses Programm auszuführen, müssen Sie die main-Methode einbinden und ein Instanzobjekt erstellen.

Nachfolgend ist die Klasse EmployeeTest, die zwei Instanzen der Klasse Employee instanziiert und Methoden aufruft, um Variablenwerte festzulegen.

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

Code der Datei EmployeeTest.java:

import java.io.*; public class EmployeeTest { public static void main(String[] args) { //Verwenden Sie den Konstruktor, um zwei Objekte zu erstellen. Employee empOne = new Employee("EXAMPLE1"); Employee empTwo = new Employee("EXAMPLE2"); //Rufen Sie die Member-Methoden dieser beiden Objekte auf empOne.setAge(26); empOne.setDesignation("Senior-Programmierer"); empOne.setSalary(1000); empOne.printEmployee(); empTwo.setAge(21); empTwo.setDesignation("Programmieranfänger"); empTwo.setSalary(500); empTwo.printEmployee(); } }

Kompilieren Sie diese beiden Dateien und führen Sie die Klasse EmployeeTest aus, dann können Sie das folgende Ergebnis sehen:

$ javac EmployeeTest.java Employee.java
$ java EmployeeTest 
名字:EXAMPLE1
年龄:26
职位:高级程序员
薪水:1000.0
名字:EXAMPLE2
年龄:21
职位:Example程序员
薪水:500.0
Weitere Erweiterungen