Pausa caffè #111. Polimorfismo e legame dinamico in Java. Ciclo for in Java + esempio di sintassi del ciclo forEach

Polimorfismo e legame dinamico in Java

Fonte: DZone Il polimorfismo è uno dei concetti fondamentali della programmazione orientata agli oggetti. Che tu sia nuovo alla programmazione Java o uno sviluppatore esperto, dovresti sapere cos'è il polimorfismo e come funziona. La maggior parte degli sviluppatori afferma di essere esperta in questo argomento, ma quando si tratta di altre funzionalità complesse come il legame statico e dinamico, molti di loro perdono la fiducia.

Cos'è il polimorfismo in Java?

Polimorfismo significa avere molte forme. Nella programmazione, ciò si riferisce alla capacità di un segnale o di un messaggio di apparire in più di una forma.

Esempio di vita reale

Una persona può presentare molte caratteristiche contemporaneamente. Ad esempio, una madre può essere contemporaneamente moglie, figlia, sorella, dipendente di un'azienda e così via. Pertanto, una persona può mostrare caratteristiche diverse in condizioni diverse. Questo è noto come polimorfismo.

L'importanza del polimorfismo

Il polimorfismo è una delle caratteristiche più importanti di qualsiasi linguaggio di programmazione orientato agli oggetti (ad esempio Java). Con l'aiuto del polimorfismo, lo stesso compito può essere eseguito in modi diversi.

Tipi di polimorfismo

In Java, il polimorfismo può essere diviso in due categorie:

1. Polimorfismo in fase di compilazione (collegamento statico)
2. Polimorfismo runtime (Runtime, associazione dinamica)

Polimorfismo in fase di compilazione

Il polimorfismo in fase di compilazione è noto anche come collegamento statico. Questo tipo di polimorfismo può essere ottenuto tramite sovraccarico di funzioni o sovraccarico di operatori. Ma in Java, questo è limitato all'overload delle funzioni poiché Java non supporta l'overload degli operatori. Sovraccarico di funzioni Quando ci sono almeno due funzioni o metodi con lo stesso nome di funzione, ma il numero di parametri che contengono è diverso, o almeno un tipo di dati del parametro corrispondente è diverso (o entrambi), allora si parla di funzione o sovraccarico del metodo e queste funzioni sono note come funzioni di sovraccarico. Esempio 1 Finora abbiamo studiato cos'è il sovraccarico di funzioni. Ora proviamo a dimostrare il sovraccarico delle funzioni del software.

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));

    }
}

È possibile eseguire il programma sopra qui . Spiegazione del programma:

• Il programma sopra è costituito da due funzioni statiche con gli stessi nomi: Addizione .

• In questo caso entrambe le funzioni contengono lo stesso numero di parametri, ma i parametri corrispondenti sono diversi.

• Il Metodo 1 accetta due parametri interi, mentre il Metodo 2 accetta due parametri double .

• Dalla funzione principale, chiamiamo prima la funzione Addizione(12, 14) . I parametri passati sono numeri interi (12 e 14), quindi qui verrà chiamato il Metodo 1 .

• Quindi abbiamo chiamato la funzione Addizione(15.2, 16.1) . Poiché i parametri passati sono di tipo dati doppio (15.2 e 16.1), questa volta verrà chiamato il Metodo 2 .

• Ecco come viene ottenuto l'overload delle funzioni in Java in base a diversi tipi di dati dei parametri.

Esempio 2 Considera il programma seguente:

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));

    }
}

È possibile eseguire il programma sopra qui . Spiegazione del programma:

• Il programma sopra è costituito da due funzioni statiche con gli stessi nomi: Addizione .

• In questo caso entrambe le funzioni contengono un numero diverso di parametri, ma il tipo di dati dei primi due parametri corrispondenti è lo stesso (numero intero).

• Il metodo 1 accetta due parametri interi e il metodo 2 accetta tre parametri di tipo dati interi.

• Dalla funzione principale, chiamiamo prima la funzione Addizione(2, 3) . Poiché i parametri passati sono numeri interi (2 e 3), qui chiameranno il Metodo 1 .

• Quindi abbiamo chiamato la funzione Addizione(4, 5, 6) . I parametri passati sono di tipo dati doppio (4, 5, 6), quindi questa volta chiameranno il Metodo 2 .

• Ecco come le funzioni vengono sovraccaricate in Java in base a un diverso numero di parametri.

Esempio 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));

    }
}

È possibile eseguire il programma sopra qui . Spiegazione del programma:

• Il programma sopra è costituito da due funzioni statiche con gli stessi nomi: Addizione .

• Entrambe le funzioni contengono un numero diverso di parametri e anche il tipo di dati del primo elemento corrispondente è diverso.

• Il Metodo 1 accetta due parametri interi, mentre il Metodo 2 accetta tre parametri: il primo è di tipo double e gli altri due sono di tipo intero.

• Dalla funzione principale, chiamiamo prima la funzione Addizione(2, 4) . Poiché i parametri passati sono numeri interi (2 e 4), qui chiameranno il Metodo 1 .

• Quindi abbiamo chiamato la funzione Addizione(4.2, 6, 10) . Il primo parametro passato è di tipo intero e i restanti parametri sono di tipo dati double (4.2, 6, 10), quindi questa volta verrà chiamato il Metodo 2 .

• In questo modo Java ottiene un sovraccarico delle funzioni basato su diversi numeri di parametri e diversi tipi di dati dei parametri corrispondenti.

Nota. Non è possibile eseguire l'overload di una funzione in base esclusivamente al tipo restituito della funzione.

Polimorfismo di runtime

Questa opzione è nota anche come collegamento dinamico. In questo processo, la chiamata di una funzione creata per un'altra funzione è consentita solo in fase di runtime. Possiamo ottenere l'associazione dinamica in Java utilizzando l'override del metodo.

Metodo prioritario

L'override del metodo in Java si verifica quando un metodo in una classe base ha una definizione in una classe derivata. Un metodo o una funzione della classe base è chiamato metodo sottoposto a override.

// 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();
    }
}

È possibile eseguire il programma sopra qui . Spiegazione del programma:

• Il programma di cui sopra è composto da tre classi: Parent ( classe 1 ), Child1 ( classe 2 ) e Child2 ( classe 3 ). La classe 2 e la classe 3 ereditano la classe 1 .

• Il genitore ha un metodo chiamato Print() . All'interno di questa funzione stampiamo " Inside Parent Class ". Child1 e Child2 hanno anche funzioni Print() , che sostanzialmente sovrascrivono la funzione Print() della classe Parent e stampano rispettivamente " Inside Child1 Class " e " Inside Child2 Class " sulla console.

• Dalla funzione main, creiamo prima un oggetto della classe genitore chiamato parent. Utilizziamo quindi questo oggetto per chiamare il metodo print della classe genitore . Pertanto sulla console verrà stampato " Inside Parent Class ".

• Successivamente, chiamiamo il costruttore predefinito della classe Child1 e chiamiamo la funzione Print() . Nota che il metodo Print() definito nella classe Child1 verrà ora chiamato perché abbiamo sovrascritto il metodo Print() della classe genitore . Pertanto, sulla console verrà stampato " Inside Child1 Class ".

• Infine, chiamiamo il costruttore predefinito della classe Child2 e chiamiamo la funzione Print() . Qui verrà chiamato il metodo Print() definito nella classe Child2 perché abbiamo sovrascritto il metodo Print() della classe genitore . Pertanto sulla console verrà stampato “ Inside Child2 Class ”.

• Questo è il modo in cui si ottiene l'override del metodo in Java.

Risultati

In questo articolo abbiamo imparato cos'è il polimorfismo in Java. Abbiamo quindi approfondito l'argomento e discusso due tipi di polimorfismo in Java: polimorfismo in fase di compilazione e polimorfismo in fase di esecuzione. Abbiamo dimostrato attraverso programmi come è possibile ottenere l'associazione statica e dinamica in Java.

Ciclo for in Java + esempio di sintassi del ciclo forEach

Fonte: FreeCodeCamp Un loop nella programmazione è una sequenza di istruzioni che vengono eseguite continuamente finché non viene soddisfatta una determinata condizione. In questo articolo impareremo i cicli for e forEach in Java.

Per la sintassi del loop in Java

Ecco la sintassi per creare un ciclo for :

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

Diamo un'occhiata ad alcune delle parole chiave nel codice:

• for indica che creeremo un ciclo. È seguito da parentesi, che contengono tutto ciò di cui abbiamo bisogno per far funzionare il nostro ciclo.

• l'inizializzazione definisce la variabile iniziale come punto di partenza del ciclo, solitamente un numero intero.

• condizione specifica quante volte il ciclo deve essere eseguito.

• incremento / decremento incrementa/diminuisce il valore della variabile iniziale ogni volta che viene eseguito il ciclo. Man mano che il valore della variabile aumenta/diminuisce, tende alla condizione specificata.

• Tieni presente che ciascuna parola chiave è separata da un punto e virgola ( ; ).

Ecco alcuni esempi:

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

/*
1
2
3
4
5
*/

Nell'esempio sopra, la variabile iniziale è x con un valore pari a 1. Il ciclo continuerà a funzionare finché il valore di x è inferiore o uguale a 5: questa è la condizione. x++ incrementa il valore di x dopo ogni esecuzione. Abbiamo continuato a stampare il valore di x che si ferma dopo 5 perché la condizione è stata soddisfatta. L'aumento a 6 non è possibile perché è maggiore e diverso da 5. Nell'esempio seguente utilizzeremo un ciclo for per stampare tutti i valori in un array.

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

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

Questo è quasi lo stesso dell'ultimo esempio. Qui abbiamo utilizzato la lunghezza dell'array come condizione e il valore iniziale della variabile come zero perché il numero ordinale del primo elemento dell'array è zero.

Sintassi del ciclo forEach in Java

Il ciclo forEach viene utilizzato specificamente per scorrere gli elementi di un array. Ecco come appare la sua sintassi:

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

Noterai che la sintassi qui è più breve del ciclo for . E anche il ciclo forEach inizia con la parola chiave for . Invece di inizializzare una variabile con un valore, specifichiamo prima il tipo di dati (deve corrispondere al tipo di dati dell'array). Questo è seguito dal nome della nostra variabile e dal nome dell'array , separati da due punti. Ecco un esempio per aiutarti a capire meglio la sintassi:

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

/*
3
6
5
8
*/

In questo esempio, abbiamo eseguito l'iterazione su ciascun elemento e incrementato il loro valore iniziale di 1. Per impostazione predefinita, il ciclo si interrompe una volta che ha eseguito l'iterazione su tutti gli elementi dell'array. Ciò significa che non è necessario passare alcun valore alla nostra variabile o specificare alcuna condizione affinché il ciclo termini.

Conclusione

In questo articolo abbiamo imparato cosa sono i loop e la sintassi per creare loop for e forEach in Java. Abbiamo visto anche alcuni esempi che ci hanno aiutato a capire quando e come utilizzarli. Buona programmazione!