Passare Oggetti come Parametri in Java

Concetti Chiave

In Java, gli oggetti possono essere passati come parametri ai metodi, consentendo una maggiore flessibilità e riutilizzo del codice.
Gli oggetti passati come parametri possono essere utilizzati per confrontare istanze di classi definite dall'utente, come dimostrato nel metodo ugualeA() della classe Test.
È possibile definire costruttori che accettano oggetti della propria classe come parametri, permettendo di creare nuovi oggetti basati su altri esistenti.
Il passaggio di oggetti come parametri è un concetto fondamentale nella programmazione orientata agli oggetti, che consente di sfruttare al meglio le classi e gli oggetti in Java.

Utilizzare Oggetti come Parametri

Finora sono stati utilizzati solo tipi semplici come parametri dei metodi, ossia tipi primitivi.

Tuttavia, Java consente di utilizzare anche oggetti come parametri dei metodi. Questo è un concetto fondamentale nella programmazione orientata agli oggetti, poiché consente di passare istanze di classi definite dall'utente ai metodi, permettendo così una maggiore flessibilità e riutilizzo del codice.

Per esempio, si consideri il seguente breve programma:

// Gli oggetti possono essere passati ai metodi.
class Test {
    int a, b;

    Test(int i, int j) {
        a = i;
        b = j;
    }

    // restituisce true se o è uguale all'oggetto invocante
    boolean ugualeA(Test o) {
        if(o.a == a && o.b == b) return true;
        else return false;
    }
}

class PassaOggetto {
    public static void main(String[] args) {
        Test ogg1 = new Test(100, 22);
        Test ogg2 = new Test(100, 22);
        Test ogg3 = new Test(-1, -1);

        System.out.println("ogg1 == ogg2: " + ogg1.ugualeA(ogg2));
        System.out.println("ogg1 == ogg3: " + ogg1.ugualeA(ogg3));
    }
}

Questo programma genera il seguente output:

ogg1 == ogg2: true
ogg1 == ogg3: false

Come si può vedere, il metodo ugualeA() all'interno della classe Test confronta due oggetti per verificarne l'uguaglianza e restituisce il risultato.

Cioè, confronta l'oggetto invocante con quello che gli viene passato. Se contengono gli stessi valori, allora il metodo restituisce true. Altrimenti, restituisce false.

Si noti che il parametro o nel metodo ugualeA() specifica Test come tipo. Anche se Test è una classe definita dal programma, viene utilizzata nello stesso modo dei tipi incorporati in Java.

Uno degli usi più comuni dei parametri oggetto riguarda i costruttori. Frequentemente, può essere utile costruire un nuovo oggetto in modo che inizialmente sia uguale a un altro oggetto esistente. Per fare ciò, è necessario definire un costruttore che accetti un oggetto della propria classe come parametro.

Per esempio, la seguente versione della classe Scatola consente a un oggetto di inizializzarne un altro:

// Qui, Scatola permette a un oggetto di inizializzarne un altro.

class Scatola {
    double larghezza;
    double altezza;
    double profondita;

    // Si noti questo costruttore. Prende un oggetto di tipo Scatola.
    Scatola(Scatola ob) { // passa oggetto al costruttore
        larghezza = ob.larghezza;
        altezza = ob.altezza;
        profondita = ob.profondita;
    }

    // costruttore usato quando tutte le dimensioni sono specificate
    Scatola(double l, double a, double p) {
        larghezza = l;
        altezza = a;
        profondita = p;
    }

    // costruttore usato quando non sono specificate dimensioni
    Scatola() {
        larghezza = -1;  // usa -1 per indicare
        altezza = -1;    // una scatola
        profondita = -1; // non inizializzata
    }

    // costruttore usato quando viene creato un cubo
    Scatola(double lato) {
        larghezza = altezza = profondita = lato;
    }

    // calcola e restituisce il volume
    double volume() {
        return larghezza * altezza * profondita;
    }
}

class OverloadingCostruttori {
    public static void main(String[] args) {
        // crea scatole usando i vari costruttori
        Scatola miaScatola1 = new Scatola(10, 20, 15);
        Scatola miaScatola2 = new Scatola();
        Scatola mioCubo = new Scatola(7);

        Scatola mioClone = new Scatola(miaScatola1); // crea copia di miaScatola1

        double vol;

        // ottieni volume della prima scatola
        vol = miaScatola1.volume();
        System.out.println("Il volume di miaScatola1 è " + vol);

        // ottieni volume della seconda scatola
        vol = miaScatola2.volume();
        System.out.println("Il volume di miaScatola2 è " + vol);

        // ottieni volume del cubo
        vol = mioCubo.volume();
        System.out.println("Il volume del cubo è " + vol);

        // ottieni volume del clone
        vol = mioClone.volume();
        System.out.println("Il volume del clone è " + vol);
    }
}

Come si vedrà quando si inizierà a creare le proprie classi, fornire molteplici forme di costruttori è solitamente necessario per consentire agli oggetti di essere costruiti in maniera conveniente ed efficiente.