Programmazione e algoritmi 2

Utilizzando il metodo costruttore sarà possibile allocare le due variabili una sola volta e i vari metodi chiamati leggeranno semplicemente il contenuto delle variabili d'istanza senza costruirne una copia. Vediamo dunque il codice di esempio:

public class OperazioniSuNumeri {
    //campi
    //variabili di ISTANZA
    public numeroX;
    public numeroY;
    
    public OperazioniSuNumeri(int x, int y) { //costruttore
        numeroX=x;
        numeroY=y;
    }
    
    public int sottrazione() {
        int sottrazione;
        sottrazione=numeroX-numeroY;
        return sottrazione;
    }
    
    public int somma() {
        int somma;
        somma=numeroX+numeroY;
        return somma;
    }
    
    // gli altri metodi con la stessa struttura
}

E il codice per istanziare l'oggetto e la chiamata dei metodi sarà:

public class Implementazione {
    public static void Main(String args[]) {
        //Istanza della classe OperazionisuNumeri
        OperazioniSuNumeri operazioni;
        operazioni = new OperazioniSuNumeri(10,2);
        
        int sottrazione = operazioni.sottrazione(); //richiamo il metodo sottrazione
        int somma = operazioni.somma(); //richiamo il metodo somma
    }
}

il metodo somma

//stampo a video i risultati ottenuti

System.out.println(somma);

System.out.println(sottrazione);

La prima parola chiave nei costruttori è this:

1. Riferimento all'oggetto corrente;
2. Non si può usare in metodi static;
3. Normalmente è implicito.

La seconda parola chiave nei costruttori è super:

Il costruttore di una qualunque classe, come prima istruzione richiama il costruttore della superclasse a cui fa riferimento. Per esempio se istanziamo un oggetto di tipo "ResponsabileDiProgetto", il costruttore chiamerà automaticamente il costruttore della superclasse relativa, ovvero chiamerà il costruttore della classe "Dipendente" (se non è presente nessun costruttore viene richiamo il costruttore di default).

Sottolineiamo che la chiamata al costruttore della superclasse, in java, è una cosa inevitabile. Vediamo però come può essere gestita questa apparente limitazione utilizzando il

può essere inizializzato una sola volta (tipicamente dacostruttori);

rende le variabili di un metodo non modificabili;

nei campi di istanza rende gli oggetti immutabili;

una classe con tutti i campi di istanza final può essere istanziata creando oggetti immutabili;

nei metodi di istanza rende il metodo non sovrascrivibile in overriding.

Può essere utilizzato come campo di istanza di una classe.

La classe String oggetti immutabili.

La classe ArrayList

• versione dinamica dei classici array;
• libreria classe del java.

La gerarchia delle classi in Java

In java tutte le classi estendono direttamente o indirettamente e implicitamente o esplicitamente la classe Object (classe superiore a tutte), quindi tutte le volte che creiamo una classe senza ereditarietà è come se ereditassimo la classe Object che il Java ci mette a disposizione.

Es.

Class A extends Object {…}

Ogni variabile di tipo statico riferimento ha in realtà 2 tipi:

tipo statico: quello della dichiarazione, noto al compilatore;

tipo dinamico (perché può variare) es. tipo dinamico di b2 → B

tipo dinamico A a3 → null (non c'è)

Il polimorfismo: overloading e overriding

La parola polimorfismo indica la possibilità per uno stesso oggetto di assumere più forme; quindi l'attitudine di un oggetto a mostrare più implementazioni per una singola funzionalità.

In altre parole, potremmo dire che il polimorfismo consente ad oggetti differenti (ma collegati tra loro) la flessibilità di rispondere in modo diverso allo stesso tipo di messaggio.

Per chiarire il concetto possiamo fare un semplice esempio di applicazione del polimorfismo nella vita reale: quando facciamo riferimento ad un computer probabilmente useremo lo stesso termine (computer, appunto) sia per identificare un computer desktop, un portatile o un netbook. Questo tipo di generalizzazione viene effettuata in quanto gli

oggetti cui abbiamo fatto riferimento sostanzialmente effettuano le stesse operazioni...ma queste operazioni vengono fatte da oggetti con forme diverse (polimorfismo).

Polimorfismo dei metodi:

Dal punto di vista implementativo il polimorfismo per i metodi si ottiene utilizzando l'overload e l'override dei metodi stessi.

Un metodo è univocamente determinato se prendiamo in considerazione sia il suo nome che la lista di tutti i suoi parametri. Ciò permette, di fatto, di avere all'interno di una classe più metodi che hanno lo stesso nome, ma con parametri diversi.

L'overload quindi si basa sulla scrittura di più metodi identificati dallo stesso nome che però hanno, in ingresso, parametri di tipo e numero diverso.

Es.

public class OperazioniSuNumeri {
    public int somma(int x, int y) {
        return x+y;
    }
    public float somma(float x, float y) {
        return x-y;
    }
}

Dal punto di vista implementativo dunque non ci dovremo assolutamente preoccupare di effettuare controlli

public class Dipendente{
    private String nome;
    private String cognome;
    private int oreLavorativeMensili;
    private int retribuzioneOraria;

    public int getOreLavorativeMensili(){
        return oreLavorativeMensili;
    }

    public int getRetribuzioneOraria(){
        return retribuzioneOraria;
    }

    public int stipendio(){
        return oreLavorativeMensili * retribuzioneOraria;
    }
}

public class ResponsabileDiProgetto extends Dipendente {
    private int bonus;

    public int stipendio(){
        int stipendioBase = (getOreLavorativeMensili() * getRetribuzioneOraria());
        return stipendioBase + bonus;
    }
}