nuovo java

package com.claudiodesio.osservatorio.dati;

public enum Stato {

    IN_ATTESA("\"Sono in attesa...\""),
    OSSERVAZIONE("\"Tocca a me... che meraviglia!\""),
    FINITO("\"Ho finito.\"");

    private String messaggio;

    private Stato(String messaggio) {
        this.messaggio = messaggio;
    }

    public String getMessaggio() {
        return messaggio;
    }
}

package com.claudiodesio.osservatorio.dati;

public class Partecipante extends Thread {

    private final String nome;

    private Stato stato;

    private final Telescopio telescopio;

    public Telescopio getTelescopio() {
        return telescopio;
    }

    public Partecipante(String nome, Telescopio telescopio) {
        this.nome = nome;
        this.telescopio = telescopio;
        this.setStato(Stato.IN_ATTESA);
        stato();
    }

    public Stato getStato() {
        return stato;
    }

    public void setStato(Stato stato) {
        this.stato = stato;
    }

    public String getNome() {
        return nome;
    }

    @Override
    public void run() {
        telescopio.permettiOsservazione(this);
    }

    public void stato() {
        System.out.println(nome + " dice: " + stato.getMessaggio());
    }
}

package com.claudiodesio.osservatorio.dati;

public class Telescopio {

    public synchronized void permettiOsservazione(Partecipante partecipante) {
        partecipante.setStato(Stato.OSSERVAZIONE);
        partecipante.stato();
        try {
            Thread.sleep(3000);
        } catch (InterruptedException ex) {
            ex.printStackTrace();
        }
        partecipante.setStato(Stato.FINITO);
        partecipante.stato();
    }
}

package com.claudiodesio.osservatorio.test;

import com.claudiodesio.osservatorio.dati.Partecipante;
import com.claudiodesio.osservatorio.dati.Telescopio;

public class Osservazione {

    public static void main(String args[]) {
        Telescopio telescopio = new Telescopio();
        Partecipante[] partecipanti = getPartecipanti(telescopio);
        for (Partecipante partecipante : partecipanti) {
            partecipante.start();
        }
    }

    private static Partecipante[] getPartecipanti(Telescopio telescopio) {
        Partecipante[] partecipanti = {
            new Partecipante("Ciro", telescopio),
            new Partecipante("Gianluca", telescopio),
            new Partecipante("Pierluigi", telescopio),
            new Partecipante("Gigi", telescopio),
            new Partecipante("Nicola", telescopio),
            new Partecipante("Pino", telescopio),
            new Partecipante("Maurizio", telescopio),
            new Partecipante("Raffaele", telescopio),
            new Partecipante("Fabio", telescopio),
            new Partecipante("Vincenzo", telescopio)};
        return partecipanti;
    }
}

Ciro dice: "Sono in attesa..."
Gianluca dice: "Sono in attesa..."
Pierluigi dice: "Sono in attesa..."
Gigi dice: "Sono in attesa..."
Nicola dice: "Sono in attesa..."
Pino dice: "Sono in attesa..."
Maurizio dice: "Sono in attesa..."
Raffaele dice: "Sono in attesa..."
Fabio dice: "Sono in attesa..."
Vincenzo dice: "Sono in attesa..."
Ciro dice: "Tocca a me... che meraviglia!"
Ciro dice: "Ho finito."
Vincenzo dice: "Tocca a me... che meraviglia!"
Vincenzo dice: "Ho finito."
Maurizio dice: "Tocca a me... che meraviglia!"
Maurizio dice: "Ho finito."
Pino dice: "Tocca a me... che meraviglia!"
Pino dice: "Ho finito."
Fabio dice: "Tocca a me... che meraviglia!"
Fabio dice: "Ho finito."
Gigi dice: "Tocca a me... che meraviglia!"
Gigi dice: "Ho finito."
Nicola dice: "Tocca a me... che meraviglia!"
Nicola dice: "Ho finito."
Raffaele dice: "Tocca a me... che meraviglia!"
Raffaele dice: "Ho finito."
Pierluigi dice: "Tocca a me... che meraviglia!"
Pierluigi dice: "Ho finito."
Gianluca dice: "Tocca a me... che meraviglia!"
Gianluca dice: "Ho finito."

package com.claudiodesio.sportello.dati;

import java.util.*;

public class TimeUtils {

    private static final Random RANDOM = new Random();

    public static int getNumeroRandom() {
        return (RANDOM.nextInt(6) + 5);
    }
}

package com.claudiodesio.sportello.dati;

public class Richiedente extends Thread {

    private final String nome;

    public Richiedente(String nome) {
        this.nome = nome;
    }

    public String getNome() {
        return nome;
    }

    @Override
    public void run() {
        Sportello.getInstance().gestisciRichiesta(this);
    }

    @Override
    public String toString() {
        return nome;
    }
}

package com.claudiodesio.sportello.dati;

public class Stampante {

    private static Stampante instance;

    private Stampante() {
    }

    public static Stampante getInstance() {
        if (instance == null) {
            instance = new Stampante();
        }
        return instance;
    }

    public synchronized void stampa(Richiedente richiedente) {
        System.out.println("Stampa carta d'identità di " + richiedente
          + " in corso...");
        try {
            wait(3000);
        } catch (InterruptedException ex) {
            ex.printStackTrace();
        }
        System.out.println("Stampa completata! " + richiedente
          + " grazie e arrivederci!");
    }
}

package com.claudiodesio.sportello.dati;

public class Sportello {

    private final Stampante stampante;
    private static Sportello instance;

    public synchronized static Sportello getInstance() {
        if (instance == null) {
            instance = new Sportello();
        }
        return instance;
    }

    private Sportello() {
        stampante = Stampante.getInstance();
    }

    public synchronized void gestisciRichiesta(Richiedente richiedente) {
        System.out.println("Buongiorno " + richiedente);
        System.out.println("Impiegato dice: \"Prego compili il modulo "
          + richiedente + "\"");
        compilaModulo(richiedente);
        stampante.stampa(richiedente);
        System.out.println(richiedente + " dice: \"Grazie a lei!\"");
    }

    private synchronized void compilaModulo(Richiedente richiedente) {
        System.out.println("Richiedente " + richiedente
          + " dice: \"OK lo compilo subito ma...\"");
        final int attesa = TimeUtils.getNumeroRandom();
        try {
            System.out.println("...mi servono " + attesa + " minuti...");
            wait(attesa * 1000);
        } catch (InterruptedException ex) {
            ex.printStackTrace();
        }
        System.out.println("Richiedente " + richiedente
          + " dice: \"...ho compilato il modulo!\"");
    }
}

package com.claudiodesio.sportello.test;

import com.claudiodesio.sportello.dati.Richiedente;

public class TestSportello {

    public static void main(String args[]) {
        final Richiedente[] richiedenti = getRichiedenti();
        for (Richiedente richiedente : richiedenti) {
            richiedente.start();
        }
    }

    private static Richiedente[] getRichiedenti() {
        Richiedente[] partecipanti = {
            new Richiedente("Ciro"),
            new Richiedente("Mario"),
            new Richiedente("Massimo"),
            new Richiedente("Chicco"),
            new Richiedente("Enrico"),
            new Richiedente("Lorenzo"),
            new Richiedente("Emanuele"),
            new Richiedente("Cosimo"),
            new Richiedente("Alessandro"),
            new Richiedente("Salvatore")};
        return partecipanti;
    }
}

Buongiorno Ciro
Impiegato dice: "Prego compili il modulo Ciro"
Richiedente Ciro dice: "OK lo compilo subito ma..."
...mi servono 9 minuti...
Buongiorno Salvatore
Impiegato dice: "Prego compili il modulo Salvatore"
Richiedente Salvatore dice: "OK lo compilo subito ma..."
...mi servono 9 minuti...
Buongiorno Cosimo
Impiegato dice: "Prego compili il modulo Cosimo"
Richiedente Cosimo dice: "OK lo compilo subito ma..."
...mi servono 7 minuti...
Buongiorno Mario
Impiegato dice: "Prego compili il modulo Mario"
Richiedente Mario dice: "OK lo compilo subito ma..."
...mi servono 7 minuti...
Buongiorno Chicco
Impiegato dice: "Prego compili il modulo Chicco"
Richiedente Chicco dice: "OK lo compilo subito ma..."
...mi servono 5 minuti...
Buongiorno Alessandro
Impiegato dice: "Prego compili il modulo Alessandro"
Richiedente Alessandro dice: "OK lo compilo subito ma..."
...mi servono 9 minuti...
Buongiorno Enrico
Impiegato dice: "Prego compili il modulo Enrico"
Richiedente Enrico dice: "OK lo compilo subito ma..."
...mi servono 8 minuti...
Buongiorno Massimo
Impiegato dice: "Prego compili il modulo Massimo"
Richiedente Massimo dice: "OK lo compilo subito ma..."
...mi servono 8 minuti...
Buongiorno Lorenzo
Impiegato dice: "Prego compili il modulo Lorenzo"
Richiedente Lorenzo dice: "OK lo compilo subito ma..."
...mi servono 5 minuti...
Buongiorno Emanuele
Impiegato dice: "Prego compili il modulo Emanuele"
Richiedente Emanuele dice: "OK lo compilo subito ma..."
...mi servono 9 minuti...
Richiedente Lorenzo dice: "...ho compilato il modulo!"
Stampa carta d'identità  di Lorenzo in corso...
Stampa completata! Lorenzo grazie e arrivederci!
Lorenzo dice: "Grazie a lei!"
Richiedente Massimo dice: "...ho compilato il modulo!"
Stampa carta d'identità  di Massimo in corso...
Stampa completata! Massimo grazie e arrivederci!
Massimo dice: "Grazie a lei!"
Richiedente Enrico dice: "...ho compilato il modulo!"
Stampa carta d'identità  di Enrico in corso...
Stampa completata! Enrico grazie e arrivederci!
Enrico dice: "Grazie a lei!"
Richiedente Mario dice: "...ho compilato il modulo!"
Stampa carta d'identità  di Mario in corso...
Stampa completata! Mario grazie e arrivederci!
Mario dice: "Grazie a lei!"
Richiedente Cosimo dice: "...ho compilato il modulo!"
Stampa carta d'identità  di Cosimo in corso...
Stampa completata! Cosimo grazie e arrivederci!
Cosimo dice: "Grazie a lei!"
Richiedente Chicco dice: "...ho compilato il modulo!"
Stampa carta d'identità  di Chicco in corso...
Stampa completata! Chicco grazie e arrivederci!
Chicco dice: "Grazie a lei!"
Richiedente Emanuele dice: "...ho compilato il modulo!"
Stampa carta d'identità  di Emanuele in corso...
Stampa completata! Emanuele grazie e arrivederci!
Emanuele dice: "Grazie a lei!"
Richiedente Salvatore dice: "...ho compilato il modulo!"
Stampa carta d'identità  di Salvatore in corso...
Stampa completata! Salvatore grazie e arrivederci!
Salvatore dice: "Grazie a lei!"
Richiedente Alessandro dice: "...ho compilato il modulo!"
Stampa carta d'identità  di Alessandro in corso...
Stampa completata! Alessandro grazie e arrivederci!
Alessandro dice: "Grazie a lei!"
Richiedente Ciro dice: "...ho compilato il modulo!"
Stampa carta d'identità  di Ciro in corso...
Stampa completata! Ciro grazie e arrivederci!
Ciro dice: "Grazie a lei!"

Esercizio12E.java:3: warning: [rawtypes] found raw type: ArrayList
class RunnableArrayList extends ArrayList implements Runnable {
                                ^
  missing type arguments for generic class ArrayList<E>
  where E is a type-variable:
    E extends Object declared in class ArrayList
Esercizio12E.java:3: error: RunnableArrayList is not abstract and does
  not override abstract method run() in Runnable
class RunnableArrayList extends ArrayList implements Runnable {
^
Esercizio12E.java:3: warning: [serial] serializable class
  RunnableArrayList has no definition of serialVersionUID
class RunnableArrayList extends ArrayList implements Runnable {
^
1 error
2 warnings

public class ContoAllaRovescia {

    public void attiva(int secondi) throws InterruptedException {
        for (int i = secondi; i > 0; i--) {
            System.out.println(i);
            Thread.sleep(1000);
        }
        System.out.println("Tempo scaduto!");
    }
}

public class Esercizio12H {
    public static void main(String args[]) throws Exception {
        ContoAllaRovescia contoAllaRovescia = new ContoAllaRovescia();
        int secondi = 10;
        if (args.length > 0) {
            try {
                secondi = Integer.parseInt(args[0]);
            }
            catch (Exception exc) {
                System.out.println("L'input deve essere un numero "
                  + "intero positivo, usiamo il valore di default 10...");
            }
        }
        contoAllaRovescia.attiva(secondi);
    }
}

10
9
8
7
6
5
4
3
2
1
Tempo scaduto!

3
2
1
Tempo scaduto!

L'input deve essere un numero intero positivo, usiamo il valore di default 10...
10
9
8
7
6
5
4
3
2
1
Tempo scaduto!

Tempo scaduto!

public class Corridore extends Thread {

    private boolean viaLibera;

    private boolean inAzione;

    private int gap;

    public Corridore() {
        inAzione = true;
        gap = 1000;
    }

    public void run() {
        while (inAzione) {
            try {
                Thread.sleep(gap);
                if (viaLibera) {
                    System.out.println("|");
                    Thread.sleep(gap);
                    System.out.println("  |");
                }
            } catch (InterruptedException exc) {
                assert false;
            }
        }
    }

    public void inizia() {
        start();
    }

    public void corri() {
        System.out.println("Ok, vado...");
        gap = 400;
        viaLibera = true;
    }

    public void fermati() {
        System.out.println("Ok, mi fermo.");
        System.out.println("| |");
        viaLibera = false;
    }

    public void cammina() {
        System.out.println("Ok, mi riposo un po'...");
        gap = 1000;
        viaLibera = true;
    }

    public void basta() {
        System.out.println("Meno male, non ce la facevo più...");
        inAzione = false;
    }
}

import java.util.Scanner;

public class Esercizio12L {
    public static void main(String args[]) {
        Corridore corridore = new Corridore();
        corridore.inizia();
        Scanner scanner = new Scanner(System.in);
        boolean cicla = true;
        System.out.println(
           "Ciao allenatore, il corridore è a tua disposizione!");
        System.out.println("Scrivi i comandi e batti invio");
        System.out.println("(corri, cammina, fermati, basta)");
        while (cicla) {

            String comando = scanner.nextLine();
            switch (comando) {
                case"corri":
                    corridore.corri();
                break;
                case"cammina":
                    corridore.cammina();
                break;
                case"fermati":
                    corridore.fermati();
                break;
                case"basta":
                    corridore.basta();
                    cicla = false;
                break;

                default:
                break;
            }
        }
        try {
            Thread.sleep(2000);
        }
        catch (Exception exc) {
            assert false;
        }
        System.out.println("Fine allenamento");
    }
}

Ciao allenatore, il corridore è a tua disposizione!
Scrivi i comandi e batti invio
(corri, cammina, fermati, basta)
corri
Ok, vado...
|
  |
|
  |
|
  |
|
  |
c|
a  |
mmi|
na  |
|

Ok, mi riposo un po'...
  |
|
  |
|
  |
ferm|
ati  |

Ok, mi fermo.
| |
corri
Ok, vado...
|
  |
|
  |
|
  |
ca|
  |
mm|
ina  |
|
  |
|

Ok, mi riposo un po'...
  |
|
  |
|
fe  |
rmat|
i
Ok, mi fermo.
| |
basta
Meno male, non ce la facevo più...
Fine allenamento

import java.util.Date;

public final class Esercizio12R {

    private final Integer intero;

    private final Date date;

    public Esercizio12R(Integer intero, Date date) {
        this.intero = intero;
        this.date = (Date)date.clone();
    }

    public final Date getStringBuilder() {
        return (Date)date.clone();
    }

    public final Integer getIntero() {
        return intero;
    }
}

Esercizio12T.java:6: error: <anonymous Esercizio12T$1> is not abstract
  and does not override abstract method call() in Callable
        Callable<String> callable = new Callable<>() {public void 
  call(){}};
                                                     ^
Esercizio12T.java:6: error: call() in <anonymous Esercizio12T$1> 
  cannot implement call() in Callable
        Callable<String> callable = new Callable<>() {public void 
  call(){}};
                                                                  ^
  return type void is not compatible with String
  where V is a type-variable:
    V extends Object declared in interface Callable
Esercizio12T.java:7: error: cannot find symbol
        Future<String> future =
  Executors.newFixedThreadPool(3).start(callable);
                                                               ^
  symbol:   method start(Callable<String>)
  location: interface ExecutorService
3 errors

Callable<String> callable = new Callable<>() {
    public String call(){return "";}
};
ExecutorService service = Executors.newFixedThreadPool(3);
Future<String> future = service.submit(callable);
String result = null;
try {
    result = future.get();
}
catch (Exception exc) {
    exc.printStackTrace();
}

import java.time.format.*;

public class Esercizio12U extends TimerTask {

    private Timer timer;

    public Esercizio12U() {
        timer = new Timer();
    }

    @Override
    public void run() {
        DateTimeFormatter timeFormatter =
            DateTimeFormatter.ofLocalizedTime(FormatStyle.SHORT);
        System.out.println("Sveglia! Sono le " +
            timeFormatter.format(LocalTime.now()));
        timer.cancel();
    }

    public static void main(String args[]) throws Exception {
        int seconds = Integer.parseInt(args[0])*1000;
        Esercizio12U timerTask = new Esercizio12U();
        timerTask.timer.schedule(timerTask, seconds);
    }
}