Scrivere un programma che prende in input da tastiera un numero fissato di parole (per esempio 4) e stampa la prima e l’ultima parola secondo l’ordine lessicografico.

La classe OrdineLessicografico.java:

public class OdineLessicografico {
String prima;
String seconda;
String terza;
String quarta;

  // Metodo costruttore inizializzato con 4 Stringhe
  public OdineLessicografico(String p,String s,String t,String q)
  {
    prima = p;
    seconda = s;
    terza = t;
    quarta = q;
  }

  // Metodo che ordina in modo lessicografico la prima e la quarta parola
  public void ordina()
  {
    if (prima.compareTo(quarta)<0)
    {
      System.out.println(prima);
      System.out.println(quarta);
    }
    else
    {
      System.out.println(quarta);
      System.out.println(prima);
    }
  }
}

La classe di test:

import java.util.Scanner;
public class TestOrdine {

  public static void main(String[] args)
  {
    Scanner in = new Scanner(System.in);

    // Prendo in input 4 parole
    System.out.println("Dammi 4 parole (ognuna seguita dal tasto <invio>): ");
    String a = in.nextLine();
    String b = in.nextLine();
    String c = in.nextLine();
    String d = in.nextLine();

    // Creo un nuovo oggetto OrdineLessicografico
    OdineLessicografico x = new OdineLessicografico(a,b,c,d);

    // Chiamo il metodo ordina
    x.ordina();
  }
}

Scrivere un programma che stampi

• “OK” se legge “S” ,”SI”, “OK”, “certo” oppure “perche` no?”.
• “Fine” se legge “N” o “No”
• “Dato non corretto” altrimenti

A tal fine scrivere una classe InputChecker.

La classe InputChecker.java:

public class InputChecker {
String inp;

  // Metodo Costruttore
  public InputChecker(String v)
  {
    inp = v;
  }

  // Metodo che verifica l'input e stampa la relativa informazione
  public void verificaInput()
  {
    if(inp.equalsIgnoreCase("S") || inp.equalsIgnoreCase("SI") ||inp.equalsIgnoreCase("OK") || inp.equalsIgnoreCase("certo") || inp.equalsIgnoreCase("perchè no?"))
    {
      System.out.println("OK");
    }
    else
    {
      if(inp.equalsIgnoreCase("N") || inp.equalsIgnoreCase("No"))
      {
        System.out.println("Fine");
      }
      else
      {
        System.out.println("Dato non corretto");
      }
    }

  }
}

La classe di test:

import java.util.Scanner;
public class TestInputCheck {

  public static void main(String[] args)
  {
    Scanner in = new Scanner(System.in);

    // Prendo in input la parola da verificare
    System.out.println("Dammi l'input di verifica: ");
    String a = in.nextLine();

    // Creo un nuovo oggetto InputChecker
    InputChecker x = new InputChecker(a);

    // Verifico l'input
    x.verificaInput();
  }
}

Scrivere un programma che prende in input da tastiera 3 numeri in virgola mobile per poi stamparli in ordine crescente. Senza utilizzare cicli o strutture di appoggio.

La classe VirgolaMobile.java:

import java.util.Scanner;
public class VirgolaMobile
{
	public static void main(String[] args)
	{
		Scanner in = new Scanner(System.in);

		// Prendo in input 3 numeri in virgola mobile
		System.out.println("Dammi tre numeri in virgola mobile seguiti da <invio> :");
		double a = in.nextDouble();
		double b = in.nextDouble();
		double c = in.nextDouble();

		// Stampo a video i tre numeri in ordine decrescente
		System.out.println("Ecco i tre numeri in ordine descrescente:");
		if (a>b && a>c)
		{
			System.out.println(a);
			if( b>c)
			{
				System.out.println(b);
				System.out.println(c);
			}
			else
			{
				System.out.println(c);
				System.out.println(b);
		    }
		}
		else
		{
			if (b>a && b>c)
			{
				System.out.println(b);
				if (a>c)
				{
					System.out.println(a);
					System.out.println(c);
				}
				else
				{
					System.out.println(c);
					System.out.println(a);
				}

			}
			else
			{
				if (c>a && c>b)
				{
					System.out.println(c);
					if(a>b)
					{
						System.out.println(a);
						System.out.println(b);
					}
					else
					{
						System.out.println(b);
						System.out.println(a);
					}
				}
			}
		}
	}
}

Realizzare una classe Mesi i cui oggetti corrispondono ai mesi. Il costruttore riceve in input un parametro intero (il numero del mese) e la classe contiene un metodo getName() che restituisce il nome del mese.
Scrivere un programma per tradurre i numeri da 1 a 12 nei nomi dei mesi corrispondenti.

La classe Mesi.java:

public class Mesi {
int mese;

  // Metodo Costruttore inizializzato con int m = numero del mese
  public Mesi(int m)
  {
    mese = m;
  }

  // Metodo che restituisce il relativo mese
  public void getName()
  {
    if (mese > 12)
    {
        System.out.println("ERRORE MESE");
    }
    else
      if (mese == 1)
      {
         System.out.print("1  ");
         System.out.println("GENNAIO");
      }

      if (mese == 2)
      {
         System.out.print("2  ");
         System.out.println("FEBBRAIO");
      }

      if (mese == 3)
      {
         System.out.print("3  ");
         System.out.println("MARZO");
      }

      if (mese == 4)
      {
         System.out.print("4  ");
         System.out.println("APRILE");
      }

      if (mese == 5)
      {
         System.out.print("5  ");
         System.out.println("MAGGIO");
      }

      if (mese == 6)
      {
         System.out.print("6  ");
         System.out.println("GIUGNO");
      }

      if (mese == 7)
      {
         System.out.print("7  ");
         System.out.println("LUGLIO");
      }

      if (mese == 8 )
      {
         System.out.print("8  ");
         System.out.println("AGOSTO");
      }

      if (mese == 9)
      {
         System.out.print("9  ");
         System.out.println("SETTEMBRE");
      }

      if (mese == 10)
      {
         System.out.print("10  ");
         System.out.println("OTTOBRE");
      }

      if (mese == 11)
      {
         System.out.print("11  ");
         System.out.println("NOVEMBRE");
      }

      if (mese == 12)
      {
         System.out.print("12  ");
         System.out.println("DICEMBRE");
      }

      if (mese < 1)
      {
          System.out.println("ERRORE MESE");
      }
  }
}

La classe di test TestMese.java:

public class TestMese
{
  public static void main(String[] args)
  {
    // Stampo a video i nomi dei 12 mesi dell'anno
    for ( int i = 1 ; i < 13 ; i++)
    {
      Mesi a = new Mesi(i);
      a.getName();
    }
  }
}

Scrivere un programma che legge da tastiera un numero intero di 5 cifre e stampi in ordine inverso le singole cifre che lo compongono. Utilizzare opportune funzioni di conversione, cicli e substring.
Es. se l’input è 42853 vengono stampate le cifre
3
5
8
2
4

La classe LetturaInversa.java:

public class LetturaInversa
{
int numero;

  // Metodo costruttore che prende in input un numero intero
  public LetturaInversa(int n)
  {
      numero = n;
  }

  // Metodo che stampa le cifre che compongono il numero in modo inverso
  public void stampaContrario()
  {
    // Converto il numero in una stringa
    String num = Integer.toString(numero);

    // Stampo a video un numero alla volta partendo dall'ultimo numero
    for(int i=0; i<num.length(); i++){
    	System.out.println(num.substring(num.length()-i-1,num.length()-i));
    }
  }
}

La classe di test:

import java.util.Scanner;
public class TestInverso {

  public static void main(String[] args)
  {

    Scanner in = new Scanner(System.in);

    // Prendo in input il numero di 5 cifre
    System.out.println("Dammi un numero : ");
    int x = in.nextInt();

    if(x>99999){
    	System.out.println("Doveni inserire un valore di 5 cifre o inferiore!");
    }else{
    	// Creo un nuovo oggetto per la lettura inversa
        LetturaInversa a = new LetturaInversa(x);

        // Stampo a video i numeri in ordine inverso
        System.out.println("Ecco i numeri stampati in ordine inverso : ");
        a.stampaContrario();
    }
  }
}

Scrivere un programma che calcoli il resto in monete (2 euro, 1 euro, 50/100, 20/100,
10/100, 5/100, 2/100, 1/100) della somma corrisposta dal cliente. L’input sarà costituito da due importi: il prezzo da pagare e la somma corrisposta dal cliente.
Realizzare la classe Cashier per la gestione dei diversi tagli di moneta e una classe Resto che implementi l’erogazione del resto.

La classe Cashier.java

public class Cashier
{
double resto;

  // Metodo Costruttore vuoto
  public Cashier()
  {
  }

  // Metodo che restituisce una moneta da 2 Euro
  public double dai2Euro()
  {
      return 2;
  }

  // Metodo che restituisce una moneta da 1 Euro
  public double dai1Euro()
  {
      return 1;
  }

  // Metodo che restituisce una moneta da 50 centesimi
  public double dai50Cent()
  {
      return 0.50;
  }

  // Metodo che restituisce una moneta da 20 centesimi
  public double dai20Cent()
  {
      return 0.20;
  }

  // Metodo che restituisce una moneta da 10 centesimi
  public double dai10Cent()
  {
      return 0.10;
  }

  // Metodo che restituisce una moneta da 5 centeimi
  public double dai5Cent()
  {
      return 0.05;
  }

  // Metodo che restituisce una moneta da 2 centesimi
  public double dai2Cent()
  {
      return 0.02;
  }

  // Metodo che restituisce una moneta da 1 centesimo
  public double dai1Cent()
  {
      return 0.01;
  }

}

La classe Resto.java:

import java.util.Scanner;
public class Resto
{

  public static void main(String[] args)
  {
    Scanner in = new Scanner(System.in);

    // Prendo in input la somma da pagare
    System.out.println("Dammi il prezzo : ");
    double p = in.nextDouble();

    // Prendo in input la somma emessa per il pagamento
    System.out.println("Dammi la somma di denaro");
    double s = in.nextDouble();

    // Creo un nuovo oggetto Cashier per gestire il resto
    Cashier a = new Cashier();

    System.out.println("Ecco il resto in monete: ");
    // Verifico che la somma emessa sia >= del prezzo del prodotto
    if (s >= p)
    {
        // Calcolo il resto
        double r = s - p;
        double re = 0 ;

        // Emetto se necessario moneta da 2 Euro
        while (r >= 2)
        {
            System.out.println(a.dai2Euro());
            r = r - a.dai2Euro();
            re = re + a.dai2Euro();
        }

        // Emetto se necessario moneta da 1 Euro
        while (r >= 1)
        {
            System.out.println(a.dai1Euro());
            r = r - a.dai1Euro();
            re = re + a.dai1Euro();
        }

        // Emetto se necessario moneta da 50 centesimi
        while (r >= 0.50)
        {
            System.out.println(a.dai50Cent());
            r = r - a.dai50Cent();
            re = re + a.dai50Cent();
        }

        // Emetto se necessario moneta da 20 centesimi
        while (r >= 0.20)
        {
            System.out.println(a.dai20Cent());
            r = r - a.dai20Cent();
            re = re + a.dai20Cent();
        }

        // Emetto se necessario moneta da 10 centesimi
        while (r >= 0.10)
        {
            System.out.println(a.dai10Cent());
            r = r - a.dai10Cent();
            re = re + a.dai10Cent();
        }

        // Emetto se necessario moneta da 5 centesimi
        while (r >= 0.05)
        {
            System.out.println(a.dai5Cent());
            r = r - a.dai5Cent();
            re = re + a.dai5Cent();
        }

        // Emetto se necessario moneta da 2 centesimi
        while (r >= 0.02)
        {
            System.out.println(a.dai2Cent());
            r = r - a.dai2Cent();
            re = re + a.dai2Cent();
        }

        // Emetto se necessario moneta da 1 centesimo
        while (r >= 0.01)
        {
            System.out.println(a.dai1Cent());
            r = r - a.dai1Cent();
            re = re + a.dai1Cent();
        }

    // Stampo a video il resto
    System.out.print("Per un totale di : ");
    System.out.println(" Euro " + re);

    }
  }
}

Realizzare un’applicazione che permetta di calcolare perimetro, area e diagonale di un quadrato partendo dalla conoscenza del lato.

Classe Quadrato.java:

import java.math.*;
public class Quadrato
{
  int lato;
  // Metodo costruttore inizializzato con la misura del lato
  public Quadrato(int l)
  {
      lato = l;
  }

  // Metodo che calcola l'area
  public int calcolaA()
  {
      return (lato*lato);
  }

  // Metodo che calcola il perimetro
  public int calcolaP()
  {
      return (lato*4);
  }

  // Metodo che calcola la diagonale
  public double calcolaD()
  {
      // Chiamata al metodo sqrt della classe MATH
      // Calcolo della radice quadrata di 2
      double r = Math.sqrt(2);
      return (lato*r);
  }

  // Metodo che restituisce la misura del lato
  public int getLato()
  {
      return lato;
  }
}

La classe di test TestQuadrato.java:

import java.util.Scanner;
public class TestQuad {

  public static void main(String[] args)
  {
      Scanner in = new Scanner(System.in);

      // Prendo in input la misura del lato
      System.out.println("Dammi la misura del lato");
      int l = in.nextInt();

       // Creo un nuovo oggetto di tipo Gauadrato
      Quadrato a = new Quadrato(l);

      // Stampo a video l'area, il perimetro e la diagonale
      System.out.println("L'area è pari a ");
      System.out.println(a.calcolaA());

      System.out.println("Il perimetro è pari a ");
      System.out.println(a.calcolaP());

      System.out.println("La diagonale è: ");
      System.out.println(a.calcolaD());
  }
}

Progettare una classe che implementi un dado, specificando da prima il numero di facce (caso base 4) e quindi un metodo che restituisca una faccia del dado simulando appunto il lancio. Utilizzare la classe Random per generare il valore della faccia del dado.
Realizzare infine una classe di test.

Codice della classe Dado.java:

import java.util.Random;
public class Dado
{
  // Metodo Costruttore inizializzato con il numero di facce del dado
  public Dado(int s)
  {
    facce = s;
    // Generatore di numeri casuali
    generatore = new Random();
  }

  // Metodo costruttore del dado classico con 4 facce
  public Dado(){
    facce = 4;
    // Generatore di numeri casuali
    generatore = new Random();
  }

  // Metodo che simula il lancio del dado
  public int lancia()
  {
      return 1 + generatore.nextInt(facce);
  }

  private Random generatore;
  private int facce;
}

La classe di test TestLancio.java:

import java.util.Scanner;
public class TestLancio {

  public static void main(String[] args)
  {
      // Creo un nuovo dado con 6 facce
      Dado d = new Dado(6);
      Scanner in = new Scanner(System.in);

      // Simulo una certa quantità di lanci
      System.out.println("Quanti lanci vuoi simulare?");
      int n = in.nextInt();

      for( int i = 0 ; i < n ; i++)
      {
          int r = d.lancia();
          // Visualizzo il risultato di ogni singolo lancio
          System.out.print(r + "  ");
      }
  }
}

Realizzare un programmino che chieda in input per ogni taglio di moneta il quantitativo in possesso e calcoli in conclusione il totale economico delle monete.

Ecco il codice della classe Moneta.java

import java.util.Scanner;
public class Moneta{

  public static void main(String[] args)
  {
      // Imposto il valore delle monete
      final double dieciCent = 0.10;
      final double ventiCent = 0.20;
      final double cinquantaCent = 0.50;
      final double unEur = 1;
      final double duEur = 2;

      Scanner in = new Scanner(System.in);

      // Prendo in input il numero di monete da 10 centesimi
      System.out.println("Quanti 10 centesimi hai?");
      int dieci = in.nextInt();

      // Prendo in input il numero di monete da 20 centesimi
      System.out.println("Quanti 20 centesimi hai?");
      int venti = in.nextInt();

      // Prendo in input il numero di monete da 50 centesimi
      System.out.println("Quanti 50 centesimi hai?");
      int cinquanta = in.nextInt();

      // Prendo in input il numero di monete da 1 Euro
      System.out.println("Quanti 1 euro hai?");
      int euri = in.nextInt();

      // Prendo in input il numero di monete da 2 Euro
      System.out.println("Quanti 2 euro hai?");
      int duEuri = in.nextInt();

      // Calcolo il totale di monete e lo visualizzo a video
      double totale = dieci*dieciCent + venti*ventiCent + cinquanta*cinquantaCent + euri*unEur + duEuri*duEur;
      System.out.println("Totale Euro nel portafoglio = " + totale);

  }
}

Realizzare una classe Cartolina attraverso la quale siamo interessati a compilare una cartolina postale. L’idea è di implementare una classe che ci faciliti, per esempio, la compilazione di cartoline con lo stesso testo ma inviate a persone diverse.
Realizzare poi una classe di test che permetta di scrivere un certo numero di cartoline.

Classe Cartolina.java

public class Cartolina
{
  String destinatario;
  String caP;
  String citta;
  final String testo;

  /* Metodo Costruttore inizializzato con destinatario,
     codice di avviamento postale e città.
     Testo cartolina già impostato.
  */
  public Cartolina(String d, String cap, String c )
  {
      destinatario = d;
      caP = cap;
      citta = c;
      testo = "Saluti e baci da Parigi. Fabio";
  }

  // Metodo che visualizza i dati della cartolina
  public void visualizza()
  {
      System.out.println("*** CARTOLINA ***");
      System.out.print("Per : " + destinatario);
      System.out.print(" " +caP);
      System.out.println(" " + citta);
      System.out.println(testo);
  }
}

Classe di test

import java.util.Scanner;
import java.util.ArrayList;
public class TestCarolina {

  public static void main(String[] args)
  {
      ArrayList<Cartolina> cart = new ArrayList<Cartolina>();
      Scanner in = new Scanner(System.in);

      // Prendo in input il numero di cartoline da compilare
      System.out.println("Quante cartoline vuoi spedire?");
      int t = in.nextInt();
      in.nextLine();

      int l = 1;

      // Compilo le cartoline
      while ( t > 0)
      {
        System.out.println(" CARTOLINA numero : " + l);

        // Prendo in input il destinatario
        System.out.println("Dammi il destinatario :");
        String n = in.nextLine();

        // Prendo in input il CAP
        System.out.println("Dammi il cap :");
        String cp = in.nextLine();

        // Prendo in input la cità
        System.out.println("Dammi la città :");
        String cy = in.nextLine();

        // Creo una nuova cartolina con i dati acquisiti
        Cartolina a = new Cartolina(n,cp,cy);

        // Aggiungo la cartolina in una collezione
        cart.add(a);
        l++;
        t--;
      }

      // Stampo a video le cartoline create
      for (int i =0 ; i<cart.size(); i++)
      {
          Cartolina a = (Cartolina) cart.get(i);
          a.visualizza();
      }

  }
}