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

Dichiarazione di una classe Java

livello di accessopublic|(package)
abstractse presente,la classe non puo' essere istanziata.Usato in classi come Applet per definire un modello da implementare in sottoclassi.
finalse 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 NomeClasseper convenzione il nome comincia con la maiuscola
extends NomeSuperclassepresente 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 accessopublic|protected|(package o file)|private
staticse presente,la variabile viene allocata indipendentemente dagli oggetti istanziati, in un'unica copia.
finalse 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.
tipoUno 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 accessopublic|protected|(package o file)|private
staticse presente, indica metodi che possono essere richiamati senza instanziare oggetti,usando il nome della classe.
abstractse presente,il metodo non e' implementato.
finalse presente,il metodo non puo' essere ridefinito.
native
synchronizedse 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 nomeMetodousare 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

Vettori Java:l'oggetto Array

I Vettori in Java sono classi normali.

Come tutti gli oggetti essi sono:

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 ArrayList

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

Esercizi della seconda lezione del corso su Java2

Fate almeno uno degli esercizi proposti e collegate alla vostra home page del corso sia l'applet che il sorgente Java.
  1. Create una classe NumeriComplessi che vi permetta di operare su questo tipo di numeri(che non esistono in Java come dati semplici).
  2. Create un oggetto cerchio e un applet che instanzia un numero random di cerchi e li disegna nella finestra dell'applet.
  3. Generalizzate il programma precedente in modo che possa disegnare non solo cerchi ma anche quadrati. Definite un oggetto generico "Forma" e poi da questo ricavate gli oggetti "Cerchio" e "Quadrato".
  4. Scrivete un applet che fa il plot di una funzione a piacere(ad esempio una parabola).
  5. Scrivete un applet che fa il plot di un certo numero di funzioni.La scelta della funzione viene pilotata da un parametro di nome "tipo" e valore "cos",etc. Create una pagina Web che contiene il plot di tutte le funzioni che avete implementato richiamando piu' volte l'applet(abbastanza difficile:vedete questo programma e il suo codice sorgente per capire come fare).