Java-Methoden und Grundlagen der objektorientierten Programmierung

Einführung

Dieses Lab verbessert Ihre Java - Fähigkeiten, indem es Methoden und die Grundlagen der objektorientierten Programmierung (OOP) einführt. Diese Konzepte sind unerlässlich für das Schreiben von gut strukturiertem, wiederverwendbarem und effizientem Code. Wir werden folgende Themen behandeln:

1. Das Erstellen und Verwenden von Methoden zur Organisation des Codes und zur Förderung der Wiederverwendbarkeit.
2. Das Verständnis der Kernideen hinter Klassen und Objekten.
3. Das Implementieren einer einfachen Klasse, die Methoden und Attribute enthält.

Am Ende dieses Labs können Sie Java - Programme schreiben, die Methoden nutzen, um komplexe Probleme in kleinere, besser handhabbare Segmente zu unterteilen. Sie werden auch verstehen, wie die objektorientierte Programmierung in Java funktioniert, eine entscheidende Fähigkeit für das Bauen größerer und komplexerer Anwendungen. Wenn diese Konzepte zunächst kompliziert erscheinen, machen Sie sich keine Sorgen - wir werden sie Schritt für Schritt angehen, und am Ende des Labs werden Sie verstehen, wie diese Ideen zu einem organisierten und leistungsstarken Code beitragen.

Lassen Sie uns beginnen!

Methoden verstehen und erstellen

Methoden sind im Wesentlichen kleine Programme innerhalb Ihres Hauptprogramms. Sie helfen Ihnen, Ihren Code zu organisieren, seine Lesbarkeit zu verbessern und die Wiederverwendung von Code zu ermöglichen, ohne denselben Code wiederholt schreiben zu müssen. Betrachten Sie Methoden als spezialisierte Werkzeuge in einem Werkzeugkasten – jedes für einen bestimmten Zweck entwickelt.

1. Öffnen Sie zunächst die Datei MethodDemo.java in der WebIDE. Sie sollten diesen Startcode sehen:

   public class MethodDemo {
       public static void main(String[] args) {
           System.out.println("Welcome to the Method Demo!");
   
           // TODO: Call methods here
       }
   
       // TODO: Add methods here
   }

   Dies ist die grundlegende Struktur unseres Java-Programms. Die main-Methode ist der Einstiegspunkt, an dem die Ausführung unseres Programms beginnt.

2. Erstellen wir nun unsere erste Methode. Wir erstellen eine einfache Methode, die eine Begrüßung ausgibt. Fügen Sie diese Methode außerhalb und nach der main-Methode auf Klassenebene hinzu:

   public class MethodDemo {
       public static void main(String[] args) {
           System.out.println("Welcome to the Method Demo!");
   
           // TODO: Call methods here
       }
   
       // Add the new method here, outside and after the main method
       public static void printGreeting(String name) {
           System.out.println("Hello, " + name + "! Welcome to Java methods.");
       }
   }

   Lassen Sie uns aufschlüsseln, was dies bedeutet:

   • public: Dieses Schlüsselwort gibt an, dass auf die Methode von anderen Klassen aus zugegriffen werden kann.
   • static: Dies bedeutet, dass die Methode zur Klasse selbst gehört, nicht zu einer bestimmten Instanz (instance) der Klasse. Wir werden dieses Konzept später noch genauer untersuchen; betrachten Sie es vorerst als eine Anforderung für Methoden, die wir verwenden möchten, ohne ein Objekt zu erstellen.
   • void: Dies bedeutet, dass unsere Methode keinen Wert zurückgibt. Sie führt eine Aktion aus – das Ausgeben einer Begrüßung – gibt aber keine Daten zurück.
   • printGreeting: Dies ist der Name, den wir unserer Methode zugewiesen haben. Wir werden diesen Namen verwenden, um die Methode aufzurufen (invoke) oder zu callen (call).
   • (String name): Dies ist ein Parameter – ein Datenelement, das unsere Methode akzeptiert. Es erwartet einen String, den wir name genannt haben. Wenn wir diese Methode aufrufen, müssen wir einen Wert für diesen Parameter angeben.

3. Großartig! Nachdem wir nun eine Methode erstellt haben, wollen wir sie verwenden. Ersetzen Sie innerhalb der main-Methode den Kommentar // TODO: Call methods here durch:

   printGreeting("Alice");

   

   Diese Zeile ruft oder invoked unsere printGreeting-Methode auf und übergibt ihr den Namen "Alice" als Argument. Das Argument liefert die spezifische Eingabe, die die Methode benötigt, um ihre Aktion auszuführen.

4. Speichern Sie die Datei und lassen Sie uns das Programm kompilieren und ausführen. Geben Sie im Terminal am unteren Rand Ihrer WebIDE diese Befehle ein:

   javac ~/project/MethodDemo.java
   java -cp ~/project MethodDemo

   Der erste Befehl kompiliert unsere Java-Datei und übersetzt sie in Bytecode, den die Java Virtual Machine verstehen kann. Der zweite Befehl führt das kompilierte Programm aus. Sie sollten eine ähnliche Ausgabe wie diese sehen:

   Welcome to the Method Demo!
   Hello, Alice! Welcome to Java methods.

5. Ausgezeichnet! Sie haben gerade Ihre erste Java-Methode erstellt und verwendet. Rufen wir sie noch einmal mit einem anderen Namen auf. Fügen Sie diese Zeile in der main-Methode direkt nach dem ersten printGreeting-Aufruf hinzu:

   printGreeting("Bob");

6. Speichern, kompilieren und führen Sie das Programm erneut aus. Sie sollten nun Folgendes sehen:

   Welcome to the Method Demo!
   Hello, Alice! Welcome to Java methods.
   Hello, Bob! Welcome to Java methods.

   Beachten Sie, wie wir unsere Methode mit verschiedenen Eingaben wiederverwenden können? Dies ist ein wesentlicher Vorteil der Verwendung von Methoden.

7. Erstellen wir nun eine Methode, die einen Wert zurückgibt. Fügen Sie diese Methode Ihrer Klasse unterhalb der printGreeting-Methode hinzu:

   public static int sumNumbers(int a, int b) {
       return a + b;
   }

   Diese Methode akzeptiert zwei ganze Zahlen (integer), addiert sie und gibt das Ergebnis zurück. Beachten Sie, dass wir anstelle von void int verwenden, um anzugeben, dass diese Methode einen ganzzahligen Wert zurückgibt.

8. Verwenden wir diese neue Methode in unserer main-Methode. Fügen Sie diese Zeilen am Ende der main-Methode hinzu:

   int result = sumNumbers(5, 7);
   System.out.println("The sum of 5 and 7 is: " + result);

   Hier rufen wir unsere sumNumbers-Methode auf und übergeben die Werte 5 und 7 als Argumente. Der Rückgabewert der Methode wird dann in einer Variablen namens result gespeichert. Nachdem wir den Rückgabewert gespeichert haben, geben wir den Wert auf der Konsole aus.

9. Speichern, kompilieren und führen Sie das Programm noch einmal aus. Sie sollten nun die zusätzliche Ausgabe sehen:

   The sum of 5 and 7 is: 12

   

Herzlichen Glückwunsch! Sie haben Ihre ersten Java-Methoden erstellt und verwendet. Sie haben gesehen, wie Methoden Aktionen ausführen (wie das Anzeigen von Begrüßungen) und Rückgabewerte liefern können (wie die Summe zweier Zahlen). Methoden ermöglichen es Ihnen, Ihren Code in kleinere, wiederverwendbare Teile zu strukturieren, wodurch Ihre Programme leichter zu verstehen und zu warten sind.

Einführung in Klassen und Objekte

Jetzt, da wir Methoden verstehen, gehen wir einen Schritt in die objektorientierte Programmierung und erstellen eine einfache Klasse. In der objektorientierten Programmierung verwenden wir Klassen als Baupläne, um Objekte zu erstellen. Stellen Sie sich eine Klasse wie einen Keksschnitt und die Objekte wie die Kekse vor, die Sie damit herstellen.

1. Öffnen Sie Car.java und beginnen wir mit dem Bau unserer Klasse. Zuerst definieren wir die Klasse und fügen einige Attribute hinzu:

   public class Car {
       // Attributes
       private String make;
       private String model;
       private int year;
   }

   Diese Attribute (auch Felder oder Eigenschaften genannt) definieren, was jedes Car - Objekt besitzen wird. Jedes Auto wird eine Marke, ein Modell und ein Baujahr haben.

   Das Schlüsselwort private bedeutet, dass diese Attribute nur von innerhalb der Klasse selbst zugegriffen werden können. Dies ist ein Beispiel für Kapselung, ein Konzept, das dazu beiträgt, die Integrität der Daten in unseren Objekten zu schützen.

2. Jetzt fügen wir unserer Klasse einen Konstruktor hinzu. Ein Konstruktor ist eine spezielle Methode, die automatisch aufgerufen wird, wenn wir ein neues Objekt erstellen. Er wird hauptsächlich verwendet, um die Attribute des Objekts zu initialisieren. Fügen Sie diesen Konstruktor zu Ihrer Car - Klasse hinzu:

   // Constructor
   public Car(String make, String model, int year) {
       this.make = make;
       this.model = model;
       this.year = year;
   }

   Dieser Konstruktor nimmt drei Parameter entgegen und verwendet sie, um die Werte unserer Attribute festzulegen. Das Schlüsselwort this wird verwendet, um auf die Attribute des aktuellen Objekts zu verweisen – es hilft, zwischen dem Attribut des Objekts und dem an den Konstruktor übergebenen Parameter zu unterscheiden, wenn ihre Namen identisch sind.

3. Als Nächstes fügen wir unserer Klasse eine Methode hinzu, die Informationen über das Auto anzeigt. Fügen Sie diese Methode zu Ihrer Car - Klasse hinzu:

   // Method
   public void displayInfo() {
       System.out.println("Car Information:");
       System.out.println("Make: " + make);
       System.out.println("Model: " + model);
       System.out.println("Year: " + year);
   }

Diese Methode nimmt keine Parameter entgegen und gibt auch keinen Wert zurück. Sie gibt einfach die Informationen über das Auto in der Konsole aus.

4. Toll! Wir haben unsere Car - Klasse erstellt. Jetzt öffnen wir CarDemo.java und fügen folgenden Code hinzu:

   public class CarDemo {
       public static void main(String[] args) {
           // We'll add code here in the next step
       }
   }

   Dies legt die Grundstruktur für unser Demo - Programm fest.

5. Jetzt erstellen wir einige Car - Objekte und verwenden sie. Fügen Sie diesen Code innerhalb der main - Methode hinzu:

   Car myCar = new Car("Toyota", "Corolla", 2022);
   myCar.displayInfo();
   
   Car friendsCar = new Car("Honda", "Civic", 2023);
   friendsCar.displayInfo();

   Hier erstellen wir zwei Car - Objekte. Das Schlüsselwort new wird verwendet, um ein neues Objekt zu erstellen, und wir rufen den zuvor definierten Konstruktor auf, um die Marke, das Modell und das Jahr festzulegen. Dann rufen wir die displayInfo - Methode für jedes Auto - Objekt auf, um ihre Eigenschaften anzuzeigen.

6. Bevor wir unser Programm kompilieren und ausführen, ist es wichtig zu beachten, dass wir mit mehreren Java - Dateien arbeiten (Car.java und CarDemo.java). Wenn wir mehrere Dateien mit Abhängigkeiten kompilieren, müssen wir sie zusammen kompilieren. Stellen Sie auch sicher, dass CarDemo.java und Car.java sich im selben Verzeichnis befinden. Andernfalls müssen Sie die Car - Klasse am Anfang von CarDemo.java wie unten gezeigt importieren.

   Wenn CarDemo.java und Car.java sich in verschiedenen Verzeichnissen befinden, müssen Sie möglicherweise eine Importanweisung oben in CarDemo.java hinzufügen:

   import packagename.Car;  // Replace 'packagename' with the actual package name if applicable

   Jetzt kompilieren und führen wir das CarDemo - Programm aus:

   javac ~/project/Car.java ~/project/CarDemo.java
   java -cp ~/project CarDemo

   Der erste Befehl kompiliert beide unsere Java - Dateien zusammen und stellt sicher, dass alle Abhängigkeiten berücksichtigt werden. Der zweite Befehl führt unsere CarDemo - Klasse aus.

   Sie sollten eine Ausgabe wie diese sehen:

   Car Information:
   Make: Toyota
   Model: Corolla
   Year: 2022
   Car Information:
   Make: Honda
   Model: Civic
   Year: 2023

Herzlichen Glückwunsch! Sie haben gerade Ihre erste Java - Klasse erstellt und sie verwendet, um Objekte zu erstellen. Dies ist die Grundlage der objektorientierten Programmierung in Java. Sie haben einen Bauplan definiert (die Car - Klasse) und ihn verwendet, um spezifische Instanzen zu erstellen (die Car - Objekte). Jedes Objekt hat seine eigene eindeutige Menge an Attributen, aber sie teilen sich alle die von der Klasse definierte Struktur und das Verhalten.

Verbessern unserer Klasse mit weiteren Methoden

Jetzt, da wir ein grundlegendes Verständnis von Klassen und Objekten haben, verbessern wir unsere Car - Klasse mit weiteren Methoden, um ihre Nützlichkeit zu erhöhen. Wir werden Methoden hinzufügen, die Aktionen darstellen, die ein Auto ausführen kann, und Eigenschaften, über die wir möglicherweise Informationen über ein Auto erhalten möchten.

1. Öffnen Sie die Datei Car.java. Fügen wir eine Methode hinzu, die das Beschleunigen des Autos darstellt. Fügen Sie diese Methode zur Car - Klasse hinzu:

   public void accelerate() {
       System.out.println("The " + make + " " + model + " is accelerating.");
   }

   Diese Methode ändert keine der Attribute des Autos; sie gibt einfach eine Nachricht über das Beschleunigen des Autos aus.

2. Jetzt fügen wir eine Methode für das Bremsen hinzu. Fügen Sie diese Methode zur Car - Klasse hinzu:

   public void brake() {
       System.out.println("The " + make + " " + model + " is braking.");
   }

   Diese Methode gibt ebenfalls nur eine Nachricht über die Aktion des Autos aus, ähnlich wie die vorherige accelerate - Methode.

3. Als Nächstes fügen wir eine Methode hinzu, die Informationen über das Auto liefert. Fügen Sie diese Methode hinzu:

   public String getMakeAndModel() {
       return make + " " + model;
   }

   Diese Methode kombiniert die Marke und das Modell zu einem einzigen String und gibt ihn zurück. Beachten Sie, dass der Rückgabetyp String und nicht void ist, da diese Methode uns Informationen liefert.

4. Schließlich fügen wir eine Methode hinzu, die feststellt, ob ein Auto als Antikauto eingestuft wird. An vielen Orten gilt ein Auto als Antikauto, wenn es älter als 25 Jahre ist. Fügen Sie diese Methode hinzu:

    public boolean isAntique() {
        int currentYear = java.time.Year.now().getValue();
        return (currentYear - year) > 25;
    }

   Diese Methode verwendet die integrierte Year - Klasse von Java, um das aktuelle Jahr zu erhalten. Sie berechnet dann das Alter des Autos und gibt true zurück, wenn es älter als 25 Jahre ist, und false sonst.

5. Nachdem wir diese zusätzlichen Methoden zu unserer Car - Klasse hinzugefügt haben, aktualisieren wir unsere CarDemo.java - Datei, um sie zu verwenden. Öffnen Sie CarDemo.java und ersetzen Sie ihren Inhalt durch:

   public class CarDemo {
       public static void main(String[] args) {
           Car myCar = new Car("Toyota", "Corolla", 2022);
           Car classicCar = new Car("Ford", "Mustang", 1965);
   
           myCar.displayInfo();
           myCar.accelerate();
           myCar.brake();
   
           System.out.println(classicCar.getMakeAndModel() + " is an antique: " + classicCar.isAntique());
   
           Car[] carArray = {myCar, classicCar};
           for (Car car : carArray) {
               System.out.println(car.getMakeAndModel() + " is an antique: " + car.isAntique());
           }
       }
   }

   Diese neue main - Methode erreicht mehrere Ziele:

   • Sie erstellt zwei Car - Objekte: ein modernes Auto und ein klassisches Auto.
   • Sie ruft unsere neu hinzugefügten accelerate - und brake - Methoden auf dem modernen Auto - Objekt auf.
   • Sie verwendet die getMakeAndModel - und isAntique - Methoden auf dem klassischen Auto - Objekt.
   • Sie erstellt ein Array von Car - Objekten und verwendet eine for - each - Schleife, um durch sie zu iterieren, was zeigt, wie wir Sammlungen von Objekten verarbeiten können.

6. Speichern Sie beide Dateien, kompilieren und führen Sie dann das CarDemo - Programm aus:

   javac ~/project/Car.java ~/project/CarDemo.java
   java -cp ~/project CarDemo

   Sie sollten eine Ausgabe ähnlich dieser sehen:

   Car Information:
   Make: Toyota
   Model: Corolla
   Year: 2022
   The Toyota Corolla is accelerating.
   The Toyota Corolla is braking.
   Ford Mustang is an antique: true
   Toyota Corolla is an antique: false
   Ford Mustang is an antique: true

Herzlichen Glückwunsch! Sie haben Ihre Car - Klasse erheblich erweitert und ein komplexeres Programm mit Objekten erstellt. Dies zeigt, wie die objektorientierte Programmierung verwendet werden kann, um reale Konzepte im Code abzubilden. Jedes Auto - Objekt besitzt jetzt seine eigenen Daten (Marke, Modell, Jahr) und Aktionen (Beschleunigen, Bremsen usw.), ähnlich wie reale Autos.

1. Wir haben unserer Car - Klasse Methoden hinzugefügt, die Aktionen darstellen (accelerate() und brake()). Obwohl diese Methoden in unserer aktuellen Implementierung den Zustand des Autos nicht ändern, könnten sie in einem komplexeren Programm Attribute wie Geschwindigkeit oder Treibstoffstand ändern.

2. Wir haben getMakeAndModel() hinzugefügt, das zwei Informationen zu einem einzigen String kombiniert. Dies ist ein häufiges Muster in der objektorientierten Programmierung – das Erstellen von Methoden, die einen bequemen Zugang zu Objektdaten ermöglichen.

3. Die isAntique() - Methode zeigt, wie Objektdaten (das Baujahr des Autos) mit externen Informationen (dem aktuellen Jahr) kombiniert werden können, um neue Informationen über ein Objekt abzuleiten.

4. In unserer CarDemo - Klasse haben wir gezeigt, wie man mehrere Objekte erstellt und verwendet, wie man verschiedene Methoden auf diesen Objekten aufruft und wie man durch ein Array von Objekten iteriert.

Dieses Beispiel zeigt die Stärke der objektorientierten Programmierung. Wir haben eine Car - Klasse erstellt, die sowohl Daten (Marke, Modell, Jahr) als auch Verhalten (Beschleunigen, Bremsen, isAntique) kapselt. Jedes von uns erstellte Car - Objekt ist unabhängig und hat seine eigene eindeutige Menge an Daten, aber alle folgen den gleichen Aktionen, wie sie von der Klasse definiert sind.

Zusammenfassung

In diesem Lab haben wir in unserer Java - Programmierreise erhebliche Fortschritte gemacht. Wir haben einige grundlegende, aber essentielle Konzepte behandelt, die die Grundlage für das Schreiben komplexerer und besser organisierter Java - Programme bilden. Lassen Sie uns zusammenfassen, was wir gelernt haben:

1. Methoden:

   • Wir haben Methoden erstellt und verwendet, um unseren Code zu strukturieren und ihn wiederverwendbarer zu machen.
   • Wir haben untersucht, wie Methoden Parameter akzeptieren und Werte zurückgeben können, wodurch wir komplexe Probleme in kleinere, handhabbare Aufgaben aufteilen können.
   • Methoden helfen uns, Codewiederholungen zu reduzieren und unsere Programme leichter verständlich und wartbar zu machen.

2. Klassen und Objekte:

   • Wir haben das Konzept von Klassen als Baupläne für die Erstellung von Objekten eingeführt.
   • Wir haben eine Car - Klasse mit Attributen (Marke, Modell, Jahr) und Methoden (displayInfo, accelerate, brake usw.) erstellt.
   • Wir haben gelernt, wie man Objekte (Instanzen einer Klasse) instanziiert und Methoden auf diesen Objekten aufruft.

3. Objektorientierte Programmierung:

   • Wir haben gesehen, wie die objektorientierte Programmierung es uns ermöglicht, reale Konzepte in unserem Code abzubilden.
   • Wir haben Daten (Attribute) und Verhalten (Methoden) in unserer Car - Klasse gekapselt.
   • Wir haben mehrere Car - Objekte erstellt, was zeigt, dass jedes Objekt seine eigene Menge an Daten hat, aber die gleichen von der Klasse definierten Aktionen teilt.

4. Erweiterte Klassenfunktionalität:

   • Wir haben unsere Car - Klasse mit komplexeren Methoden erweitert, darunter eine, die Java's integrierte Datumswerkzeuge nutzt, um zu bestimmen, ob ein Auto ein Antikauto ist.
   • Wir haben gesehen, wie Methoden mit Objektdaten und externen Informationen interagieren können, um neue Informationen zu generieren.

5. Arbeiten mit mehreren Objekten:

   • Wir haben ein Array von Car - Objekten erstellt, was zeigt, wie man mit Sammlungen von Objekten in unseren Programmen arbeitet.

Diese Konzepte bilden die Grundlage der Java - Programmierung und sind für die Erstellung größerer und komplexerer Anwendungen unerlässlich. Wenn Sie Ihre Java - Reise fortsetzen, werden Sie feststellen, dass Sie diese Konzepte wiederholt nutzen.

Denken Sie daran, dass das Beherrschen der Programmierung ständliche Übung erfordert. Hier sind einige Ideen, um Ihr Lernen zu erweitern:

1. Versuchen Sie, der Car - Klasse weitere Attribute hinzuzufügen, wie color oder mileage.
2. Erstellen Sie Methoden, die diese Attribute ändern, wie paint(String newColor) oder drive(int miles).
3. Erstellen Sie eine Garage - Klasse, die mehrere Car - Objekte speichern kann. Fügen Sie Methoden hinzu, um Autos in die Garage hinzuzufügen, Autos zu entfernen und alle Autos in der Garage anzuzeigen.
4. Experimentieren Sie mit der Erstellung von Klassen für andere Arten von Objekten, wie Book oder Student.

Weiter programmieren, weiter erkunden und vor allem weiterhin Spaß haben! Sie sind auf dem guten Weg, ein erfahrener Java - Programmierer zu werden.