Lezione 2 - Come si (ri)usano gli oggetti?


Tutte le applicazioni in questa lezione sono state prese dai materiali del seminario tenuto al Cern da Raúl Ramos-Pollán.Allo stesso indirizzo al Cern e' disponibile una copia zippata dello stesso materiale, mentre la S accanto al titolo di ogni applicazione punta a una copia locale dello stesso materiale. Se dovete stampare questo documento usate questo link
Se e' facile definire un nuovo oggetto,l'uso di un oggetto preesistente e' piu' difficile. Ad esempio conviene solo usarlo o ridefinirlo? Perche' in alcuni casi siamo costretti a usare un'interfaccia?E cos'e' un'interfaccia? Cosa sono le variabili statiche e a cosa servono? Quando servono i metodi statici? Inoltre come si usano le classi che permettono di fare grafica fornite nelle librerie del JDK, come Graphics,Color,etc.?


Applicazione 1:Definire una classe di contatori con proprieta' e metodi. Usarla istanziando piu' oggetti.S

    file Counter.java

public class Counter {
        int value = 0;
        public int increment() {
                value ++;
                return value;
        }
        public int getValue() {
                return value;
        }
}


    file MyApplication.java

public class MyApplication {

    public static void main (String args[]) {

        Counter c1 = new Counter();
        Counter c2 = new Counter();

        System.out.println("Counter 1 has value "+c1.getValue());
        System.out.println("Counter 2 has value "+c2.getValue());

        c1.increment();
        c1.increment();
        c2.increment();

        System.out.println("Counter 1 now has value "+c1.getValue());
        System.out.println("Counter 2 now has value "+c2.getValue());

    }
}

La maniera piu' semplice per usare un oggetto e' di dichiararlo e instanziarlo.Dopodiche' abbiamo accesso a tutte le sue variabili e i suoi metodi.
Qui possiamo vedere la definizione di una classe con variabili e metodi.
L'uso di una classe comporta Solo a questo punto e' possibile usare la classe richiamando i suoi metodi e le sue proprieta'.Infatti l'effetto dell'operatore new e' di far allocare lo spazio necessario per contenere l'oggetto dalla zona di memoria chiamata heap facendo puntare la variabile (che prima era uguale a null) a questa zona. In Java le variabili che descrivono oggetti si comportano in maniera molto differente di quelle che si riferiscono a dati primitivi.


Applicazione 2:Definire un nuovo tipo di contatore BigCounter estendendo la classe Counter dell'applicazione 1 modificando il metodo increment.Usare la classe originale insieme alla classe ridefinita.Mostrare l'uso di super() per estendere un metodo preesistente.S

    file BigCounter.java

public class BigCounter extends Counter {

    public int increment() {
        value = value + 2;
        return value;
    }
}

    file MyApplication.java

public class MyApplication {

    public static void main (String args[]) {

        Counter c1 = new Counter();
        Counter c2 = new BigCounter();

        System.out.println("Counter 1 has value "+c1.getValue());
        System.out.println("Counter 2 has value "+c2.getValue());

        c1.increment();
        c1.increment();
        c2.increment();

        System.out.println("Counter 1 now has value "+c1.getValue());
        System.out.println("Counter 2 now has value "+c2.getValue());

    }
}

Ridefinire l'oggetto ci permette una piu' grande liberta' in quanto possiamo adattare meglio l'oggetto ai nostri bisogni,aggiungendo (o ridefinendo)tutti i metodi e le variabili che vogliamo.
Nel ridefinire un metodo,possiamo usare il metodo originale riferendoci ad esso come super.nomeMetodo().


Applicazione 3:Definire un costruttore per la classe Counter in modo da poter dare un valore iniziale al contatore. S

    file Counter.java

public class Counter {
                int value;
                public Counter() { this(0); }
                public Counter (int startingValue) {
                        value = startingValue;
                }
                public int increment() {
                        value ++;
                        return value;
                }
                public int getValue() {
                        return value;
                }
}

    file MyApplication.java

public class MyApplication {

    public static void main (String args[]) {
   
        Counter c1 = new Counter(3);
        BigCounter c2 = new BigCounter(5);

        System.out.println("Counter 1 has value "+c1.getValue());
        System.out.println("Counter 2 has value "+c2.getValue());

        c1.increment();
        c1.increment();
        c2.increment();

        System.out.println("Counter 1 now has value "+c1.getValue());
        System.out.println("Counter 2 now has value "+c2.getValue());

    }
}
Come e' evidente dagli esempi precedenti dove mancava,non e' necessario in Java definire il costruttore. Quando e' presente esso si riconosce per il fatto di essere definito come un metodo (ma non e' un metodo) che ha lo stesso nome della classe. L'unica differenza e' che manca la dichiarazione del valore ritornato.In Java le scritte this() e super() si riferiscono al costruttore. In particolare super() permette di definire il costruttore di una sottoclasse richiamando il costruttore della superclasse.


Applicazione 4:Costruire una classe con variabili statiche e normali.Usare la classe mostrando il diverso comportamento dei due tipi di variabili. S

    file Sample.java

public class Sample {
    static int classValue = 0;
    int objectValue = 10;

    public static void printClassValue() {
        System.out.println("The class value "+classValue);
    }
  
    public static void setClassValue (int v) {
        classValue = v;
    }

    public void printObjectValue() {
        System.out.println("This object's value is "+objectValue);
    }
    public void setObjectValue(int v) {
        objectValue = v;
    }
};

    file MyApplication.java

public class MyApplication {
        public static void main (String args[]) {
                Sample.printClassValue();       // prints 0;
                Sample s1 = new Sample();
                Sample s2 = new Sample();

                s1.setClassValue(20);  
                s1.setObjectValue(25);
                s1.printClassValue();   // prints 20
                s2.printClassValue();   // prints also 20
                s1.printObjectValue();          // prints 25
                s2.printObjectValue();          // prints 10

                Sample.setClassValue(15);
                s2.printClassValue();           // prints 15
                s1.printClassValue();           // prints also 15
        }
}
Le variabili e i metodi statici vengono detti anche di classe perche' si riferiscono alla classe, a differenza dei normali metodi e variabili che sono di oggetto in quanto si riferiscono al singolo oggetto.
Se avete blocchi di costanti che devono essere usati dappertutto (come i common del Fortran) potete definire un oggetto di sole variabili statiche (senza metodi). Le variabili in esso contenute possono essere usate ovunque senza bisogno di instanziare l'oggetto.Una variabile statica viene allocata in memoria indipendentepente dal fatto se un oggetto e' stato instaziato o no. Inoltre anche se vengono instanziati piu' oggetti la variabile statica non viene duplicata ma rimane unica. Per questo la si puo' richiamare usando il nome della classe(e non dell'oggetto). Ad esempio Color.red o Math.PI.
Le costanti si dichiarano di solito anche come final per evitare che siano modificate da qualcuno e possiate ritrovarvi con un valore di PI diverso da 3.14.
Allo stesso modo se avete delle funzioni non legate a un particolare oggetto potete dichiararle come statiche e usarle dappertutto.Questo e' il caso dei metodi Math.sin,Math.cos,etc
Un metodo statico non ha normalmente accesso alle normali variabili e ai normali metodi della classe, perche' e' in esecuzione anche quando non e' istanziato alcun oggetto. Per questo in un metodo statico non potete usare this. Se volete riferirvi a variabili e metodi di oggetto, allora dovete istanziare esplicitamente un oggetto della classe nella quale ci troviamo ed usare il nome di quest'oggetto.Questo di solito crea confusione nei principianti.
Viceversa gli oggetti istanziati di una classe hanno tutti accesso alla stessa variabile statica e possono usarla come mezzo per comunicare tra di loro(una specie di bacheca di messaggi comune). Un esempio di variabile statica usata in questo modo e' un contatore del numero di oggetti istanziati per una data classe.


Applicazione 5:Definite ora anche una classe Accumulator simile alla classe Counter.Definite un'interfaccia comune alle due classi consistente in un metodo che stampa i valori dei contatori ed implementatela in ambedue le classi. S

    file StatusPrinter.java

public interface StatusPrinter {  
        public void printStatus();
}

    file Accumulator.java

public class Accumulator  implements StatusPrinter{
                int sum = 0;
                public void add (int quantity) {
                        sum = sum + quantity;
                }
                public int getSum () {
                        return sum;
                }
                public void printStatus () {
                        System.out.println ("Hi I'm an accumulator. My sum is "+sum);
                }
}

    file Counter.java

public class Counter implements StatusPrinter {
                int value = 0;
                public int increment() {
                        value ++;
                        return value;
                }

                public void printStatus() {
                        System.out.println ("I'm a Counter. My value is " + value );
                }
                public int getValue() {
                        return value;
                }
}

    file MyApplication.java

public class MyApplication {
    static void displayStuff (StatusPrinter s) {
                s.printStatus();
    }   

    public static void main (String args[]) {
                Accumulator a1 = new Accumulator();
                Counter     c1 = new Counter();
                MyApplication.displayStuff (a1);
                MyApplication.displayStuff (c1);
        }
}
In definitiva un'interfaccia in Java e' una speciale classe astratta che contiene solo metodi astratti.Ogni classe in Java puo' estendere un'unica superclasse ma implementare un numero qualsiasi di interfacce. Questo permette di realizzare anche in Java una specie di ereditarieta' multipla.


Applicazione 6:Costruire una classe SingleCounter che puo' essere instanziata una sola volta realizzando un Singleton.Come funziona questo programma. S

    file SingleCounter.java


final class SingleCounter {
        private static SingleCounter s = new SingleCounter(0);
        private int value;
        private SingleCounter(int v){value=v;}
        public static SingleCounter instance(){return s;}
        public int increment() {
                value ++;
                return value;
        }
        public int getValue() {
                return value;
        }
}

    file MyApplication.java


public class MyApplication {

    public static void main (String args[]) {

        SingleCounter c1 = SingleCounter.instance();
        c1.increment();
        SingleCounter c2 = SingleCounter.instance();
        c2.increment();
	System.out.println("Counter 1 has value "+c1.getValue());
        System.out.println("Counter 2 has value "+c2.getValue());


    }
}



Applet 7:mostra quando avviene la chiamata ai vari metodi dell'applet.
Passando agli applet, qui abbiamo la difficolta' aggiuntiva di dover conoscere con esattezza come il browser richiama il vostro programma. Il browser si aspetta in effetti un oggetto ereditato dalla classe Applet (percio' il nome) all'interno del quale devono essere ridefiniti alcuni metodi come init(),paint(),start(),stop(),etc. Cominciamo a usare degli oggetti non scritti da noi. Questi oggetti sono forniti assieme al JDK e documentati nella documentazione standard della Sun che bisogna imparare a consultare. E' importante,nello scrivere questi metodi, sapere quando il browser li richiama. Per questo il primo applet dimostrativo e' una estensione dell'applet Ciao con dei metodi ridotti al minimo col solo scopo di sapere quando sono richiamati. Da notare che la scritta compare nella finestra Java (Java Console)che possiamo far aprire dal browser(in Internet Explorer per far apparire questa finestra occorre selezionare "Java console enabled" nelle "Internet Options" "Advanced").
import java.applet.Applet;
import java.awt.*;

public class Lifecycle extends Applet
{ int initCount=0;
  int startCount=0;
  int stopCount=0;
  int destroyCount=0;
  int paintCount=0;
  
  public void init()
  { ++initCount;
    System.out.println("init(): " + initCount);
  }

  public void start()
  { ++startCount;
    System.out.println("start() " + startCount);
  }

  public void stop()
  { ++stopCount;
    System.out.println("stop() " + stopCount);
  }

  public void destroy()
  { ++destroyCount;
    System.out.println("destroy() " + destroyCount);
  }
  public void paint(Graphics g)
  { ++paintCount;
    g.drawString("Ciao a tutti",20,20);
    System.out.println("paint(): " + paintCount);
  }
}
Guardate l'applet in funzione.



Applet 8:come il precedente ma aggiornato per Java2
import java.awt.*;
import javax.swing.*;

public class Lifecycle1 extends JApplet
{ 
  Display disegno;

  int initCount=0;
  int startCount=0;
  int stopCount=0;
  int destroyCount=0;
  int paintCount=0;
  
  public void init()
  { 
    disegno = new Display();  
    setContentPane(disegno);

    ++initCount;
    System.out.println("init(): " + initCount);
  }

  public void start()
  { ++startCount;
    System.out.println("start() " + startCount);
  }

  public void stop()
  { ++stopCount;
    System.out.println("stop() " + stopCount);
  }

  public void destroy()
  { ++destroyCount;
    System.out.println("destroy() " + destroyCount);
  }
class Display extends JPanel {
  public void paintComponent(Graphics g)
  { 
   super.paintComponent(g);
   ++paintCount;
    g.drawString("Ciao a tutti",20,20);
    System.out.println("paint(): " + paintCount);
  }
 }
}


Guardate l'applet in funzione.
Parleremo piu' in dettaglio di JApplet e JPanel nella lezione 5 ma per ora basta sapere che aggiungendo le seguenti istruzioni:

import javax.swing.*;

public class nomeclasse extends JApplet
{ 
  Display disegno;

  public void init()
  { 
    disegno = new Display();  
    setContentPane(disegno);

  }

class Display extends JPanel {
  public void paintComponent(Graphics g)
  { 
   super.paintComponent(g);
  }
 }
}
e' possibile modificare un qualsiasi applet 1.1 nella versione 2 di Java.


Applet 9 :utilizzare l'oggetto Graphics per disegnare un cerchio.
La grafica in Java viene fatta usando i metodi dell'oggetto Graphics che prevede un sistema di riferimento della finestra dell'applet in pixel numerati da sinistra a destra e dall'alto in basso a partire da 0.Potete usare il metodo getSize dell'oggetto applet per ricavarne le dimensioni. In generale tutta la documentazione sugli oggetti e i metodi delle librerie di classi Java va presa dalla documentazione distribuita assieme al JDK.
 
 import java.awt.*;
 import javax.swing.*;

 public class Cerchio1 extends JApplet {
  
 int r, x, y;
 
  Display disegno;

  public void init()
  { 
    disegno = new Display();  
    setContentPane(disegno);
   
    r = 50;
    x = 100; y=100;
  }

class Display extends JPanel {
  public void paintComponent(Graphics g){
  super.paintComponent(g);

  g.drawOval(x,y,2*r,2*r);
  System.out.println("x,y,r= "+x+" "+y+" "+r);

 }
 }
}


Guardate l'applet in funzione.



Applet 10 :modifica dell'applet precedente in modo da disegnare n cerchi a caso .


/* Questo applet disegna dei cerchi */
 import java.awt.*;
 import javax.swing.*;

 public class Cerchio1 extends JApplet {
  
  Display disegno;

 int n,width,height;

public void init() {
  disegno = new Display();  
  setContentPane(disegno);

  n = (int)(Math.random()*100);
  disegno.repaint();
  }

class Display extends JPanel {
  public void paintComponent(Graphics g){
  super.paintComponent(g);
  
  width = getSize().width;
  height = getSize().height;
 System.out.println(n+" "+width+" "+height);
 for(int i=0;i < n;i++){
   int r = (int)(Math.random()*width/2);
   int x = (int)(Math.random()*width);
   int y = (int)(Math.random()*height);


 g.setColor(new Color((float)Math.random(),(float)Math.random(),(float)Math.random()));
 g.fillOval(x,y,2*r,2*r);
 // System.out.println(x+" "+y+" "+r);
   }
 }
}    
}


Guardate l'applet in funzione.
Rivediamo brevemente gli elementi di base di Java necessari per capire questi programmi e fare gli esercizi proposti.
Java al livello microscopico e' simile al C. Esso ha istruzioni,commenti,8 tipi primitivi di dati (l'unica cosa di Java che non e' oggetto).Esso ha gli stessi operatori algebrici e logici del linguaggio C.
Il passaggio dei parametri avviene per valore e non e' possibile modificare il valore della variabile passata .Ma se passate un oggetto e' possibile modificarne le proprieta' utilizzando la sintassi nomeoggetto.nomeproprieta' = espressione;.
Per concludere questa rapidissima carrellata su Java al livello "microscopico" diciamo che Java tratta vettori e stringhe di caratteri come oggetti.
Infine una trattazione piu' dettagliata e sistematica degli stessi argomenti dal Java tutorial.


Applet 11 :Scrivete un applet che disegni l'insieme di Julia per un valore random delle costanti applicando il notissimo algoritmo usato per l'insieme di Mandelbrot .

import  java.awt.*;
import javax.swing.*;

public class Julia extends JApplet {
 
 Color col[]=new Color[221];

 Display disegno;

 public void init()
  { 
    disegno = new Display();  
    setContentPane(disegno);
  
  col[0] = new Color(255,0,0);
  col[1] = new Color(0,255,0);
  col[2] = new Color(0,0,255);
  col[3] = new Color(255,255,0);
  col[4] = new Color(0,255,255);
  col[5] = new Color(255,0,255);
  for(int i=6;i< 221;i++){
    col[i]=new Color(i,0,0);
     }
}
class Display extends JPanel {
public void paintComponent(Graphics g){
   super.paintComponent(g);
    
    int width = getSize().width;
    int height = getSize().height;
    double c1,c2;
    double x,y;
    double incrementox=4./width;
    double incrementoy=3./height;
    int k; int maxit =220;
    double x1,y1,r;
    int i,j;
    double x0,y0;
    c1 = Math.random()*4.-2.;
    c2 = Math.random()*3.-1.5;

    for(x=-2.;x<2.;x=x+incrementox){
      for(y=-1.5;y<1.5;y=y+incrementoy){
               x0 =x; y0=y;
          for(k=1;k<maxit;k=k+1){
               x1 = x0*x0 - y0*y0 + c1;
               y1 = 2.*x0*y0 + c2;
               r = x1*x1 + y1*y1;
               if(r > 4.)break;
               x0 = x1;
               y0 = y1;
               }
           if(k<220) {
              i = (int)(((x+2)/4)*width);
              j = (int)(((y+1.5)/3.)*height);
              g.setColor(col[k]);
              g.fillRect(i,j,1,1);
              }
       }
}
}

}
}
Guardate l'applet in funzione.



Applet 12 :Come il precedente ma con una tavolozza piu' elaborata tipo "arcobaleno" .

import  java.awt.*;
import javax.swing.*;

public class Julia1 extends JApplet {
 int maxcol = 158;
 Color col[]=new Color[maxcol];
 
 Display disegno;

  public void init()
  { 
    disegno = new Display();  
    setContentPane(disegno);

    setcol(col);
}
class Display extends JPanel {
public void paintComponent(Graphics g){
  super.paintComponent(g);
    int width = getSize().width;
    int height = getSize().height;
    double c1,c2;
    double x,y;
    double incrementox=4./width;
    double incrementoy=3./height;
    int k; 
    double x1,y1,r;
    int i,j;
    double x0,y0;
    c1 = Math.random()*4.-2.;
    c2 = Math.random()*3.-1.5;

    for(x=-2.;x<2.;x=x+incrementox){
      for(y=-1.5;y<1.5;y=y+incrementoy){
               x0 =x; y0=y;
          for(k=1;k<maxcol;k=k+1){
               x1 = x0*x0 - y0*y0 + c1;
               y1 = 2.*x0*y0 + c2;
               r = x1*x1 + y1*y1;
               if(r > 4.)break;
               x0 = x1;
               y0 = y1;
               }
           if(k<maxcol) {
              i = (int)(((x+2)/4)*width);
              j = (int)(((y+1.5)/3.)*height);
              g.setColor(col[k]);
              g.fillRect(i,j,1,1);
              }
       }
}
}

}
public static void setcol(Color col[]){
    int ncolr = 30;
    int i; 
  col[0] = new Color(0,0,0);
  col[1] = new Color(0,0,0);
  col[2] = new Color(255,0,0);
  col[3] = new Color(0,255,0);
  col[4] = new Color(0,0,255);
  col[5] = new Color(255,255,0);
  col[6] = new Color(255,0,255);
  col[7] = new Color(0,255,255);

    for (i=0;i<ncolr;i++) {
      col[i+8] = new Color(interp(255,255,i/(double)(ncolr-1.)),
                           interp(0,255,i/(double)(ncolr-1.)),
                           interp(0,0,i/(double)(ncolr-1.)));
    }
    for (i=0;i<ncolr;i++) {
      col[i+ncolr+8] = new Color(interp(255,0,i/(double)(ncolr-1.)),
       interp(255,255,i/(double)(ncolr-1.)),
       interp(0,0,i/(double)(ncolr-1.)));
    }
    for (i=0;i<ncolr;i++) {
      col[i+2*ncolr+8] = new Color(interp(0,0,i/(double)(ncolr-1.)),
       interp(255,255,i/(double)(ncolr-1.)),
       interp(0,255,i/(double)(ncolr-1.)));
    }
    for (i=0;i<ncolr;i++) {
      col[i+3*ncolr+8] = new Color(interp(0,0,i/(double)(ncolr-1.)),
       interp(255,0,i/(double)(ncolr-1.)),
       interp(255,255,i/(double)(ncolr-1.)));
    }
    for (i=0;i<ncolr;i++) {
      col[i+4*ncolr+8] = new Color(interp(0,255,i/(double)(ncolr-1.)),
       interp(0,0,i/(double)(ncolr-1.)),
       interp(255,255,i/(double)(ncolr-1.)));
    }
}
static  int interp(int a,int b,double f) {
                return (int)(a*(1-f)+b*f);
        }
}
Guardate l'applet in funzione.
La tavolozza e' realizzata richiamando il metodo setcol che a sua volta chiama il metodo interp per interpolare i colori intermedi tra due colori dati.


Applet 13 :Se x e y sono le coordinate del pixel, la formula ncol=c1*(sin(-11+c2*x)+sin(-12+c2*y)) genera delle interessanti immagini per -5.< c1 < -4 e -5< c2 < -4. Questo applet genera queste immagini a caso utilizzando il metodo setcol dell'applet precedente .

import  java.awt.*;
import javax.swing.*;

public class Pick extends JApplet {
 int maxcol = 158;
 Color col[]=new Color[maxcol];
 
 Display disegno;

  public void init()
  { 
    disegno = new Display();  
    setContentPane(disegno);

   Julia1.setcol(col);
}
class Display extends JPanel {
public void paintComponent(Graphics g){
    super.paintComponent(g);

    int width = getSize().width;
    int height = getSize().height;

    double c1,c2;
    int i,j,ncol;
    c1 = Math.random()-5.;
    c2 = Math.random()-5.;

    for(i=0;i<width;i++){
      for(j=0;j<height;j++){
              ncol = (int)(c1*(Math.sin(-11.+c2*i)+Math.sin(-12.+c2*j)));
              ncol = Math.abs(ncol)%maxcol+1;
              g.setColor(col[ncol]);
              g.fillRect(i,j,1,1);
              }
       }
}

}
}

Guardate l'applet in funzione.
Il metodo setcol dell'applet precedente essendo stato dichiarato:
public static void setcol(Color col[]){
puo' essere richiamato come metodo di classe, senza dover instanziare nessun oggetto.
Per completare l'argomento sull'uso di oggetti grafici, bisogna considerare che Java oltre a permettere la manipolazione di colori e immagini permette anche la definizione di font.
Trovate qui la versione precedente della lezione con gli applet 1.1
INDIETRO a Imparate Java in una settimana
INDIETRO a Seminario su Java
Maintained by : info@zitogiuseppe.com
Ultimo aggiornamento: