Java-Klassen: Schreiben Sie Ihre eigenen Klassen und Konstruktoren

Hallo! Heute werden wir über Klassen in Java sprechen. Man könnte sagen, dass Klassen den Grundstein der Java-Programmierung bilden. Wenn Sie Programmierer werden, besteht fast Ihr gesamter Job darin, eigene Klassen mit verschiedenen Funktionen zu schreiben. Mal sehen, was das bedeutet und wie es funktioniert. :) Wie Sie wissen, ist Java eine objektorientierte Programmiersprache. Alle Programme bestehen aus Objekten, die auf die eine oder andere Weise miteinander in Beziehung stehen. Eine Klasse ist im Wesentlichen eine Vorlage für ein Objekt. Es bestimmt, wie das Objekt aussehen wird und welche Funktionen es haben wird. Jedes Objekt ist ein Objekt einer Klasse. Betrachten Sie dieses sehr einfache Beispiel:

public class Cat {

    String name;
    int age;

}

Nehmen wir an, wir schreiben aus irgendeinem Grund ein Programm, das Katzen einbezieht (wir haben beispielsweise eine Tierklinik, die Zugriff auf ein Online-Konto bietet). Wir haben eine Cat- Klasse erstellt und darin zwei Variablen deklariert: String name und int age . Diese Mitgliedsvariablen werden Felder genannt. Im Wesentlichen handelt es sich hierbei um eine Vorlage für alle Katzen, die wir in Zukunft erstellen werden. Jedes Cat- Objekt verfügt über zwei Variablen: einen Namen und ein Alter.

public class Cat {

    String name;
    int age;

    public static void main(String[] args) {
        Cat smudge = new Cat();
        smudge.age = 3;
        smudge.name = "Smudge";

        System.out.println("We created a cat named " + smudge.name + ". His age is " + smudge.age);
    }

}

So funktioniert das! Wir erstellen eine Katze, geben ihr einen Namen und ein Alter und zeigen alles auf der Konsole an. Stück Kuchen. :) Meistens beschreiben Kurse Dinge und Phänomene in der realen Welt. Eine Katze, ein Tisch, eine Person, ein Blitz, eine Buchseite, ein Rad – all diese Dinge erstellen Sie in Ihren Programmen mithilfe einzelner Klassen. Konzentrieren wir uns zunächst auf die Variablen, die wir in der Cat- Klasse deklariert haben. Sie werden Felder oder Instanzvariablen genannt. Ihr Name sagt wirklich alles. Jede Instanz (oder jedes Objekt) der Cat- Klasse verfügt über diese Variablen. Jede Katze, die wir erstellen, hat ihre eigene Namensvariable und ihr eigenes AlterVariable. Das macht Sinn – im Grunde ist es bei echten Katzen so. :) Neben Instanzvariablen gibt es auch Klassenvariablen (statische Variablen). Lassen Sie uns unser Beispiel beenden:

public class Cat {

    String name;
    int age;

    static int count = 0;

    public static void main(String[] args) {
        Cat smudge = new Cat();
        smudge.age = 3;
        smudge.name = "Smudge";
        count++;

        Cat fluffy = new Cat();
        fluffy.age = 5;
        fluffy.name = "Fluffy";
        count++;

        System.out.println("We created a cat named " + smudge.name + ". His age is " + smudge.age);
        System.out.println("We created a cat named " + fluffy.name + ". His age is " + fluffy.age);

        System.out.println("Total number of cats = " + count);
    }
}

Konsolenausgabe: Wir haben eine Katze namens Smudge erstellt. Er ist 3 Jahre alt. Wir haben eine Katze namens Fluffy erschaffen. Er ist 5 Jahre alt. Gesamtzahl der Katzen = 2. Jetzt hat unsere Klasse eine neue Variable namens count. Es ist für die Zählung der erstellten Katzen verantwortlich. Jedes Mal erstellen wir im Wesentlichen eine Katze-Methode erhöhen wir diese Variable um 1. Diese Variable wird mit dem Schlüsselwort static deklariert. Das heißt, es gehört zur Klasse und nicht zu einem bestimmten Objekt der Klasse. Was natürlich Sinn macht: Der Name jeder Katze gehört zu dieser bestimmten Katze, aber wir brauchen einen Katzenzähler, der für alle gilt. Das ist genau das, was das Schlüsselwort static erreicht: Es macht die Zählvariable zu einer einzigen Variablen für alle Katzen. Hinweis: Wenn wir die Variable anzeigen, verwenden wir weder smudge.count noch Fluffy.count. Es gehört weder Smudge noch Fluffy; Es gehört zur gesamten Cat- Klasse. Deshalb heißt es einfach zählen. Sie könnten auch Cat.count schreiben. Das wäre auch richtig. Bei der Anzeige der Namensvariablen würden wir Folgendes nicht tun:

public class Cat {

    String name;
    int age;

    static int count = 0;

    public static void main(String[] args) {
        Cat smudge = new Cat();
        smudge.age = 3;
        smudge.name = "Smudge";
        count++;

        System.out.println("We created a cat named " + name + ". His age is " + smudge.age);

        System.out.println("Total number of cats = " + count);
    }
}

Das ist ein Fehler! Jede Katze hat ihren eigenen Namen. Der Compiler wird hier verwirrt. „Einen Namen an die Konsole ausgeben? Wessen Name?“ :/"

Methoden

Zusätzlich zu Variablen verfügt jede Klasse über Methoden. Wir werden in einer separaten Lektion ausführlicher darauf eingehen, aber die allgemeinen Prinzipien sind recht einfach. Methoden definieren die Funktionalität Ihrer Klasse, also was Objekte Ihrer Klasse tun können. Eine dieser Methoden kennen Sie bereits: die main()- Methode. Aber wie Sie sich vielleicht erinnern, ist die Hauptmethode statisch, was bedeutet, dass sie zur gesamten Klasse gehört (die Logik ist dieselbe wie bei Variablen). Standardmäßige, nicht statische Methoden können jedoch nur für bestimmte von uns erstellte Objekte aufgerufen werden. Wenn wir beispielsweise eine Katzenklasse schreiben möchten, müssen wir wissen, welche Funktionen eine Katze in unserem Programm haben soll. Unter dieser Voraussetzung schreiben wir ein paar Methoden für unsere Katze:

public class Cat {

    String name;
    int age;

    public void sayMeow() {
        System.out.println("Meow!");
    }

    public void jump() {
        System.out.println("Pounce!");
    }

    public static void main(String[] args) {
        Cat smudge = new Cat();
        smudge.age = 3;
        smudge.name = "Smudge";

        smudge.sayMeow();
        smudge.jump();

    }
}

Hör zu! Jetzt ähnelt unsere Klasse viel mehr einer Katze! Jetzt haben wir nicht nur eine Katze mit einem Namen („Smudge“) und einem Alter (3). Er kann auch miauen und springen! Was für eine Katze wäre sie ohne diese „Funktionalität“? :) Wir nehmen ein bestimmtes Objekt (smudge) und rufen seine Methoden sayMeow() und jump() auf. Schauen wir uns die Konsole an: Miau! Zuschlagen! Eine echte Katze! :) :)

Erstellen Sie Ihre eigenen Klassen. Abstraktion

In Zukunft müssen Sie Ihre eigenen Klassen schreiben. Worauf müssen Sie beim Verfassen achten? Wenn wir über Variablen sprechen, müssen Sie etwas namens Abstraktion verwenden. Abstraktion ist eines der vier Grundprinzipien der objektorientierten Programmierung. Es bedeutet, die wichtigsten und bedeutsamsten Merkmale eines Gegenstands herauszufiltern und umgekehrt die unbedeutenden oder unbedeutenden Merkmale beiseite zu schieben. Lassen Sie uns zum Beispiel einen Aktenschrank für Firmenmitarbeiter erstellen. Um Mitarbeiterobjekte zu erstellen, haben wir einen Mitarbeiter geschriebenKlasse. Welche Eigenschaften sind wichtige Merkmale eines Mitarbeiters für den Aktenschrank unseres Unternehmens? Name, Geburtsdatum, SSN und Mitarbeiter-ID. Es ist jedoch unwahrscheinlich, dass wir die Größe, Augen- oder Haarfarbe des Mitarbeiters für die Mitarbeiterakte des Unternehmens benötigen. Unternehmen benötigen diese Informationen nicht. Daher deklarieren wir in der Employee- Klasse die folgenden Variablen: String name , int age , int socialSecurityNumber und int EmployeeId. Und wir lassen unnötige Informationen weg (wie die Augenfarbe). Mit anderen Worten: Wir schaffen eine Abstraktion. Wenn wir jedoch einen Aktenschrank für Modelagenturen herstellen, ändert sich die Situation dramatisch. Die Größe, Augenfarbe und Haarfarbe eines Models sind wichtige Merkmale, ihre SSN ist für uns jedoch völlig irrelevant. Daher müssen wir in der Model- Klasse die folgenden Variablen erstellen: String-Höhe , String-Haare , String-Augen . So funktioniert Abstraktion – es ist ganz einfach! :) :)

Konstrukteure

Kehren wir zu unserem Katzenbeispiel zurück.

public class Cat {

    String name;
    int age;

    public static void main(String[] args) {
        Cat smudge = new Cat();

        System.out.println("Here the program does something for 2 hours...");

        smudge.age = 3;
        smudge.name = "Smudge";

    }
}

Schauen Sie sich diesen Code an und versuchen Sie herauszufinden, was mit unserem Programm nicht stimmt. In unserem Programm gab es zwei Stunden lang eine Katze ohne Namen und Alter! Das ist natürlich grundsätzlich falsch. Die Datenbank der Tierklinik sollte keine Katzen ohne Informationen enthalten. Derzeit ist unsere Katze dem Programmierer ausgeliefert. Wir vertrauen darauf, dass er die Angabe von Namen und Alter nicht vergisst und alles gut wird. Wenn er es vergisst, wird die Datenbank ein Problem haben: unbenannte Katzen. Wie können wir dieses Problem lösen? Wir müssen irgendwie verhindern, dass Katzen ohne Namen und Alter geschaffen werden. Hier kommen Konstrukteure zur Rettung. Geben wir ein Beispiel:

public class Cat {

    String name;
    int age;

    // Constructor for the Cat class
    public Cat(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public static void main(String[] args) {

        Cat smudge = new Cat("Smudge", 5);
    }
}

Im Wesentlichen ist ein Konstruktor eine Vorlage für Objekte einer Klasse. In diesem Fall geben wir an, dass für jedes Cat- Objekt zwei Argumente, ein String und ein int , angegeben werden müssen . Wenn wir jetzt versuchen, eine namenlose Katze zu erschaffen, wird es nicht funktionieren.

public class Cat {

    String name;
    int age;

    public Cat(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public static void main(String[] args) {

        Cat smudge = new Cat(); // Error!
    }
}

Da die Klasse nun über einen Konstruktor verfügt, weiß der Java-Compiler, wie die Objekte aussehen sollen, und lässt nicht zu, dass Objekte ohne Angabe der Argumente erstellt werden. Untersuchen wir nun das Schlüsselwort this, das Sie im Konstruktor sehen. Es ist auch einfach. Das Schlüsselwort this dient zur Angabe eines bestimmten Objekts. Der Code im Konstruktor

public Cat(String name, int age) {
    this.name = name;
    this.age = age;
}

kann fast wörtlich interpretiert werden: „Der Name dieser Katze (die, die wir erstellen) = das Argument, das für den Namensparameter des Konstruktors übergeben wurde. Das Alter dieser Katze (die, die wir erstellen) = das Argument, das für den Namensparameter des Konstruktors übergeben wurde.“ Altersparameter.“ Nachdem der Konstruktor ausgeführt wurde, können Sie überprüfen, ob unserer Katze alle erforderlichen Werte zugewiesen wurden:

public class Cat {

    String name;
    int age;

    public Cat(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public static void main(String[] args) {

        Cat smudge = new Cat("Smudge", 5);
        System.out.println(smudge.name);
        System.out.println(smudge.age);
    }
}

Konsolenausgabe: Smudge 5 Beim Aufruf des Konstruktors:

Cat smudge = new Cat("Smudge", 5);

Das ist tatsächlich intern passiert:

this.name = "Smudge";
this.age = 5;

Und die Werte der an den Konstruktor übergebenen Argumente wurden dem smudge- Objekt zugewiesen (darauf bezieht sich dies in diesem Fall). Selbst wenn Sie in einer Klasse keinen Konstruktor deklarieren, wird dennoch ein Konstruktor aufgerufen! Aber wie ist das möglich? О_О Weil alle Java-Klassen einen sogenannten Standardkonstruktor haben. Es benötigt keine Argumente, wird aber jedes Mal aufgerufen, wenn Sie ein Objekt einer beliebigen Klasse erstellen.

public class Cat {

    public static void main(String[] args) {

        Cat smudge = new Cat(); // The default constructor is invoked here
    }
}

Auf den ersten Blick mag dies nicht offensichtlich sein. Wir haben ein Objekt erstellt, na und? Wo macht der Konstruktor hier etwas? Um es zu sehen, schreiben wir explizit einen leeren Konstruktor für die Cat- Klasse. Darin werden wir eine Phrase an die Konsole ausgeben. Wenn die Phrase angezeigt wird, wurde der Konstruktor aufgerufen.

public class Cat {

    public Cat() {
        System.out.println("A cat has been created!");
    }

    public static void main(String[] args) {

        Cat smudge = new Cat(); // The default constructor is invoked here
    }
}

Konsolenausgabe: Eine Katze wurde erstellt! Da ist die Bestätigung. Der Standardkonstruktor ist in Ihren Klassen immer unsichtbar vorhanden. Aber Sie müssen noch etwas darüber wissen. Der Standardkonstruktor wird aus einer Klasse entfernt, sobald Sie einen Konstruktor mit Argumenten erstellen. Tatsächlich haben wir oben bereits Beweise dafür gesehen. Es stand in diesem Code:

public class Cat {

    String name;
    int age;

    public Cat(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public static void main(String[] args) {

        Cat smudge = new Cat(); // Error!
    }
}

Ohne Namen und Alter konnten wir keine Cat erstellen, da wir einen Cat- Konstruktor mit String- und Int-Parametern deklariert haben. Dies führte dazu, dass der Standardkonstruktor sofort aus der Klasse verschwand. Denken Sie also daran, dass Sie, wenn Sie mehrere Konstruktoren in Ihrer Klasse benötigen, einschließlich eines Konstruktors ohne Argumente, diesen separat deklarieren müssen. Unsere Klinik möchte Gutes tun und obdachlosen Kätzchen helfen, deren Namen und Alter unbekannt sind. Dann sollte unser Code so aussehen:

public class Cat {

    String name;
    int age;

    // For cats with owners
    public Cat(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // For street cats
    public Cat() {
    }

    public static void main(String[] args) {

        Cat smudge = new Cat("Smudge", 5);
        Cat streetCat = new Cat();
    }
}

Nachdem wir nun einen expliziten Standardkonstruktor angegeben haben, können wir beide Arten von Katzen erstellen. Im Konstruktor können Sie Werte direkt zuweisen. Man muss sie nicht immer Argumenten entnehmen. Beispielsweise könnten wir alle Straßenkatzen in der Datenbank mit „Straßenkatze Nr. <Anzahl>“ als Vorlage kennzeichnen. :

public class Cat {

    String name;
    int age;

    static int count = 0;

    public Cat() {
        count++;
        this.name = "Street cat No. " + count;
    }

    public Cat(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public static void main(String[] args) {

        Cat streetCat1 = new Cat();
        Cat streetCat2 = new Cat();
        System.out.println(streetCat1.name);
        System.out.println(streetCat2.name);
    }
}

Wir haben eine Zählvariable , die unsere Straßenkatzen zählt. Jedes Mal, wenn der Standardkonstruktor ausgeführt wird, erhöhen wir count um 1 und hängen diese Zahl an den Namen der Katze an. Die Reihenfolge der Argumente ist für Konstruktoren sehr wichtig. Lassen Sie uns die an unseren Konstruktor übergebenen Namens- und Altersargumente vertauschen.

public class Cat {

    String name;
    int age;

    public Cat(int age, String name) {
        this.name = name;
        this.age = age;
    }

    public static void main(String[] args) {

        Cat smudge = new Cat("Smudge", 10); // Error!
    }
}

Es ist ein Fehler aufgetreten! Der Konstruktor legt eindeutig fest, dass beim Erstellen eines Cat- Objekts ihm eine Zahl und ein String in dieser Reihenfolge übergeben werden müssen. Unser Code funktioniert also nicht. Denken Sie unbedingt an diese Regel und respektieren Sie sie, wenn Sie Ihre eigenen Klassen deklarieren:

public Cat(String name, int age) {
    this.name = name;
    this.age = age;
}

public Cat(int age, String name) {
    this.age = age;
    this.name = name;
}

Das sind zwei völlig unterschiedliche Konstrukteure! Erledigen Sie nun einige Aufgaben, um Ihr Verständnis des Materials zu festigen. :) :)

Museum für Antiquitäten.

Ihre Aufgabe besteht darin, eine Artifact -Klasse zu entwerfen.
Im Museum werden drei Arten von Artefakten aufbewahrt.
Über den ersten Typ wissen wir nichts außer der vom Museum vergebenen Seriennummer (zum Beispiel: 212121).
Für den zweiten Typ kennen wir die Seriennummer und die Kultur, die ihn geschaffen hat (zum Beispiel: 212121, „Azteken“).
Für den dritten Typ kennen wir die Seriennummer, die Kultur, die ihn geschaffen hat, und das Jahrhundert, in dem er geschaffen wurde (zum Beispiel: 212121, „Azteken“, 12).

Erstellen Sie eine Artefaktklasse , die die im Museum aufbewahrten Antiquitäten beschreibt, und schreiben Sie die erforderlichen Konstruktoren für die Klasse. Erstellen Sie dann in der main()- Methode ein Artefakt jeder Art.
```
public class Artifact {

    // Write your code here

    public static void main(String[] args) {
        // Write your code here
    }
}
```
Datingwebsite

Lassen Sie uns eine Benutzerdatenbank für eine Dating-Website erstellen.
Aber hier liegt das Problem: Sie haben die erforderliche Reihenfolge der Argumente vergessen und es ist keine technische Dokumentation verfügbar.
Entwerfen Sie eine Benutzerklasse , die über die folgenden Felder verfügt: Name ( String ), Alter ( Short ) und Größe ( Int ).
Erstellen Sie die entsprechende Anzahl von Konstruktoren, sodass Name, Alter und Größe in beliebiger Reihenfolge angegeben werden können.
```
public class User {

    String name;
    short age;
    int height;

    // Write your code here

    public static void main(String[] args) {

    }
}
```

Um das Gelernte zu vertiefen, empfehlen wir Ihnen, sich eine Videolektion aus unserem Java-Kurs anzusehen

Mehr Lektüre:
Anonymer Unterricht Statisch verschachtelte Klassen Verschachtelte innere Klassen Beziehungen zwischen Klassen. Vererbung, Zusammensetzung und Aggregation Der Unterschied zwischen abstrakten Klassen und Schnittstellen