Esercizio 1.

public class L {
    private int h;
    private L t;

    public L(int h, L t) {
	this.h = h;
	this.t = t;
    }

    public L merge(L other) {
	if (other == null) return this;
	else if (h <= other.h)
	    if (t != null) return new L(h,t.merge(other));
	    else return new L(h,other);
	else return new L(other.h,merge(other.t));
    }
}
===================================================
Esercizio 2:

import java.io.*;

public abstract class AbsLista {


    public abstract AbsLista tail();

    public int length() {
    
    //if (this == null) return 0;
    if (tail() == null) return 1;
    else return tail().length()+1;

    }

}

import java.io.*;

public class Lfloat extends AbsLista {
    public float h;
    public AbsLista t;

    public Lfloat(float h, Lfloat t) {
        this.h = h;
        this.t = t;
    }

    public float head() {
        return h;
    }

    public AbsLista tail() {
        return t;
    }
}

import java.io.*;

public class Lint extends AbsLista {
    public int h;
    public Lint t;

    public Lint(int h, Lint t) {
        this.h = h;
        this.t = t;
    }

    public int head() {
        return h;
    }

    public AbsLista tail() {
        return t;
    }

    public int somma() {
    if (tail() != null) return head()+((Lint) tail()).somma();
    // alternativamente: if (tail() != null) return head()+t.somma();
    else return head();
    }

}


===================================================
Esercizio 3:

La prima esecuzione stampa:

-3 valore negativo
0
2

poiche' la creazione dell'InteroNonNegativo dentro il blocco try
provoca un'eccezione che viene intercettata dal catch che ne stampa
il messaggio. Quindi crea un nuovo InteroNonNegativo con il costruttore senza
argomenti e ne stampa il valore 0. Quindi il blocco finally assegna 2
ad x e subito dopo si crea un InteroNonNegativo che contiene 2.

La seconda esecuzione stampa:

3
NegativeException "-2 valore negativo"
traccia di esecuzione

poiche' la creazione dell'InteroNonNegativo dentro al blocco try
avviene senza problemi creando un InteroNonNegativo che contiene 3.
Tale valore viene stampato e si esegue quindi il blocco finally che
assegna -2 ad x. La creazione dell'InteroNonNegativo n2 genera
un'eccezione che non e' intercettata da alcun catch, per cui il
programma si blocca a quel punto stampando il tipo di eccezione che
ha causato il blocco, il messaggio contenuto nell'eccezione e la
traccia di esecuzione fino al punto di blocco.