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 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;
        }
}

Il file Counter.java contiene una definizione della classe contatore. In Java ogni file deve contenere un'unica classe pubblica di nome uguale a quello del file.
La classe e' definita public altrimenti sarebbe inaccessibile dall'esterno del file.
Lo stato dell'oggetto e' definito dall'unica variabile value.Questa variabile e' inaccessibile dall'esterno realizzando l'incapsulazione.
La classe e' accessibile dall'esterno attraverso i 2 metodi pubblici increment e getValue che definiscono il suo comportamento. Notate come il secondo metodo e' un metodo getter introdotto solo per realizzare l'incapsulazione.
l'operatore ++ in Java ha lo stesso uso che in C/C++ cioe' value++ indica la stessa cosa di value=value+1

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());

    }
}

Contiene il programma che usa la classe Counter.
Questo programma deve necessariamente contenere una definizione del metodo main con l'istruzione:
```
public static void main (String args[]) { }
```
per indicare dove deve cominciare l'esecuzione del programma Java. In gergo Java un programma col metodo main e' un'applicazione per distinguerlo dai programmi applet (applicazioncine) che girano nel browser.Un'applicazione si fa partire con l'istruzione
```
java nome_della_classe_contenente_il_metodo_main 
```
E' possibile inserire anche una lista di stringhe di caratteri che vengono assegnati agli elementi del vettore args
Crea 2 contatori invocando il costruttore.Da notare che ,dato che noi non abbiamo definito il costruttore, viene usato quello della classe madre Object.
Invoca i metodi della classe contatore piu' volte inviando messaggi agli oggetti corrispondenti.
System.out.println() richiama il metodo println della classe out contenuta a sua volta nella classe System. Notate che essendo il metodo statico puo' essere richiamato usando il nome della classe senza dover instanziare nessun oggetto.
+ e' l'unico operatore sovraccaricato in Java. Infatti esso e' usato anche per le stringhe indicando in tal caso l'operazione di concatenazione.
Concatenando una variabile con una stringa si ottiene una stampa del valore della variabile (valore numerico o valore del puntatore nel caso di oggetti).

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

La dichiarazione di una variabile: Nomeclasse a;
La creazione dell'oggetto : a = new Nomeclasse()

Solo a questo punto e' possibile usare la classe richiamando i suoi metodi e le sue proprieta'.

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;
    }
}

Notate l'uso di extends per indicare che vogliamo estendere un'altra classe, realizzando l'ereditarieta'.
invece di scrivere
```
value = value+2; return value;
```
possiamo scrivere
```
super.increment();return super.increment();
```
richiamando il metodo della classe madre.

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());

    }
}

Abbiamo ora un oggetto Counter e un oggetto BigCounter (che e' anche Counter) ma il codice del programma e' rimasto lo stesso:questo e' il polimorfismo in azione. All'atto dell'esecuzione il programma si preoccupa di richiamare il metodo corretto.

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;
                }
}

il costruttore si presenta come un metodo che ha lo stesso nome della classe e senza dichiarazione del valore ritornato.
E' possibile definire piu' costruttori che si differenziano per numero e tipo di argomenti.
this() si riferisce al costruttore della classe nel quale ci troviamo. super() si riferisce invece al costruttore della classe madre.

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());

    }
}

notare il richiamo del nuovo costruttore anche per l'oggetto BigCounter; questo e' possibile perche' un BigCounter e' anche un Counter.


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
        }
}


I metodi statici possono essere richiamati usando il nome della classe(
ma e' possibile usare anche il nome di un oggetto della classe).
Sample.setClassValue e s1.setClassValue fanno la stessa cosa.
Una variabile statica esiste anche prima di instanziare un singolo oggetto
Le variabili statiche sono uniche qualsiasi sia il numero di oggetti istanziati percio'
s1.printClassValue e S2.printClassValue daranno
sempre lo stesso risultato.


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




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();
}


Un'interfaccia e' una classe che contiene solo definizioni di metodi (cioe' metodi vuoti senza codice); in questo caso il singolo metodo 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);
                }
}


La classe Accumulator ha due metodi propri e inoltre un
metodo ereditato dall'interfaccia StatusPrinter e implementato (cioe' col codice definito) in questa classe.

    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;
                }
}

Counter implementando la stessa interfaccia ridefinisce
anch'essa il metodo printStatus.

    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);
        }
}

definiamo un metodo generico displayStuff che lavora
su dati di tipo StatusPrinter e quindi con tutti gli oggetti
delle classi che implementano questa interfaccia. 
il metodo displayStuff non fa altro che richiamare il
metodo printStatus sull'oggetto passato.
Ora possiamo usare il metodo displayStuff con oggetti di tipo diverso:un'esempio di messaggio generico a cui ogni oggetto 
risponde a suo modo. Questo e' il polimorfismo in azione!

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. 




Applet 6: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 Netscape 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.
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.


L'uso di classi di libreria come Applet comporta l'aggiunta di uno o piu'
comandi import prima della definizione della classe. Questi comandi si riferiscono ai packages contenenti le classi usate e non sono essenziali. 
Essi vengono introdotti per renderci la vita piu' facile
perche' possiamo riferirci al nome
della classe abbreviato in Applet invece di java.applet.Applet.Insomma
l'istruzione import indica al compilatore in quali cartelle cercare
le varie classi(dato che i package in Java sono
ognuno in cartelle di nome uguale al nome del package).
init e' richiamato all'inizio, una volta per tutte.Viene richiamato anche se usiamo la finestra Location per per riattivare l'applet.

start a ogni reload dell'applet subito dopo stop.
paint ogni volta che la finestra ha bisogno di essere ridipinta .
destroy viene richiamato solo se si torna indietro cliccando daccapo sul link all'applet.
Il comportamento puo' cambiare da browser a browser.






Applet 7
: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 java.applet.*;
 public class Cerchio1 extends Applet {
  
 int r, x, y;

public void init() {
   r = 50;
   x = 100; y=100;
  }

public void paint( Graphics g) {

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

 }
}

Guardate l'applet in funzione.

Usiamo init per dare un valore iniziale alle variabili x,y,r
La paint disegna il cerchio usando questi valori,ogni volta che il browser lo richiede.





Applet 8
:modifica dell'applet precedente in modo da disegnare n cerchi a caso . 
/* Questo applet disegna dei cerchi */
import java.awt.*;
 import java.applet.*;
 public class Cerchio1 extends Applet {

 int n,width,height;

public void init() {
  n = (int)(Math.random()*100);
  width = getSize().width;
  height = getSize().height;
  repaint();
  }

public void paint( Graphics g) {
 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.


Le istruzioni System.out.println sparse nel programma servono per il debug
dello stesso e possono essere eliminate (o commentate) quando siamo sicuri
che il programma funziona.
getSize() ritorna le dimensioni dell'applet sotto forma
di oggetto Rectangle le cui proprieta' width e height danno larghezza e altezza in pixel. 
L'oggetto Math serve per definire le funzioni matematiche di base come Math.abs(),Math.sin(),Math.PI,Math.exp().Queste funzioni di solito tornano un valore
double.Per questo i numeri a virgola mobile(decimali) in Java si dichiarano di solito come double.
Un operatore particolare e' quello di cast che si indica col nome
di un tipo di dati entro parentesi tonde e serve a convertire in maniera
esplicita da un tipo di dati all'altro.
int r = (int)(Math.random()*width/2);

La conversione e' obbligatoria solo se si fanno operazioni tra dati "incompatibili" :ad esempio un int in generale puo' non essere in grado di contenere il 
valore double tornato da Math.random()*width/2 ,
ma un double puo' contenere senza problemi un int e percio' l'operazione width/2 non richiede
conversione.
Quando Netscape inizia l'esecuzione richiama il metodo init. Invece paint viene richiamato ogni volta che l'applet deve essere ridisegnato. Da notare che non possiamo chiamare direttamente paint ma possiamo ,chiamando repaint(),
suggerire a Netscape di farlo appena possibile.
L'oggetto Color assieme al metodo setColor (di Graphics) ci permettono di definire i colori con triple di percentuali di 
rosso,verde e blu'.

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 9
: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 java.applet.*;
public class Julia extends Applet {
 Color col[]=new Color[221];

public void init(){
  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);
     }
}
public void paint(Graphics g){
    double c1,c2;
    double x,y;
    double incrementox=4./100;
    double incrementoy=3./100;
    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 4.)break;
               x0 = x1;
               y0 = y1;
               }
           if(k<=220) {
              i = (int)(((x+2)/4)*100.);
              j = (int)(((y+1.5)/3.)*100.);
              g.setColor(col[k]);
              g.fillRect(i,j,1,1);
              }
       }
}

}
}

Guardate l'applet in funzione.

La dichiarazione:
Nomeclasse pippo[] = new Nomeclasse[n];

crea un oggetto array pippo formato a sua volta da n 
puntatori a terra (null) a oggetti Nomeclasse.
Nella init questi puntatori vengono fatti
puntare ad altrettanti oggetti Color creando una semplicissima tavolozza da usare per colorare il disegno.
per colorare il singolo pixel si usa il metodo di Graphics
fillRect(x,y,1,1) con gli argomenti che indicano un rettangolo al punto di coordinate x,y di dimensioni 1.


        




Applet 10
:Come il precedente ma con una tavolozza piu' elaborata tipo "arcobaleno" . 
import  java.awt.*;
import java.applet.*;
public class Julia1 extends Applet {
 int maxcol = 158;
 Color col[]=new Color[maxcol];

public void init(){
   setcol();
}
public void paint(Graphics g){
    double c1,c2;
    double x,y;
    double incrementox=4./100;
    double incrementoy=3./100;
    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 4.)break;
               x0 = x1;
               y0 = y1;
               }
           if(k < maxcol) {
              i = (int)(((x+2)/4)*100.);
              j = (int)(((y+1.5)/3.)*100.);
              g.setColor(col[k]);
              g.fillRect(i,j,1,1);
              }
       }
}

}
void setcol(){
    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 11
: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 riutilizzando il metodo setcol
dell'applet precedente dopo averlo modificato in metodo statico.

import  java.awt.*;
import java.applet.*;
public class Pick extends Applet {
 int maxcol = 158;
 Color col[]=new Color[maxcol];

public void init(){
   Julia1.setcol(col);
}
public void paint(Graphics g){
    double c1,c2;
    int i,j,ncol;
    c1 = Math.random()-5.;
    c2 = Math.random()-5.;

    for(i=0;i<100;i++){
      for(j=0;j<100;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.

Le uniche modifiche nell'applet precedente sono:
 setcol()   diventa setcol(col);
....
 void setcol(){  diventa public static void setcol(Color col[]){

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.
Dichiarazione di una classe Java

livello di accesso public|(package)
abstract se presente,la classe non puo' essere istanziata.Usato in classi come Applet per definire un modello da implementare in sottoclassi.
final se presente,la classe non puo' essere ridefinita.Usato
per proteggere classi di uso generale come String da  possibili
usi nocivi da parte di hacker.
class NomeClasse per convenzione il nome comincia con la maiuscola
extends NomeSuperclasse presente se la classe ne ridefinisce un'altra
implements Interface1,Interface2,... presente se la classe implementa una o piu' interfacce
{ alt+123 oppure SHIFT+[ 
variabili
costruttore
metodi
} alt+125 oppure SHIFT+]

Dichiarazione di una variabile Java

livello di accesso public|protected|(package o file)|private
static se presente,la variabile viene allocata indipendentemente dagli oggetti istanziati, in un'unica copia.
final se presente,la variabile non puo' essere ridefinita.Usato
per costanti. 
transient
volatile
se presente, indica che la variabile e' condivisa
tra piu' Thread e quindi ogni suo cambio di valore deve essere immediatamente accessibile.
tipo Uno degli 8 tipi primitivi oppure il nome di una classe
nomevariabile
= espressione; se presente,richiama il costruttore o indica il valore iniziale di un tipo primitivo.

Dichiarazione di un metodo Java

livello di accesso public|protected|(package o file)|private
static se presente, indica metodi che possono essere richiamati
senza instanziare oggetti,usando il nome della classe.
abstract se presente,il metodo non e' implementato.
final se presente,il metodo non puo' essere ridefinito.
native 
synchronized se presente indica che il metodo deve eseguire solo
se altri metodi sincronizzati in altri Thread non stanno eseguendo. Permette l'accesso esclusivo a risorse condivise. 
tipodivaloreritornato nomeMetodo usare void se il metodo non ritorna nessun valore.Il nome del metodo comincia per convenzione con una lettera minuscola.
(tipoarg1 nomearg1,tipoarg2 nomearg2,...) lista di argomenti
throws Eccezione1,Eccezione2,... lista delle eccezioni lanciate da questo metodo
{
variabili locali
istruzioni del metodo
if(condizione)throw Eccezione; lancio di eccezione
return espressione; normale ritorno con un valore
}


La dichiarazione:
public static void main(String args[]){}
indica  un metodo molto particolare in quanto rende la
classe che lo implementa un'applicazione e il metodo viene richiamato dal
sistema operativo per primo all'atto dell'attivazione della stessa. 
args e' un vettore di stringhe che contiene le parole scritte dopo
il comando java NomeClasse.
 Istruzioni Java
 
Chiamata di un metodo
 
g.fillOval(x,y,2*r,2*r);

if
    if (n > 0) {
    istruzioni...
    }else{
    istruzioni...
    }

Cicli
for(int i=0;i < n;i++){
 istruzioni
 }

while ( i < 5) {
   i=a.doSomething();
     } 

  do { 
 i=a.doSomething();
  } while ( i < 5)

Istruzione di selezione
switch( i ){
case 1: b.func();
case 2: a.func();
default: c:func(); 
  } 

break e continue
while ( i < 5) {
  i=a.doSomething();
  if(i<0) break;
  }

jmp0:
  while (b.func())
  { if (a.func()) continue jmp0; 
   else 
   continue jmp1; 
    } 
   jmp1:


 Vettori Java:l'oggetto Array
 I Vettori 
      in Java sono classi normali.
       
      
        Come tutti gli oggetti essi sono:
      
         Trattati per referenza
         Creati 
          da new
         Cancellati 
          automaticamente quando non sono piu' usati. 
          
      
      I vettori possono essere dichiarati in 2 modi 
        
          int 
        iArray [];
          int 
        [] iArray;
      E' possibile inizializzare vettori di dati primitivi con 
        
          int 
        [] iArray = { 1, 3 , 5, 6};
      iArray.length() => 
        numero degli elementi del vettore.
      La lunghezza di un
vettore, una volta creato, non puo' essere piu' cambiata. Se invece
avete bisogno di un vettore che possa crescere o decrescere a piacere,bisogna usare l'oggetto Vector
 
      

 In Java un vettore bidimensionale(o in generale multidimensionale) viene definito come un vettore di vettori:
 

     int iArray[][] = new int[2][5] ;

    
 ma potete avere anche righe di lunghezza differente:


     
int jArray[][] = { {1, 3, 4},{2,4},{5}};
  

     
          jArray.length()    => 3     
      

     
          jArray[0].length() => 3
          

     
  jArray[1].length() => 2 
           

     
 jArray[2].length() => 1

 Stringhe di caratteri in Java:l'oggetto String
 
Le stringhe in Java sono anch'essi oggetti.
       
      Le stringhe possono essere inizializzate nella dichiarazione : 
          String 
        str= new String("A string");
          String 
        str1= " and another string"
      L'unico caso
in Java di "sovraccarico(overload)" di un operatore (+):
          String 
        str2 = str + str1; 
        
      Allora str2 
        conterra':
          "A 
        string and another string";
       
        Confronto tra stringhe
          if(str1.equals(str2)) 
        
       
        Lunghezza di una stringa
          str1.length() 
        
       
        Sottostringa a partire da i di lunghezza k
          str1.substring(i,k) 
        
       
        Posizione di  una sottostringa str2
          str1.indexOf(str2) 
        
 
Un oggetto molto utile per trattare stringhe di qualsiasi lunghezza e'
l'oggetto StringBuffer
       

INDIETRO a Imparate Java in una settimana



INDIETRO a Seminario su Java

Maintained by Giuseppe Zito:
Giuseppe.Zito@cern.ch

livello di accesso	public\|(package)
abstract	se presente,la classe non puo' essere istanziata.Usato in classi come Applet per definire un modello da implementare in sottoclassi.
final	se presente,la classe non puo' essere ridefinita.Usato per proteggere classi di uso generale come String da possibili usi nocivi da parte di hacker.
class NomeClasse	per convenzione il nome comincia con la maiuscola
extends NomeSuperclasse	presente se la classe ne ridefinisce un'altra
implements Interface1,Interface2,...	presente se la classe implementa una o piu' interfacce
{	alt+123 oppure SHIFT+[
variabili
costruttore
metodi
}	alt+125 oppure SHIFT+]

livello di accesso	public\|protected\|(package o file)\|private
static	se presente,la variabile viene allocata indipendentemente dagli oggetti istanziati, in un'unica copia.
final	se presente,la variabile non puo' essere ridefinita.Usato per costanti.
transient
volatile	se presente, indica che la variabile e' condivisa tra piu' Thread e quindi ogni suo cambio di valore deve essere immediatamente accessibile.
tipo	Uno degli 8 tipi primitivi oppure il nome di una classe
nomevariabile
= espressione;	se presente,richiama il costruttore o indica il valore iniziale di un tipo primitivo.