Artikels

Java oefeninge vir Java Base opleidingskursus

Lys van Java-oefeninge met oplossing vir Java Base-opleidingskursus.

Die nommering van die oefening is 'n aanduiding van die moeilikheidsgraad, van die eenvoudigste tot die mees ingewikkelde. As jy enige kommentaar, vrae of voorstelle het: skryf aan ons by info @bloginnovazione.it

Oefening 1
Skryf 'n Java-program wat die gebruiker vra om twee stringe in te voer en wys die gebruiker waar as die stringe dieselfde is en onwaar as hulle verskillend is.

import java.util.Scanner;

public class CompareTwoStrings {
   public static void main(String[] args) {
        
      Scanner risposta = new Scanner(System.in);
        
      System.out.println("Inserisci la prima stringa");
      String str1 = risposta.nextLine();

      System.out.println("Inserisci la seconda stringa");
      String str2 =risposta.nextLine();

      if(str1.equals(str2))
      {
         System.out.println("La stringa " + str1 + " è uguale a " + str2);
      }
      else
      {
         System.out.println("La stringa " + str1 + " è diversa da " + str2);
      }

      risposta.close();

   }
}

Oefening 2
Skryf 'n Java-program wat die gebruiker vra om twee stringe (str1 en str2) in te voer en wat 'n ander sin aan die gebruiker vertoon met die volgende voorwaardes:
1) as hulle dieselfde is, skryf "die string" + + "Is gelyk aan" +
2) as hulle verskil, skryf "die string" + + "Is anders as" +
3) as een van die twee ingesluit is in die ander "die string" + + ”Is ingesluit in die +-string
4) in die geval dat die een by die ander ingesluit is, sê hoeveel gevalle daar is, en skryf dan
"Die gebeure is:" +

import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class CompareTwoStrings {

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

      System.out.println("Digitare prima stringa:");
      String str1 = input.nextLine();

      System.out.println("Digitare seconda stringa:");
      String str2 = input.nextLine();
        
      boolean verifica = str1.equals(str2); // check equals
      boolean verificaContenuto1 = str1.contains(str2); //check inclusion
      boolean verificaContenuto2 = str2.contains(str1);

      if (verifica){
         System.out.println("La stringa " + str1 + " è uguale alla stringa "+ str2 + " (sensibile al maiuscolo).");
      }
      else if (verificaContenuto1){

         Pattern p = Pattern.compile(str2);
         Matcher m = p.matcher(str1);

         int count1 = 0;
         while(m.find()){
            count1 += 1;
         }
               
         System.out.println("La stringa2 " + str2 + " è contenuta nella stringa1 " + str1 + " " + count1 + " volte.");
      }
      else if (verificaContenuto2){
                
         Pattern p = Pattern.compile(str1);
         Matcher m = p.matcher(str2);

         int count2 = 0;
         while(m.find()){
            count2 += 1;
         }
               
         System.out.println("La stringa1 " + str1 + " è contenuta nella stringa2 " + str2 + " " + count2 + " volte.");
      }
        
      else {
         System.out.println("La stringa " + str1 + " è diversa alla stringa " + str2 + ".");
      }

      input.close();

      System.out.println("Fine.");
   }
}

Oefening 3
Gegewe 'n sleutelbordinvoer, kontroleer die inhoud, (die eerste drie voorwaardes is nie eksklusief nie, terwyl die valse (kontemporêre) van die eerste drie voorwaardes die vierde opsie impliseer):
1) as binêre getal omskakel na desimale en heksadesimale uitvoer
2) as desimale getal omskakel na uitvoer na binêre en heksadesimale
3) as hex getal omskakel na binêre en desimale uitvoer
4) rapporteer in alle ander gevalle onaanvaarbare insette en versoek invoeging
doen dan die omskakelings 101, 1 en 2 vir die invoer '3'
vir invoer '123' doen omskakelings 2 en 3
vir invoer '89A' doen die omskakeling 3
vir invoer '89G' voer punt 4 uit

import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class CompareTwoStrings {

    public static String bi2int (String bin){
        char[] numbers = binary.toCharArray();
        int result = 0;
        for(int i=numbers.length - 1; i>=0; i--)
        if(numbers[i]=='1'){
            result += Math.pow(2, (numbers.length-i - 1));
        }
        return result;
    }

    public static String bi2esa (String bin){
    }

    public static String int2bi (String integer){
        int integer1 = Integer.parseInt(integer);
        String result = Integer.toBinaryString(integer1);
        return result;
    }

    public static String int2esa (String integer){
    }

    public static String esa2bi (String esa){
    }

    public static String esa2int (String esa){
    }

    public static void main(String[] args){

        Scanner input = new Scanner(System.in);

        System.out.println("Digitare un numero binario, intero o esadecimale:");
        String numero = input.nextLine();

        Pattern pBinario = Pattern.compile("[A-Z]"|"[2-9]", Pattern.CASE_INSENSITIVE);
        Matcher mBinario = pBinario.matcher(numero);
        boolean binario = mBinario.find();

        Pattern pIntero = Pattern.compile("[A-Z]", Pattern.CASE_INSENSITIVE);
        Matcher mIntero = pIntero.matcher(numero);
        boolean intero = mIntero.find();

        Pattern pEsadecimale = Pattern.compile("[G-Z]", Pattern.CASE_INSENSITIVE);
        Matcher mEsadecimale = pEsadecimale.matcher(numero);
        boolean esadecimale = mEsadecimale.find();

        if (binario){
            System.out.println(numero + " è binario!");
            System.out.println("In interi corrisponde a " + bi2int(numero) + ",");
            System.out.println("in esadecimali corrisponde a " + bi2esa(numero) + ".");
        }

        if (intero){
            System.out.println(numero + " è intero!");
            System.out.println("In binario corrisponde a " + int2bi(numero) + ",");
            System.out.println("in esadecimali corrisponde a " + int2esa(numero) + ".");
        }

        if (esadecimale){
            System.out.println(numero + " è esadecimale!");
            System.out.println("In binario corrisponde a " + esa2bi(numero) + ",");
            System.out.println("in interi corrisponde a " + esa2int(numero) + ".");
        }

        if (!esadecimale && !intero && !binario){
            System.out.println("Input errato!");
        }

    input.close();
    }
}

Oefening 4
Maak 'n program wat 'n temperatuur van grade Celsius na grade Kelvin omskakel. Die program moet twee etikette, twee teksvelde en 'n knoppie hê. Teksvelde en byskrifte moet in 'n paneel met 'n enkelkolom-roosteruitleg georganiseer word; 'n ander paneel sal die enkele knoppie bevat en daar sal die hoofpaneel wees wat die twee panele bevat wat beskryf word.

Die program lees die waarde wat in die teksveld ingevoer is wat ooreenstem met die temperatuur in grade Celsius. Indien die ingevoerde teks leeg is, moet geen bewerking uitgevoer word nie; anders word die teks na 'n dubbele waarde omgeskakel en hierdie waarde word met 273.15 verhoog om die Kelvin-grade te verkry, wat dan in die ooreenstemmende teksveld geskryf word.

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;

public class ConvertitoreTemperatura extends JFrame implements ActionListener{
   JButton btnConverti;
   JLabel lbTempCelsius, lbTempKelvin;
   JTextField txtTempCelsius, txtTempKelvin;
   JPanel pannello, pann1, pann2;

   public ConvertitoreTemperatura() {
	pannello = new JPanel();
	pann1 = new JPanel(new GridLayout(0,1));
	pann2 = new JPanel();
	txtTempCelsius = new JTextField("",10);
	txtTempKelvin = new JTextField("",10);
	lbTempCelsius = new JLabel("Temperatura in Celsius");
	lbTempKelvin = new JLabel("Temperatura in Kelvin");
	btnConverti = new JButton("Converti Temperatura");
	pann1.add(lbTempCelsius);
	pann1.add(txtTempCelsius);
	pann1.add(lbTempKelvin);
	pann1.add(txtTempKelvin);
	pann2.add(btnConverti);
	pannello.add(pann1);
	pannello.add(pann2);
	setContentPane(pannello);
	btnConverti.addActionListener(this);
	setTitle("Convertitore Temperatura ");
	setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
	pack();
	setSize(400,150);
	setVisible(true);
   }
   public void actionPerformed(ActionEvent e) {
	String str = txtTempCelsius.getText();
	if (!str.contentEquals("")) {
		double d = Double.parseDouble(str);
		d = d + 273.15;
		txtTempKelvin.setText(""+d);
	}
   }
   public static void main(String[] args) {
	ConvertitoreTemperatura frame = new ConvertitoreTemperatura();
   }
}

Oefening 5
Skryf 'n Java-program wat twee sleutelbordinsette neem en die som uitvoer, in ag genome:
- as hulle twee heelgetalle is, word die som as uitvoer gerapporteer
- as hulle twee stringe is, word die aaneenskakeling in die uitvoer gerapporteer

public class SommaConcatenazione {

   public static void main(String[] args) {

      char simbolo;
      int numero1;
      int numero2;
      String parola1;
      String parola2;
      int risultato;
      String risultatoStringa;

      Scanner scanner = new Scanner(System.in);

      System.out.println("scegli l'operazione: numeri (n), Stringhe (s)");
      simbolo = scanner.nextLine().charAt(0);
			
      switch (simbolo) {

         case 'n':
				
            System.out.println("inserisci un numero");
            numero1 = scanner.nextInt();

            System.out.println("inserisci il secondo numero");
            numero2 = scanner.nextInt();
				
            risultato = numero1 + numero2;
            System.out.println(numero1 + " + " + numero2 + " = " + risultato);
         break;

         case 's':
				
           System.out.println("inserisci una parola");
	   parola1 = scanner.nextLine();

	   System.out.println("inserisci la seconda parola");
           parola2 = scanner.nextLine();
				
           risultatoStringa = parola1 + parola2;
           System.out.println(parola1 + "  " + parola2 + " = " + risultatoStringa);
         break;


         default:
            System.out.println("operazione  non valido");
         break;
      }
      scanner.close();
      System.out.println("FINE");
   }	
		
}

Oefening 6
Herskryf die kode van oefening 3 deur die Java-oorlading te gebruik, definendo twee metodes wat dieselfde naam het en wat implementeer: die eerste die rekenkundige som en die tweede die aaneenskakeling van snare

import java.util.Scanner;

public class Main{

    public static int somma (int addendo1, int addendo2)
    {
        return addendo1 + addendo2;
    };

    public static String somma(String addendo1, String addendo2)
    {
        return addendo1 + addendo2;
    };


    public static void main(String[] args){
        Scanner risposta = new Scanner(System.in);
        
        System.out.println("Cosa vuoi sommare? 1-numeri....2-stringhe");
        
        
        int input = risposta.nextInt();

        if( input == 1)
        {
            System.out.println("Inserisci il primo numero");
            int num1=risposta.nextInt();

            System.out.println("Inserisci il secondo numero");
            int num2=risposta.nextInt();

            System.out.println("Il risultato è: "+ somma(num1,num2));
        }
        else 
        {
            risposta.nextLine();
            System.out.println("Inserisci la prima stringa");
           String str1 = risposta.nextLine();

            System.out.println("Inserisci la seconda stringa");
           String str2 =risposta.nextLine();

            System.out.println("Il risultato è: "+ somma(str1,str2));
            

        }
        risposta.close();
        

    }


}

Oefening 7
Herskryf die kode van oefening 4 deur Java-oorlading te gebruik, en herken die inhoud van snare deur gebruik te maak van gereelde uitdrukkings. As daar ten minste een letter is dan voeg ons saam, anders voeg ons by

import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Esercizio3 {

    public static int somma(int addendo1, int addendo2){
        return addendo1 + addendo2;
    }

    public static String somma(String stringa1, String stringa2){
        return stringa1 + stringa2;
    }

    public static void main(String[] args) {

        Scanner risposta = new Scanner(System.in);
        
        System.out.println("Inserisci il primo valore");
        String str1 = risposta.nextLine();

        System.out.println("Inserisci il secondo valore");
        String str2 =risposta.nextLine();

        Pattern pattern1 = Pattern.compile("[A-Z]", Pattern.CASE_INSENSITIVE);
        Matcher matcher1 = pattern1.matcher(str1.toUpperCase());
        boolean matchFound1 = matcher1.find();

        Pattern pattern2 = Pattern.compile("[A-Z]", Pattern.CASE_INSENSITIVE);
        Matcher matcher2 = pattern2.matcher(str2.toUpperCase());
        boolean matchFound2 = matcher2.find();

        if( matchFound1 || matchFound2)
        {
            System.out.println("Il risultato è: "+ somma(str1,str2));
        }
        else
        {
            int num1 = Integer.parseInt(str1);
            int num2 = Integer.parseInt(str2);

            System.out.println("Il risultato è: "+ somma(num1,num2));
        }

        risposta.close();

    }
}

Oefening 8
Die skryf van 'n Java-program wat 'n nommer in invoer gegee het, bereken die faktoriaal deur beide rekursie en iterasie te gebruik, en skryf beide resultate na die uitvoer.

In die eerste geval sal ons rekursie gebruik, waar 'n metode homself noem vir die oplossing, en in die tweede geval sal ons 'n lus soos for en while lus gebruik om die iterasie te kry.

Om 'n rekursiewe oplossing te skep, benodig ons 'n basisgeval waar die program eindig en die rekursie stop. Ons sien dat die basisgeval faktoriaal van 1 is, wat 1 is, so wanneer jou funksie faktoriaal (1) noem, kan jy net 1 terugstuur sonder om enige berekeninge te doen. En as die getal groter as 1 is, gaan ons voort om die faktoriële formule rekursief toe te pas deur dieselfde faktoriaal met n - 1 te noem. Sodra die invoer 1 word, stop die metode die rekursiewe oproep en gee 1 terug. Van daar af het metodestapel begin afblaai en uiteindelik word die faktoriaal van 'n getal bereken en teruggestuur.

Gebruik eerder die iterasie, en dan die for-lus om die faktoriale n te bereken! = n(n-1)(n-2) .....1. Jy kan sien dat ons met die getal begin en dit vermenigvuldig met die faktoriaal wat met 1 geïnisialiseer is, dan verminder ons die getal met een eenheid totdat die getal 1 word, wat niks anders as n is nie.(n-1)(n-2) .....1.

import java.util.Scanner;

public class Factorial{

    public static int recursiveFactorial(int n)
    {

        if( n <= 1)
        {
            return 1;
        }
        else
        {
            return n * recursiveFactorial( n - 1 );
        }
        
    } 

    public static int iterativeFactorial(int n){
        int result = 1;

        for (int i = 1; i <= n; i++) {
            result = result * i;
        }
        
        return result;
    }

    public static void main(String[] args){

        Scanner input = new Scanner(System.in); // input
        System.out.println("Insert an integer number: ");
        int numero = input.nextInt();
        if ( numero < 0 ){
            System.out.println("The number must be positive!");
            System.exit(0);
        }


        System.out.println("Recursive Factorial is: " + recursiveFactorial(numero));
        System.out.println("Iterative Factorial is: " + iterativeFactorial(numero));

        input.close();

    }
}

Oefening 9
Die skryf van 'n Java-program wat 'n nommer in invoer gegee het, bereken die faktoriaal deur beide rekursie en iterasie te gebruik, en skryf beide resultate na die uitvoer.

Daar is baie maniere om 'n string in Java om te keer. Ons kan die gevorderde Java API gebruik om die inhoud van enige String-voorwerp vinnig om te keer. Die Java-biblioteek voorsien die StringBuffer- en StringBuilder-klasse met die omgekeerde () metode wat gebruik kan word om String in Java om te keer. Maar aangesien omgekeerde rekursief is, kan ons rekursie gebruik.

Hier is die algoritme en kodes om 'n sekere string in Java om te keer sonder om StringBuffer of ander API-metodes te gebruik. Die metode hieronder wys hoe om die string om te keer, wat jy verder kan hergebruik om te kyk of die gegewe string palindroom is of nie.

Nadat die aanvanklike invoer gevalideer is, word die String karakter vir karakter besoek, vanaf die einde tot die begin en genereer 'n omgekeerde String.

import java.util.Scanner;

public class ReverseString {
    
    public static String reverseString(String str){

        if( str.length() == 0 ){
            return str;
        }
        else{
        return str.charAt(str.length()-1)  + reverseString( str.substring(0, str.length() - 1) );
        }
    }

    public static void main(String[] args){
        Scanner input = new Scanner(System.in); // input
        System.out.println("Insert a phrase: ");
        String stringa = input.nextLine();

        System.out.println("String reversed is " + reverseString(stringa));

        input.close();
    }
}

Oefening 10
Skryf 'n Java-program wat in staat is om die bewerkings van invoeging, verwydering en binêre soek binne 'n lys heelgetalle te bestuur, met die doel om 'n geordende indeks van getalle te bestuur deur die gedrag van 'n tabelindeks van 'n relasionele databasis te simuleer.

Om die indeks te bestuur, kom ons gaan voort met die skep van die indeksklas waar die metodes indeks lees, indeks invoeg en indeks verwyder. Bewerkings word altyd voorafgegaan deur 'n binêre sleutelsoektog.

Om buigsaamheid in die datastruktuur te hê, is dit beter om 'n skikkingslys te gebruik.

import java.util.Scanner;
import java.lang.Math;
import java.util.ArrayList;

//---------------------------------------------------------
// Main Class
//---------------------------------------------------------

public class Index {

//METODO MAIN
   public static void main(String[] args){

      Scanner input = new Scanner(System.in);

        ArrayList<Integer> arrayInserito = new ArrayList<Integer>();

        System.out.println("How many numbers do you want to enter ?");
        int dimensione = input.nextInt();

        int valoreLetto;
        int i= 0;
        
        for (i = 0; i <= (dimensione - 1); i++){
            System.out.println("Input " + (i+1) + "^ Value");
            valoreLetto = input.nextInt();
            arrayInserito.add(valoreLetto);
        }
        VettoreNum primoArray = new VettoreNum(arrayInserito); 

        String decisione = "Y";

        while (decisione.equalsIgnoreCase("Y")){

            System.out.println("What execute ?");
            System.out.println("(0) = INSERT Key");
            System.out.println("(1) = REMOVE Key");
            System.out.println("(2) = END");

            int scelta = input.nextInt();

            if (scelta == 2)
                continue;
                
            else {
                System.out.println("Input key to search:");
                int chiave = input.nextInt();
        
                if (chiave < 0){
                    System.out.println("Error: the key must be positive.");
                    System.exit(0);
                }

                switch (scelta){

                    //Insert
                        case 0:
                        System.out.println("Array: " + primoArray.vettore);
                        System.out.println("The key is in the index : " + primoArray.cercaValore(chiave));
                        System.out.println("Position: " + primoArray.getPosizione());
                        System.out.println("The index after insert:");
                        System.out.println(primoArray.inserisciValore(chiave));
                        break;

                    //Remove
                        case 1:
                        System.out.println("Array: " + primoArray.vettore);
                        System.out.println("The key is in the index: " + primoArray.cercaValore(chiave));
                        if (primoArray.cercaValore(chiave)){
                            System.out.println("Position: " + primoArray.getPosizione());
                            System.out.println("The index after remove:");
                            System.out.println(primoArray.rimuoviValore(chiave));
                        }
                        else 
                            System.out.println("The key is not in the index.");
                        break;

                    //no valid input
                        default:
                        System.out.println("Error: please insert a valid number.");
                    }
            }
        
            System.out.println("Do you want to do another ? (Y or N)");
            decisione = input.next();
        }
        input.close();
        System.out.println("END.");
       
    }
}



//----------------------------------------------------------------
//CLASS VECTORNUM
//----------------------------------------------------------------

class VectorNum {


    public int lunarray;   
    public int posizione;  
    public ArrayList<Integer> vettore;  
    public int sup;
    public int inf;
    public ArrayList<Integer> newArray; 

    public VettoreNum (ArrayList<Integer> vettore){
        this.vettore = vettore;
        this.lunarray = vettore.size();
        this.posizione = -1;
        this.inf = 0;
        this.sup = vettore.size() - 1;
        this.newArray = new ArrayList<Integer>();
    }


    public int getPosizione(){
        return this.posizione;
    }


    public boolean cercaValore (int chiave){

        if((this.sup - this.inf) > 1){
            int m = Math.round((this.sup + this.inf)/2);
            if (chiave < this.vettore.get(m)){
                this.sup = m;
            }
            else {
                this.inf = m;
            }
            cercaValore(chiave);
        }
        if (chiave <= this.vettore.get(this.inf))
            this.posizione = this.inf;
        else if (chiave <= this.vettore.get(this.sup))
            this.posizione = this.sup;
            else 
            this.posizione = this.sup + 1;
        return (this.vettore.get(this.inf) == chiave || this.vettore.get(this.sup) == chiave);
    }
        

    public ArrayList<Integer> inserisciValore (int chiave){

        newArray.clear();
        int i;

        for (i = 0; i < this.lunarray + 1; i++){
            if (i < this.posizione)
                this.newArray.add(this.vettore.get(i));
            else if (i == this.posizione)
                this.newArray.add(chiave);
            else
                this.newArray.add(this.vettore.get(i - 1));
        }
        this.vettore = this.newArray;
        return this.vettore;
    }


    public ArrayList<Integer> rimuoviValore (int chiave){

        vettore.remove(posizione);
        return this.vettore;
    }
}

Oefening 11
Skryf 'n java-program wat 'n invoerlêer genaamd textinput.txt lees en die inhoud daarvan kontroleer
1) as die lêer nie bestaan nie, skryf "die lêer bestaan nie"
2) as die lêer bestaan en leeg is, skryf "die textinput.txt-lêer is leeg"
3) as die lêer bestaan en slegs een nommer bevat, druk die nommer op die skerm
4) as die lêer bestaan en twee getalle op twee reëls bevat, druk die som tussen die twee getalle
5) as die lêer bestaan en meer as twee nommers bevat, maak dit die produk

Om buigsaamheid in die datastruktuur te hê, is dit beter om 'n skikkingslys te gebruik.

import java.io.File;
import java.util.Scanner;
import java.util.ArrayList;
import java.io.FileNotFoundException;


public class Exercise_11 {

    public static void main(String[] args) throws FileNotFoundException{

        File mioFile = new File("textinput.txt");

        if (!mioFile.exists()){//---------------------------------------------- file doesn't exist
            System.out.println("File not found.");
        }
        else {//---------------------------------------------------------------  file exists
            System.out.println("File exist.");

            Scanner lettore = new Scanner(mioFile);

            ArrayList<Integer> collezione = new ArrayList<Integer>();

            while (lettore.hasNextLine()) {
            int riga = lettore.nextInt();
            collezione.add(riga);
            }
            lettore.close();

            switch (collezione.size()){
                
                case 0:
                System.out.println("File empty.");
                break;

                case 1:
                System.out.println(collezione.get(0));
                break;

                case 2:
                System.out.println("Two numbers, and the sum is: " + (collezione.get(0)+collezione.get(1)));
                break;

                default:
                System.out.println("More than two numbers, and the result is: " + prodotto(collezione));
            }
        }  
    }

    public static int prodotto (ArrayList<Integer> x){

        int i = 0;
        int a = x.get(0);

        for (i = 1; i<= (x.size()-1); i++){
            a = a * x.get(i);
        }
        return a;
    } 
}

Oefening 12
Skryf 'n Java-program om bestellings by restauranttafels te bestuur.
Tafels kan in die restaurant gereël word, elk met 'n numeriese ID en 'n aantal sitplekke.
Vir elke tafel moet gestoor word die beven die skottelgoed wat verbruik word, moet dit moontlik wees om outomaties die rekening te bereken om te betaal.
Die skottelgoed en die bevande beskikbaar, word eerder in 'n 'Menu'-klas gestoor wat hulle in twee kategorieë verdeel (geregte en bevgaan, inderdaad).
Elke gereg of bevanda moet gekwalifiseer word deur 'n unieke alfanumeriese identifiseerder (naam) en sy prys.

Om die tabelle te bestuur het ons 'n tabelklas gemaak met metodes en eienskappe vir bestuur. Die spyskaart is deur HashMap bestuur

import java.util.Scanner;
import java.util.HashMap;

//--------------------------------------------------------------------
//                            MAIN CLASS
//--------------------------------------------------------------------
public class Restaurant {

// Main method
    public static void main(String[] args){

        Scanner input = new Scanner(System.in);

    // Tables:
        Table tavolo1 = new Table(1,1);
        Table tavolo2 = new Table(2,2);
        Table tavolo3 = new Table(3,2);
        Table tavolo4 = new Table(4,8);
        Table tavolo5 = new Table(5,8);
        Table tavolo6 = new Table(6,8);

    // Menu as HashMap:
        HashMap<Integer, Integer> menu = new HashMap<Integer, Integer>();
        menu.put(1,5);
        menu.put(2,4);
        menu.put(3,1);
        menu.put(4,12);
        menu.put(5,1);
        menu.put(6,2);

    // Handle of request at the tables:
        while (true){
            System.out.println("Next Customers ?");
            System.out.println("(1): take a table");
            System.out.println("(2): Get an order");
            System.out.println("(3): The Bill");
            System.out.println("(0): Go Out.");

            int operazione = input.nextInt();

            if (operazione == 0)
                break;

         //switch on previous request:
            switch (operazione){

             // Take a table------------------------------------------
                case 1:
                System.out.println("Hoe many seats ?");
                System.out.println("(1): One seat");
                System.out.println("(2): Two seats");
                System.out.println("(3): from two to eight seats");

                int persone = input.nextInt();

             // switch on number of seats
                switch (persone){

                // One seat
                    case 1:
                    if (tavolo1.libero){
                        tavolo1.setOccupato();
                        System.out.println("Table number One !");
                    }
                    else
                        System.out.println("Sold Out.");
                    break;

                // Two seats
                    case 2:
                    if (tavolo2.libero){
                        tavolo2.setOccupato();
                        System.out.println("Table number Two !");
                    }
                    else if (tavolo3.libero){
                        tavolo3.setOccupato();
                        System.out.println("Table number Three !");
                    }
                    else
                        System.out.println("Sodl out.");

                    break;

                // 3 to 8 seats
                    case 3:
                    if (tavolo4.libero){
                        tavolo4.setOccupato();
                        System.out.println("Table number Four !");
                    }
                    else if (tavolo5.libero){
                        tavolo5.setOccupato();
                        System.out.println("Table number Five !");
                    }
                    else if (tavolo6.libero){
                        tavolo6.setOccupato();
                        System.out.println("Table number Six !");
                    }
                    else
                        System.out.println("Sold Out.");

                    break;

                // more than eight seats
                    default:
                    System.out.println("Not available.");
                }
                break;

             // Show Menu and take an order------------------------
                case 2:
                System.out.println("Tanle number:");
                int num = input.nextInt();//table number to get order
                System.out.println(".");

             //switch on table to order:
                switch (num){

                    case 1:
                    //loop to show menu on order
                    while (true){
                        System.out.println("MENU:");
                        System.out.println("(1) rise $5");
                        System.out.println("(2) spaghetti  $4");
                        System.out.println("(3) chicken $10");
                        System.out.println("(4) salmon $12");
                        System.out.println("(5) Water $1");
                        System.out.println("(6) coca cola $2");
                        System.out.println(".");

                        System.out.println("Insert order (0) to exit:");
                        int selezione = input.nextInt();

                        if (selezione == 0)
                            continue;
                        else {
                            tavolo1.setOrdineAttuale(selezione, menu.get(selezione));     
                        }
                        System.out.println("It's enough ?");
                        System.out.println("(1): Y; (2): N");
                        int ancora = input.nextInt();
                        if (ancora == 2)
                            break;
                    }
                    break;

                    case 2:
                    while (true){
                        System.out.println("MENU:");
                        System.out.println("(1) rise $5");
                        System.out.println("(2) spaghetti  $4");
                        System.out.println("(3) chicken $10");
                        System.out.println("(4) salmon $12");
                        System.out.println("(5) Water $1");
                        System.out.println("(6) coca cola $2");
                        System.out.println(".");

                        System.out.println("Insert order (0) to exit:");
                        int selezione = input.nextInt();

                        if (selezione == 0)
                            continue;
                        else {
                            tavolo2.setOrdineAttuale(selezione, menu.get(selezione));     
                        }
                        System.out.println("It's enough ?");
                        System.out.println("(1): Y; (2): N");
                        int ancora = input.nextInt();
                        if (ancora == 2)
                            break;
                    }
                    
                    break;

                    case 3:
                    while (true){
                        System.out.println("MENU:");
                        System.out.println("(1) rise $5");
                        System.out.println("(2) spaghetti  $4");
                        System.out.println("(3) chicken $10");
                        System.out.println("(4) salmon $12");
                        System.out.println("(5) Water $1");
                        System.out.println("(6) coca cola $2");
                        System.out.println(".");

                        System.out.println("Insert order (0) to exit:");
                        int selezione = input.nextInt();

                        if (selezione == 0)
                            continue;
                        else {
                            tavolo3.setOrdineAttuale(selezione, menu.get(selezione));     
                        }
                        System.out.println("It's enough ?");
                        System.out.println("(1): Y; (2): N");
                        int ancora = input.nextInt();
                        if (ancora == 2)
                            break;
                    }
                    break;

                    case 4:                 
                    while (true){
                        System.out.println("MENU:");
                        System.out.println("(1) rise $5");
                        System.out.println("(2) spaghetti  $4");
                        System.out.println("(3) chicken $10");
                        System.out.println("(4) salmon $12");
                        System.out.println("(5) Water $1");
                        System.out.println("(6) coca cola $2");
                        System.out.println(".");

                        System.out.println("Insert order (0) to exit:");
                        int selezione = input.nextInt();

                        if (selezione == 0)
                            continue;
                        else {
                            tavolo4.setOrdineAttuale(selezione, menu.get(selezione));     
                        }
                        System.out.println("It's enough ?");
                        System.out.println("(1): Y; (2): N");
                        int ancora = input.nextInt();
                        if (ancora == 2)
                            break;
                    }
                    break;

                    case 5:
                    while (true){
                        System.out.println("MENU:");
                        System.out.println("(1) rise $5");
                        System.out.println("(2) spaghetti  $4");
                        System.out.println("(3) chicken $10");
                        System.out.println("(4) salmon $12");
                        System.out.println("(5) Water $1");
                        System.out.println("(6) coca cola $2");
                        System.out.println(".");

                        System.out.println("Insert order (0) to exit:");
                        int selezione = input.nextInt();

                        if (selezione == 0)
                            continue;
                        else {
                            tavolo5.setOrdineAttuale(selezione, menu.get(selezione));     
                        }
                        System.out.println("It's enough ?");
                        System.out.println("(1): Y; (2): N");
                        int ancora = input.nextInt();
                        if (ancora == 2)
                            break;
                    }
                    break;

                    case 6:
                    while (true){
                        System.out.println("MENU:");
                        System.out.println("(1) rise $5");
                        System.out.println("(2) spaghetti  $4");
                        System.out.println("(3) chicken $10");
                        System.out.println("(4) salmon $12");
                        System.out.println("(5) Water $1");
                        System.out.println("(6) coca cola $2");
                        System.out.println(".");

                        System.out.println("Insert order (0) to exit:");
                        int selezione = input.nextInt();

                        if (selezione == 0)
                            continue;
                        else {
                            tavolo6.setOrdineAttuale(selezione, menu.get(selezione));     
                        }
                        System.out.println("It's enough ?");
                        System.out.println("(1): Y; (2): N");
                        int ancora = input.nextInt();
                        if (ancora == 2)
                            break;
                    }
                    break;

                    default:
                    System.out.println("Invalid table");
                }   
                break;                

             // Payment and table available---------------------------
                case 3:
                System.out.println("Insert number of table:");
                int numero = input.nextInt();
                System.out.println(".");

             //switch on table ID
                switch (numero){

                    case 1:
                    int conto1 = somma(tavolo1.ordineAttuale);
                    System.out.println("Amount to pay: $" + conto1);
                    
                    tavolo1.ordineAttuale = null;
                    tavolo1.libero = true;
                    break;

                    case 2:
                    int conto2 = somma(tavolo2.ordineAttuale);
                    System.out.println("Amount to pay: $" + conto2);
                    
                    tavolo2.ordineAttuale = null;
                    tavolo2.libero = true;
                    break;

                    case 3:
                    int conto3 = somma(tavolo3.ordineAttuale);
                    System.out.println("Amount to pay: $" + conto3);
                    
                    tavolo3.ordineAttuale = null;
                    tavolo3.libero = true;
                    break;

                    case 4:
                    int conto4 = somma(tavolo4.ordineAttuale);
                    System.out.println("Amount to pay: $" + conto4);
                    
                    tavolo4.ordineAttuale = null;
                    tavolo4.libero = true;
                    break;

                    case 5:
                    int conto5 = somma(tavolo5.ordineAttuale);
                    System.out.println("Amount to pay: $" + conto5);
                    
                    tavolo5.ordineAttuale = null;
                    tavolo5.libero = true;
                    break;

                    case 6:
                    int conto6 = somma(tavolo6.ordineAttuale);
                    System.out.println("Amount to pay: $" + conto6);
                    
                    tavolo6.ordineAttuale = null;
                    tavolo6.libero = true;
                    break;

                    default:
                    System.out.println("Table not available.");
                }
                break;

                default:
                System.out.println("Sold out.");
            }
            
        }
        input.close();
    }


// Method to sum amount of order 
    public static int somma(HashMap<Integer, Integer> conto){
        int a = 0;
        for (int i : conto.values()){
            a = a + i;
        }
        return a;
    }

}




//-----------------------------------------------------------------------
//                           Table class
//-----------------------------------------------------------------------

class Table {

    public boolean libero;
    public int tavoloID;
    public int coperti;
    HashMap<Integer, Integer> ordineAttuale; 

    public Table (int numero, int posti){
        this.libero = true;
        this.tavoloID = numero;
        this.coperti = posti;
        this.ordineAttuale = new HashMap<Integer, Integer>();
    }

// table not available
    public void setOccupato(){
        libero = false;
    }

// available table
    public void setLibero(){
        libero = true;
    }

// check the state of the table:
    public boolean getStato(){
        return this.libero;
    }

//
    public void setOrdineAttuale(int uno, int due){
        ordineAttuale.put(uno, due);
    }
}

Opstel BlogInnovazione.it

Tags: oefeningeJavaseosagteware-ontwerpSoftware Developersagteware-ontwikkelingSagteware-ingenieursweseSagtewaretoetsing

9 Oktober 2022 6:15

volgende Foto's, video's, oudio: kunsmatige intelligensie leer om die werklikheid te repliseer "

vorige «Inligtingsdag - Ontplooiing van die dataruimte vir slim gemeenskappe - Aanlyngeleentheid, 18 Oktober 2022

Onlangse artikels

Artikels

Die voordele van inkleurbladsye vir kinders - 'n wêreld van magie vir alle ouderdomme

Die ontwikkeling van fyn motoriese vaardighede deur inkleur berei kinders voor vir meer komplekse vaardighede soos skryf. Om in te kleur...

2 Mei 2024

Artikels

Die toekoms is hier: hoe die verskepingsbedryf die wêreldekonomie revolusioneer

Die vlootsektor is 'n ware globale ekonomiese moondheid, wat na 'n 150 miljard-mark navigeer het ...

1 Mei 2024

Artikels

Uitgewers en OpenAI onderteken ooreenkomste om die vloei van inligting wat deur Kunsmatige Intelligensie verwerk word, te reguleer

Verlede Maandag het die Financial Times 'n ooreenkoms met OpenAI aangekondig. FT lisensieer sy wêreldklas-joernalistiek ...

30 April 2024

Artikels

Aanlynbetalings: Hier is hoe stroomdienste jou vir altyd laat betaal

Miljoene mense betaal vir stromingsdienste en betaal maandelikse intekengeld. Dit is algemene opinie dat jy...

29 April 2024

Java oefeninge vir Java Base opleidingskursus

Lys van Java-oefeninge met oplossing vir Java Base-opleidingskursus.

Oefening 1Skryf 'n Java-program wat die gebruiker vra om twee stringe in te voer en wys die gebruiker waar as die stringe dieselfde is en onwaar as hulle verskillend is.

Oefening 5Skryf 'n Java-program wat twee sleutelbordinsette neem en die som uitvoer, in ag genome: - as hulle twee heelgetalle is, word die som as uitvoer gerapporteer - as hulle twee stringe is, word die aaneenskakeling in die uitvoer gerapporteer

Oefening 6Herskryf die kode van oefening 3 deur die Java-oorlading te gebruik, definendo twee metodes wat dieselfde naam het en wat implementeer: die eerste die rekenkundige som en die tweede die aaneenskakeling van snare

Oefening 7Herskryf die kode van oefening 4 deur Java-oorlading te gebruik, en herken die inhoud van snare deur gebruik te maak van gereelde uitdrukkings. As daar ten minste een letter is dan voeg ons saam, anders voeg ons by

Oefening 8Die skryf van 'n Java-program wat 'n nommer in invoer gegee het, bereken die faktoriaal deur beide rekursie en iterasie te gebruik, en skryf beide resultate na die uitvoer.

Oefening 9Die skryf van 'n Java-program wat 'n nommer in invoer gegee het, bereken die faktoriaal deur beide rekursie en iterasie te gebruik, en skryf beide resultate na die uitvoer.

Oefening 10Skryf 'n Java-program wat in staat is om die bewerkings van invoeging, verwydering en binêre soek binne 'n lys heelgetalle te bestuur, met die doel om 'n geordende indeks van getalle te bestuur deur die gedrag van 'n tabelindeks van 'n relasionele databasis te simuleer.

Onlangse artikels

Die voordele van inkleurbladsye vir kinders - 'n wêreld van magie vir alle ouderdomme

Die toekoms is hier: hoe die verskepingsbedryf die wêreldekonomie revolusioneer

Uitgewers en OpenAI onderteken ooreenkomste om die vloei van inligting wat deur Kunsmatige Intelligensie verwerk word, te reguleer

Aanlynbetalings: Hier is hoe stroomdienste jou vir altyd laat betaal

Onlangse artikels

tag

Oefening 1
Skryf 'n Java-program wat die gebruiker vra om twee stringe in te voer en wys die gebruiker waar as die stringe dieselfde is en onwaar as hulle verskillend is.

Oefening 5
Skryf 'n Java-program wat twee sleutelbordinsette neem en die som uitvoer, in ag genome:
- as hulle twee heelgetalle is, word die som as uitvoer gerapporteer
- as hulle twee stringe is, word die aaneenskakeling in die uitvoer gerapporteer

Oefening 6
Herskryf die kode van oefening 3 deur die Java-oorlading te gebruik, definendo twee metodes wat dieselfde naam het en wat implementeer: die eerste die rekenkundige som en die tweede die aaneenskakeling van snare

Oefening 7
Herskryf die kode van oefening 4 deur Java-oorlading te gebruik, en herken die inhoud van snare deur gebruik te maak van gereelde uitdrukkings. As daar ten minste een letter is dan voeg ons saam, anders voeg ons by

Oefening 8
Die skryf van 'n Java-program wat 'n nommer in invoer gegee het, bereken die faktoriaal deur beide rekursie en iterasie te gebruik, en skryf beide resultate na die uitvoer.

Oefening 9
Die skryf van 'n Java-program wat 'n nommer in invoer gegee het, bereken die faktoriaal deur beide rekursie en iterasie te gebruik, en skryf beide resultate na die uitvoer.

Oefening 10
Skryf 'n Java-program wat in staat is om die bewerkings van invoeging, verwydering en binêre soek binne 'n lys heelgetalle te bestuur, met die doel om 'n geordende indeks van getalle te bestuur deur die gedrag van 'n tabelindeks van 'n relasionele databasis te simuleer.