Esercitazioni JAVA

• INDICE
• 1. Per iniziare
  2. Classe PortaMonete, assegnazione tra oggetti; classe ContoCorrente
  3. Classi String e StringTokenizer
  4. Cambiamenti di base e operatori bit a bit
• AVANTI

Per iniziare

1. Inserire il floppy personale per salvare le esercitazioni nel dirive A:
2. Aprire il file fond1eo\Es4.htm per leggere e seguire l'esercitazione
3. Ridurre le dimensioni della finestra che deve restare visibile ma consentire la visibilità di un'altra nuova finestra

Classe PortaMonete; assegnazione tra oggetti; classe ContoCorrente

• il progetto di oggetti;
• il costruttore di tali oggetti;
• il manuale d'uso per descriverne le funzionalità.

1. 1. Aprire l'ambiente JCreator facendo doppio Click sull'icona presente sul Desktop
   2. Ridimensionare la finestra in modo che sia visibile anche questa con il resto dell'esercitazione
   3. Leggere il manuale d'uso degli oggetti della classe PortaMonete
   4. Aprire con File/Open il file PortaMonete\PortaMonete.java e osservare in particolare i commenti di documentazione, - quelli che iniziano con i caratteri '/**' e terminano con '*/' - dai quali può essere costruito automaticamente il manuale d'uso
   5. Copiare il file PortaMonete\PortaMonete.java nel floppy di lavoro A: e compilarlo
   6. Aprire nel floppy di lavoro, con File/New, un file dal nome ProvaPortaMonete.java
   7. Redigere il testo di un'applicazione ProvaPortaMonete.java che faccia uso di un portamonete come ad esempio:

      public class ProvaPortaMonete{
      	public static void main(String[] args){
      		PortaMonete mio= new PortaMonete();
      		PortaMonete tuo= new PortaMonete();
      		mio.entra(20);
      		mio.entra(5);
      		mio.entra(5);
      		mio.entra(50);
      		mio.esce(15);
      		System.out.print("il mio portamonete:  ");
      		System.out.println(mio.ammontare()+"  attendo resto: "+mio.daAvere());
      		tuo.entra(10);
      		System.out.print("il tuo portamonete:  ");
      		System.out.println(tuo.ammontare()+"  attendo resto: "+tuo.daAvere());
      		tuo=mio;
      		tuo.entra(20);
      		System.out.print("il mio portamonete:  ");
      		System.out.println(mio.ammontare()+"  attendo resto: "+mio.daAvere());
          }
      }
      

   8. salvare con File/Save as, compilare con Build/Compile File, eventualmente correggere e salvare di nuovo a compilazione corretta
   9. eseguire con Build/Execute File osservando in particolare l'effetto dell'assegnazione tra oggetti - che non equivale all'assegnazione tra variabili semplici ma piuttosto a una assegnazione tra puntatori -

      mio=tuo;
      

2. 1. A partire dalla seguente documentazione che ne rende possibile la realizzazione automatica del "manuale d'uso", scrivere una classe ContoCorrente che permetta di costruire conti correnti sui quale effettuare depositi e prelievi ma anche trasferimenti su altri conti correnti.

      
      public class ContoCorrente{
        
         /**
            Costruttore di un conto corrente vuoto
            @param nome è l'intestatario
         */
         public ContoCorrente(String nome)
      
         /**
            Deposito di denaro sul conto corrente.
            @param valore la quantità di denaro depositata
         */
         public void deposito(double valore) 
      
         /**
            Prelievo di denaro dal conto corrente.
            @param valore la quantità di denaro prelevata.
         */
         public void prelievo(double valore) 
      
         /**
            Fornisce il saldo del conto corrente.
            @return l'attuale ammontare del conto.
         */
         public double saldo()
         
         /**
            Trasferisce denaro a un altro conto corrente
            @param altro l'identificativo dell'altro conto corrente
            @param valore quanto denaro viene trasferito
         */
         public void trasferimento(ContoCorrente altro, double valore)
      
      

   2. salvare e compilare , eventualmente correggere e salvare di nuovo a compilazione corretta
   3. provare tale classe nell'applicazione

      public class ProvaContoCorrente {
      	public static void main(String[] args){
      		ContoCorrente mioConto= new ContoCorrente("Pippo");
      		ContoCorrente tuoConto= new ContoCorrente("Pluto");
      		mioConto.deposito(2000);
      		System.out.println("il  saldo di  "+ mioConto.intestatario+" e' "+ 
      		      mioConto.saldo());
      		mioConto.trasferimento(tuoConto,500);
      		System.out.println("il  saldo di  "+ mioConto.intestatario+" e' "+ 
      		      mioConto.saldo());
      		System.out.println("il  saldo di  "+ tuoConto.intestatario+" e' "+ 
      		      tuoConto.saldo());
          }
      }
      

Classi String e StringTokenizer

1. 1. Eseguire la seguente applicazione

      public class RovesciaStringa {
        public static void main(String[] args) {
         	String parola="precipitevolissimevolmente";
      	System.out.println(parola);
         	for (int i=parola.length(); i>0; i--)
      		System.out.print(parola.charAt(i-1));
        	System.out.println();
        }  
      }
      

   2. Modificare l'applicazione precedente in modo che la parola, anziché rovesciata, venga criptata sostituendo 'b' ad 'a', 'c' a 'b', ..., 'a' a 'z'.
2. Una classe utile per il trattamento di stringhe è StringTokenizer nel package java.util che va importato esplicitamente - mentre alcune classi, come java.io e java.lang sono importate implicitamente.
   1. Provare la seguente applicazione per suddividere frasi in parole o anche secondo altri criteri:

      import java.util.StringTokenizer;
      
      public class ScomponeFrasi {
        public static void main(String[] args) {
         	String frase="T'amo o pio bove e mite un sentimento";
      	System.out.println(frase);
      
      	StringTokenizer   st=new StringTokenizer(frase);
              int n = st.countTokens();
         	for (int i=0; i<n; i++)
      		System.out.print(st.nextToken() + "/");
        	System.out.println();
      
      	st=new StringTokenizer(frase,"m");
              while (st.hasMoreTokens()) 
      		System.out.print(st.nextToken() + "b");
        	System.out.println();
        }  
      }
      

   2. Scrivere un'applicazione che metta in ordine alfabetico (detto anche lessicografico) le parole della frase.

Cambiamenti di base e operatori bit a bit

1. 1. Oltre al metodo String toBinaryString(int) della classe Integer che trasforma in base 2 un numero intero vi sono anche metodi predefiniti della classe Integer per ottenere i cambiamenti di un numero intero in base qualunque e viceversa.

      public class Conversioni{
      	public static void main(String[] args){
      		int n=35;
      		int base=16;
      		// converte un numero int in base diversa da 10
      		System.out.println(Integer.toString(n,base));
      		// e riconverte
      		System.out.println(Integer.valueOf(Integer.toString(n,base),base));
      		String nn="A4";
      		base=13;
      		// converte un numero in base diversa da 10 in un int
      		System.out.println(Integer.valueOf(nn,base));
      		// e riconverte
      		System.out.println(Integer.toString(Integer.valueOf(nn,base).intValue(),base));
      
      	}
      }
      

   2. Aggiungere alla classe Mat dei metodi per convertire numeri da base dieci a base diversa e viceversa
2. Gli operatori di shift '<<' e '>>', and '&', or '|' e di complemetare '~' (ottenibile con la combinazione di tasti [ALT]126) agiscono sulla rappresentazione binaria di un numero
   1. Eseguire la seguente applicazione e poi modificarla opportunamente per rendenrsi conto del funzionamento degli operatori bit a bit. Il metodo toBinariString(x) della classe Integer permette proprio di visualizzare la rappresentazione binaria di x.

      public class BitaBit{
      	public static void main(String[] args){
      		int n=(int) (Math.random()*100);
      		System.out.println(n);
      		System.out.println(Integer.toBinaryString(n));
      		System.out.println(Integer.toBinaryString(n<<1));
      		System.out.println(Integer.toBinaryString(n>>1));
      		System.out.println(Integer.toBinaryString(~n));
      		System.out.println(Integer.toBinaryString(n|8));
      		System.out.println(Integer.toBinaryString(n&8));
      	}
      }
      

   2. aggiungere nella classe Mat definita un metodo String daDecimaleaBinario(int n) equivalente al metodo toBinariString(x) facendo uso dell'operatore '&' per realizzare una maschera per estrarre uno a uno i bit della rappresentazione interna
3. Per ottenere immediatamente la rappresentazione interna di un numero reale si può innanzitutto farlo interpretare come long con il metodo doubleToLongBits(<numero reale>)e poi convertire tutto in binario ancora con il metodo toString(<numero intero>, <nuova base>) applicabile anche alla classe Long. Scrivere quindi una applicazione utile allo scopo per vedere ad esempio la rappresentazione interna del numero 4.35