Kaffeepause Nr. 111. Polymorphismus und dynamische Bindung in Java. For-Schleife in Java + Beispiel für die forEach-Schleifensyntax

Polymorphismus und dynamische Bindung in Java

Quelle: DZone Polymorphismus ist eines der Kernkonzepte der objektorientierten Programmierung. Unabhängig davon, ob Sie neu in der Java-Programmierung sind oder ein erfahrener Entwickler sind, sollten Sie wissen, was Polymorphismus ist und wie er funktioniert. Die meisten Entwickler geben an, sich in diesem Thema gut auszukennen, aber wenn es um andere komplexe Funktionen wie statische und dynamische Bindung geht, verlieren viele von ihnen ihr Vertrauen.

Was ist Polymorphismus in Java?

Polymorphismus bedeutet, viele Formen zu haben. In der Programmierung bezieht sich dies auf die Fähigkeit eines Signals oder einer Nachricht, in mehr als einer Form zu erscheinen.

Beispiel aus dem wirklichen Leben

Ein Mensch kann viele Eigenschaften gleichzeitig aufweisen. Beispielsweise kann eine Mutter gleichzeitig Ehefrau, Tochter, Schwester, Firmenangestellte usw. sein. Daher kann eine Person unter verschiedenen Bedingungen unterschiedliche Eigenschaften aufweisen. Dies wird als Polymorphismus bezeichnet.

Die Bedeutung des Polymorphismus

Polymorphismus ist eines der wichtigsten Merkmale jeder objektorientierten Programmiersprache (z. B. Java). Mit Hilfe des Polymorphismus kann dieselbe Aufgabe auf unterschiedliche Weise ausgeführt werden.

Arten von Polymorphismus

In Java kann Polymorphismus in zwei Kategorien unterteilt werden:

1. Polymorphismus zur Kompilierungszeit (statische Verknüpfung)
2. Laufzeitpolymorphismus (Laufzeit, dynamische Bindung)

Polymorphismus zur Kompilierungszeit

Polymorphismus zur Kompilierungszeit wird auch als statisches Linken bezeichnet. Diese Art von Polymorphismus kann durch Funktionsüberladung oder Operatorüberladung erreicht werden. In Java beschränkt sich dies jedoch auf das Überladen von Funktionen, da Java das Überladen von Operatoren nicht unterstützt. Funktionsüberladung Wenn es mindestens zwei Funktionen oder Methoden mit demselben Funktionsnamen gibt, aber entweder die Anzahl der darin enthaltenen Parameter unterschiedlich ist oder mindestens ein Datentyp des entsprechenden Parameters unterschiedlich ist (oder beides), dann wird dies als Funktion bezeichnet oder Methodenüberladung, und diese Funktionen werden als überladene Funktionen bezeichnet. Beispiel 1 Bisher haben wir untersucht, was Funktionsüberladung ist. Versuchen wir nun, die Überlastung von Softwarefunktionen zu demonstrieren.

class Main {

    // Method 1
    // Method with 2 integer parameters
    static int Addition(int a, int b)
    {

        // Returns sum of integer numbers
        return a + b;
    }
    // Method 2
    // having the same name but with 2 double parameters
    static double Addition(double a, double b)
    {
        // Returns sum of double numbers
        return a + b;
    }
    public static void main(String args[]) {

        // Calling method by passing
        // input as in arguments
        System.out.println(Addition(12, 14));
        System.out.println(Addition(15.2, 16.1));

    }
}

Sie können das obige Programm hier ausführen . Programmerklärung:

• Das obige Programm besteht aus zwei statischen Funktionen mit demselben Namen: Addition .

• Hier enthalten beide Funktionen die gleiche Anzahl an Parametern, ihre entsprechenden Parameter sind jedoch unterschiedlich.

• Methode 1 akzeptiert zwei ganzzahlige Parameter, während Methode 2 zwei doppelte Parameter akzeptiert .

• Von der Hauptfunktion aus rufen wir zunächst die Funktion Addition(12, 14) auf . Die übergebenen Parameter sind ganze Zahlen (12 und 14), daher wird hier Methode 1 aufgerufen.

• Dann haben wir die Funktion Addition(15.2, 16.1) aufgerufen . Da die übergebenen Parameter vom doppelten Datentyp sind (15.2 und 16.1), wird dieses Mal Methode 2 aufgerufen .

• Auf diese Weise wird in Java eine Funktionsüberladung basierend auf verschiedenen Parameterdatentypen erreicht.

Beispiel 2 Betrachten Sie das folgende Programm:

class Main {

    // Method 1
    // Method with 2 integer parameters
    static int Addition(int a, int b)
    {

        // Returns sum of integer numbers
        return a + b;
    }

    // Method 2
    // having the same name but with 3 integer parameters
    static double Addition(double a, double b)
    {

        // Returns sum of integer numbers
        return a + b;
    }
    public static void main(String args[]) {

        // Calling method by passing
        // input as in arguments
        System.out.println(Addition(12, 14));
        System.out.println(Addition(15.2, 16.1));

    }
}

Sie können das obige Programm hier ausführen . Programmerklärung:

• Das obige Programm besteht aus zwei statischen Funktionen mit demselben Namen: Addition .

• Hier enthalten beide Funktionen eine unterschiedliche Anzahl von Parametern, aber der Datentyp der ersten beiden entsprechenden Parameter ist derselbe (Ganzzahl).

• Methode 1 benötigt zwei ganzzahlige Parameter und Methode 2 drei ganzzahlige Datentypparameter.

• Von der Hauptfunktion aus rufen wir zunächst die Funktion Addition(2, 3) auf . Da es sich bei den übergebenen Parametern um Ganzzahlen (2 und 3) handelt, wird hier Methode 1 aufgerufen .

• Dann haben wir die Funktion Addition(4, 5, 6) aufgerufen . Die übergebenen Parameter sind doppelte Datentypen (4, 5, 6), daher wird dieses Mal Methode 2 aufgerufen .

• Auf diese Weise werden Funktionen in Java basierend auf einer unterschiedlichen Anzahl von Parametern überladen.

Beispiel 3

class Main {

    // Method 1
    // Method with 2 integer parameters
    static int Addition(int a, int b)
    {
        // Return the sum
        return a + b;
    }
    // Method 2
    // having the same name but with 3 parameters
    // 1st parameter is of type double and other parameters
    // are of type integer
    static double Addition(double a, int b,  int c)
    {
        // Return the sum
        return a + b + c;
    }
    public static void main(String args[]) {

        // Calling method by passing
        // input as in arguments
        System.out.println(Addition(2, 4));
        System.out.println(Addition(4.2, 6, 10));

    }
}

Sie können das obige Programm hier ausführen . Programmerklärung:

• Das obige Programm besteht aus zwei statischen Funktionen mit demselben Namen: Addition .

• Beide Funktionen enthalten eine unterschiedliche Anzahl an Parametern und auch der Datentyp des ersten entsprechenden Elements ist unterschiedlich.

• Methode 1 benötigt zwei ganzzahlige Parameter, während Methode 2 drei Parameter benötigt – der erste ist vom Typ Double und die anderen beiden sind ganzzahlige Datentypen.

• Von der Hauptfunktion aus rufen wir zunächst die Funktion Addition(2, 4) auf . Da es sich bei den übergebenen Parametern um Ganzzahlen (2 und 4) handelt, wird hier Methode 1 aufgerufen .

• Dann haben wir die Funktion Addition(4.2, 6, 10) aufgerufen . Der erste übergebene Parameter ist vom Typ Integer und die übrigen Parameter sind vom Datentyp Double (4.2, 6, 10), daher wird dieses Mal Methode 2 aufgerufen .

• Auf diese Weise erreicht Java eine Funktionsüberladung basierend auf einer unterschiedlichen Anzahl von Parametern sowie unterschiedlichen Datentypen der entsprechenden Parameter.

Notiz. Eine Funktion kann nicht allein aufgrund des Rückgabetyps der Funktion überladen werden.

Laufzeitpolymorphismus

Diese Option wird auch als dynamische Verknüpfung bezeichnet. Dabei ist der Aufruf einer für eine andere Funktion erstellten Funktion nur zur Laufzeit zulässig. Wir können eine dynamische Bindung in Java durch Methodenüberschreiben erreichen.

Überschreibende Methode

Das Überschreiben von Methoden in Java erfolgt, wenn eine Methode in einer Basisklasse eine Definition in einer abgeleiteten Klasse hat. Eine Basisklassenmethode oder -funktion wird als überschriebene Methode bezeichnet.

// Class 1
class Parent {

    // Print method
    void Print()
    {

        // Print statement
        System.out.println("Inside Parent Class");
    }
}

// Class 2
class Child1 extends Parent {

    // Print method
    void Print() { System.out.println("Inside Child1 Class"); }
}

// Class 3
class Child2 extends Parent {

    // Print method
    void Print()
    {
        // Print statement
        System.out.println("Inside Child2 Class");
    }
}

class Main {

    public static void main(String args[]) {

        // Creating an object of class Parent
        Parent parent = new Parent();
        parent.Print();

        // Calling print methods
        parent = new Child1();
        parent.Print();

        parent = new Child2();
        parent.Print();
    }
}

Sie können das obige Programm hier ausführen . Programmerklärung:

• Das obige Programm besteht aus drei Klassen: Parent ( Klasse 1 ), Child1 ( Klasse 2 ) und Child2 ( Klasse 3 ). Klasse 2 und Klasse 3 erben Klasse 1 .

• Parent hat eine Methode namens Print() . Innerhalb dieser Funktion geben wir „ Inside Parent Class “ aus. Child1 und Child2 verfügen außerdem über Print()- Funktionen , die grundsätzlich die Print()- Funktion der Parent- Klasse überschreiben und „ Inside Child1 Class “ bzw. „ Inside Child2 Class “ auf der Konsole ausgeben.

• Aus der Hauptfunktion erstellen wir zunächst ein Objekt der übergeordneten Klasse namens parent. Anschließend verwenden wir dieses Objekt, um die Druckmethode der übergeordneten Klasse aufzurufen . Daher wird „ Inside Parent Class “ auf der Konsole gedruckt.

• Danach rufen wir den Standardkonstruktor der Klasse Child1 auf und rufen die Funktion Print() auf . Beachten Sie, dass jetzt die in der Klasse Child1 definierte Print()- Methode aufgerufen wird , da wir die Print()- Methode der übergeordneten Klasse überschrieben haben . Daher wird „ Inside Child1 Class “ auf der Konsole gedruckt.

• Abschließend rufen wir den Standardkonstruktor der Klasse Child2 auf und rufen die Funktion Print() auf . Hier wird die in der Klasse Child2 definierte Print()- Methode aufgerufen , da wir die Print()- Methode der übergeordneten Klasse überschrieben haben . Daher wird „ Inside Child2 Class “ auf der Konsole gedruckt.

• Auf diese Weise wird das Überschreiben von Methoden in Java erreicht.

Ergebnisse

In diesem Artikel haben wir gelernt, was Polymorphismus in Java ist. Anschließend haben wir uns eingehender mit dem Thema befasst und zwei Arten von Polymorphismus in Java besprochen: Polymorphismus zur Kompilierungszeit und Polymorphismus zur Laufzeit. Wir haben anhand von Programmen demonstriert, wie statisches und dynamisches Binden in Java erreicht werden kann.

For-Schleife in Java + Beispiel für die forEach-Schleifensyntax

Quelle: FreeCodeCamp Eine Schleife in der Programmierung ist eine Folge von Anweisungen, die kontinuierlich ausgeführt werden, bis eine bestimmte Bedingung erfüllt ist. In diesem Artikel erfahren Sie mehr über for- und forEach- Schleifen in Java.

For-Schleifensyntax in Java

Hier ist die Syntax zum Erstellen einer for- Schleife :

for (initialization; condition; increment/decrement) {
   // code to be executed
}

Schauen wir uns einige der Schlüsselwörter im Code an:

• for gibt an, dass wir eine Schleife erstellen werden. Es folgen Klammern, die alles enthalten, was wir brauchen, damit unsere Schleife funktioniert.

• Die Initialisierung definiert die Anfangsvariable als Startpunkt der Schleife, normalerweise eine Ganzzahl.

• Bedingung gibt an, wie oft die Schleife ausgeführt werden soll.

• Inkrementieren / Dekrementieren erhöht/dekrementiert den Wert der Anfangsvariablen jedes Mal, wenn die Schleife ausgeführt wird. Wenn der Wert der Variablen zunimmt/abnimmt, tendiert sie zum angegebenen Zustand.

• Beachten Sie, dass jedes Schlüsselwort durch ein Semikolon ( ; ) getrennt ist.

Hier sind einige Beispiele:

for(int x = 1; x <=5; x++) {
  System.out.println(x);
}

/*
1
2
3
4
5
*/

Im obigen Beispiel ist die Startvariable x mit einem Wert von 1. Die Schleife läuft weiter, solange der Wert von x kleiner oder gleich 5 ist – das ist die Bedingung. x++ erhöht den Wert von x nach jedem Lauf. Wir druckten weiterhin den Wert von x aus , der nach 5 stoppt, weil die Bedingung erfüllt war. Eine Erhöhung auf 6 ist nicht möglich, da dieser größer als und ungleich 5 ist. Im folgenden Beispiel verwenden wir eine for- Schleife , um alle Werte in einem Array auszugeben.

int[] randomNumbers = {2, 5, 4, 7};
for (int i = 0; i < randomNumbers.length; i++) {
  System.out.println(randomNumbers[i]);
}

// 2
// 5
// 4
// 7

Dies entspricht fast dem letzten Beispiel. Hier haben wir die Länge des Arrays als Bedingung und den Anfangswert der Variablen als Null verwendet, da die Ordnungszahl des ersten Elements des Arrays Null ist.

forEach-Schleifensyntax in Java

Die forEach- Schleife wird speziell zum Durchlaufen der Elemente eines Arrays verwendet. So sieht seine Syntax aus:

for (dataType variableName : arrayName) {
  // code to be executed
}

Sie werden feststellen, dass die Syntax hier kürzer ist als die der for- Schleife . Und auch die forEach- Schleife beginnt mit dem for- Schlüsselwort . Anstatt eine Variable mit einem Wert zu initialisieren, geben wir zunächst den Datentyp an (er muss mit dem Datentyp des Arrays übereinstimmen). Darauf folgen der Name unserer Variablen und der Name des Arrays , getrennt durch einen Doppelpunkt. Hier ist ein Beispiel, das Ihnen hilft, die Syntax besser zu verstehen:

int[] randomNumbers = {2, 5, 4, 7};
for (int x : randomNumbers) {
  System.out.println(x + 1);
}

/*
3
6
5
8
*/

In diesem Beispiel haben wir jedes Element durchlaufen und seinen Anfangswert um 1 erhöht. Standardmäßig stoppt die Schleife, sobald sie alle Elemente des Arrays durchlaufen hat. Das bedeutet, dass wir unserer Variablen keinen Wert übergeben oder eine Bedingung für das Ende der Schleife angeben müssen.

Abschluss

In diesem Artikel haben wir gelernt, was Schleifen sind und welche Syntax zum Erstellen von for- und forEach- Schleifen in Java verwendet wird. Wir haben auch einige Beispiele gesehen, die uns geholfen haben zu verstehen, wann und wie man sie verwendet. Viel Spaß beim Codieren!