---------------------------------------

...
complex z,w,t;
...
z = 5.0 + i 3.0;
w = 3.0;
...
t = z + w;
...
System.out.println(t);

---------------------------------------

prodC(c1,c2) = 
setIm(
  setRe(creaC(),
   diffR(prodR(getRe(c1),getRe(c2)),prodR(getIm(c1),getIm(c2))))
  sumR(prodR(getRe(c1),getIm(c2)),prodR(getIm(c1),getRe(c2))))

---------------------------------------

class Complesso {
  private double re;
  private double im;

  public Complesso(double r, double i) {
    re = r;
    im = i;
  }

  public static void setC(Complesso z, double x, double y) {
    z.re = x; z.im = y;
  }
  
  public static void visualizzaC(Complesso z) {
    System.out.println(z.re + " + i" + z.im);
  }

  public static double getRe(Complesso z) {
    return z.re;
  }

  public static double getIm(Complesso z) {
    return z.im;
  }
  //... qui potremmo avere altri metodi...
}

---------------------------------------

class ... {
  ...
  ... main ... {
    ...
    double x,y;
    Complesso z = new Complesso(2,3);
    Complesso w = new Complesso(0.6, 1);
    ...
    Complesso.setC(z,x,y);
    Complesso.visualizzaC(w);
    x = Complesso.getRe(w);
    ...
  }
}

---------------------------------------

/**Il TDA pila di interi */
class Pila {
  /** Il numero di elementi massimo */
  private static final int MAXELEMENTI = 10;
  /** Il vettore che contiene gli elementi*/
  private int[] elementi;
  /** Il numero di elementi effettivamente presenti */
  private int numElementi;

  /** Costruttore: costruisce (e restituisce implicitamente) una 
    * pila vuota */
  public Pila() {
    numElementi = 0;
    elementi = new int[MAXELEMENTI];
  }
  
  /** Dice se la pila p e' vuota */
  public static boolean vuota (Pila p) {
    return (p.numElementi == 0);
  }
    
  /** Dice se la pila p e' piena */
  public static boolean piena (Pila p) {
    return (p.numElementi == p.MAXELEMENTI);
  }
    
  /** push dell'elemento e sulla pila p */
  public static Pila push (Pila p, int e) {
    if (!piena(p))
      p.elementi[p.numElementi++] = e;
    return p;
  }

  /** Restituisce il top della pila p */
  public static int top(Pila p) {
    if (!vuota(p))
      return p.elementi[p.numElementi - 1];
    else return -1;
  }
  
  /** Elimina un elemento dalla cima della pila p */
  public static Pila pop(Pila p) {
    if(!vuota(p))
      p.numElementi--;
    return p;
  }
}

---------------------------------------

/** Programma per la prova della classe Pila. */
class ProvaPila {
  public static void main (String[] args) {
    Pila p1 = new Pila();

    p1 = Pila.push(p1,1); 
    p1 = Pila.push(p1,2); 
    p1 = Pila.push(p1,3); 
    p1 = Pila.push(p1,4);
    System.out.println(Pila.top(p1));
    p1 = Pila.pop(p1); 
    p1 = Pila.pop(p1);
    System.out.println(Pila.top(p1));
    p1 = Pila.push(p1,5);
    System.out.println(Pila.top(p1));
  }
}

---------------------------------------

>javac ProvaPila.java
>java ProvaPila
4
2
5

---------------------------------------

p1 = Pila.push(Pila.push(Pila.push(Pila.push(p1,1),2),3),4);

---------------------------------------

/**Il TDA pila di interi */
class PilaP {
  /** Il numero di elementi massimo */
  private static final int MAXELEMENTI = 10;
  /** Il vettore che contiene gli elementi*/
  private int[] elementi;
  /** Il numero di elementi effettivamente presenti */
  private int numElementi;

  /** Costruttore: costruisce e restituisce implicitamente una 
    * pila vuota */
  public PilaP() {
    numElementi = 0;
    elementi = new int[MAXELEMENTI];
  }
  
  /** Dice se la pila p e' vuota */
  public static boolean vuota (PilaP p) {
    return (p.numElementi == 0);
  }
    
  /** Dice se la pila p e' piena */
  public static boolean piena (PilaP p) {
    return (p.numElementi == p.MAXELEMENTI);
  }
    
  /** push dell'elemento e sulla pila p */
  public static void push (PilaP p, int e) {
    if (!piena(p))
      p.elementi[p.numElementi++] = e;
  }

  /** Restituisce il top della pila p */
  public static int top(PilaP p) {
    if (!vuota(p))
      return p.elementi[p.numElementi - 1];
    else return -1;
  }
  
  /** Elimina un elemento dalla cima della pila p */
  public static void pop(PilaP p) {
    if(!vuota(p))
      p.numElementi--;
  }
}

---------------------------------------

/** Programma per la prova della classe PilaP. */
class ProvaPilaP {
  public static void main (String[] args) {
    PilaP p1 = new PilaP();

    PilaP.push(p1,1); 
    PilaP.push(p1,2); 
    PilaP.push(p1,3); 
    PilaP.push(p1,4);
    System.out.println(PilaP.top(p1));
    PilaP.pop(p1); 
    PilaP.pop(p1);
    System.out.println(PilaP.top(p1));
    PilaP.push(p1,5);
    System.out.println(PilaP.top(p1));
  }
}

---------------------------------------

class Insieme {
  private int maxElementi;
  private boolean[] elementi;

  /** Costruttore: costruisce e restituisce implicitamente un 
    * insieme vuoto */
  public Insieme(int num) {
    maxElementi = num;
    elementi = new boolean[maxElementi];
  }

  /** Costruttore copia: costruisce (e restituisce) un insieme 
    * uguale a quello passato come parametro */
  public Insieme(Insieme x) {
    maxElementi = x.maxElementi;
    elementi = new boolean[maxElementi];
    for (int i = 0; i < maxElementi; i++)
      elementi[i] = x.elementi[i];
  }

  /** Dice se l'insieme x e' vuoto */
  public static boolean vuoto(Insieme x) {
    boolean trovato = false;
    for(int i = 0; i < x.maxElementi; i++)
      if (x.elementi[i]) {
        trovato = true;
        break;
      }
    return !trovato;
  }

  /** Inserisce l'elemento e nell'insieme x */
  public static Insieme inserisci(int e, Insieme x) {
    Insieme tmp = new Insieme(x);
    tmp.elementi[e] = true;
    return tmp;
  }

  /** Elimina l'elemento e dall'insieme x */
  public static Insieme elimina(int e, Insieme x) {
    Insieme tmp = new Insieme(x);
    tmp.elementi[e] = false;
    return tmp;
  }

  /** Predicato di appartenenza di e a x */
  public static boolean appartiene(int e, Insieme x) {
    return x.elementi[e];
  }

  /** Visualizza il contenuto dell'insieme x */
  public static void visualizza(Insieme x) {
    boolean primo = true;
    System.out.print("{");
    for (int i = 0; i < x.maxElementi; i++)
      if (x.elementi[i])
        if (primo) {
          System.out.print(i);
          primo = false;
        } else 
          System.out.print(", " + i);
    System.out.println("}");
  }
}

---------------------------------------

class ProvaInsieme {
  // solo per testare l'implementazione
  public static void main(String[] args) {
    Insieme a = new Insieme(100);

    System.out.println(Insieme.vuoto(a));
    a = Insieme.inserisci(13,a);
    Insieme.visualizza(a);
    a = Insieme.inserisci(11,a);
    Insieme b = new Insieme(a);
    Insieme.visualizza(a);
    Insieme.visualizza(b);
    System.out.println(Insieme.appartiene(13,a));
    System.out.println(Insieme.appartiene(11,a));
    System.out.println(Insieme.appartiene(17,a));
    System.out.println(Insieme.vuoto(a));
    a = Insieme.elimina(11,a);
    a = Insieme.elimina(13,a);
    System.out.println(Insieme.appartiene(11,a));
    System.out.println(Insieme.appartiene(11,b));
    System.out.println(Insieme.vuoto(a));
    Insieme.visualizza(a);
    Insieme.visualizza(b);
  }
}

---------------------------------------

>javac ProvaInsieme.java
>java ProvaInsieme
true
{13}
{11, 13}
{11, 13}
true
true
false
false
false
true
true
{}
{11, 13}

---------------------------------------

class InsiemeP {
  private int maxElementi;
  private boolean[] elementi;

  /** Costruttore: costruisce e restituisce implicitamente un 
    * insieme vuoto */
  public InsiemeP(int num) {
    maxElementi = num;
    elementi = new boolean[maxElementi];
  }

  /** Costruttore copia: costruisce (e restituisce) un insieme 
    * uguale a quello passato come parametro */
  public InsiemeP(InsiemeP x) {
    maxElementi = x.maxElementi;
    elementi = new boolean[maxElementi];
    for (int i = 0; i < maxElementi; i++)
      elementi[i] = x.elementi[i];
  }

  /** Dice se l'insieme x e' vuoto */
  public static boolean vuoto(InsiemeP x) {
    boolean trovato = false;
    for(int i = 0; i < x.maxElementi; i++)
      if (x.elementi[i]) {
        trovato = true;
        break;
      }
    return !trovato;
  }

  /** Inserisce l'elemento e nell'insieme x */
  public static void inserisci(int e, InsiemeP x) {
    x.elementi[e] = true;
  }

  /** Elimina l'elemento e dall'insieme x */
  public static void elimina(int e, InsiemeP x) {
    x.elementi[e] = false;
  }

  /** Predicato di appartenenza di e a x */
  public static boolean appartiene(int e, InsiemeP x) {
    return x.elementi[e];
  }

  /** Visualizza il contenuto dell'insieme x */
  public static void visualizza(InsiemeP x) {
    boolean primo = true;
    System.out.print("{");
    for (int i = 0; i < x.maxElementi; i++)
      if (x.elementi[i])
        if (primo) {
          System.out.print(i);
          primo = false;
        } else 
          System.out.print(", " + i);
    System.out.println("}");
  }
}

---------------------------------------

class ProvaInsiemeP {
  // solo per testare l'implementazione
  public static void main(String[] args) {
    InsiemeP a = new InsiemeP(100);

    System.out.println(InsiemeP.vuoto(a));
    InsiemeP.inserisci(13,a);
    InsiemeP.visualizza(a);
    InsiemeP.inserisci(11,a);
    InsiemeP b = new InsiemeP(a);
    InsiemeP.visualizza(a);
    InsiemeP.visualizza(b);
    System.out.println(InsiemeP.appartiene(13,a));
    System.out.println(InsiemeP.appartiene(11,a));
    System.out.println(InsiemeP.appartiene(17,a));
    System.out.println(InsiemeP.vuoto(a));
    InsiemeP.elimina(11,a);
    InsiemeP.elimina(13,a);
    System.out.println(InsiemeP.appartiene(11,a));
    System.out.println(InsiemeP.appartiene(11,b));
    System.out.println(InsiemeP.vuoto(a));
    InsiemeP.visualizza(a);
    InsiemeP.visualizza(b);
  }
}

---------------------------------------

>javac ProvaInsiemeP.java
>java ProvaInsiemeP
true
{13}
{11, 13}
{11, 13}
true
true
false
false
false
true
true
{}
{11, 13}

---------------------------------------

class Punto {
  private double x;
  private double y;

  public Punto() {
    x = 0; 
    y = 0;
  }

  public Punto(double xCoord, double yCoord) {
    x = xCoord; 
    y = yCoord;
  }

  public static void set(Punto p, double xCoord, double yCoord){
    p.x = xCoord; 
    p.y = yCoord;    
  }

  public static void setX(Punto p, double xCoord) {
    p.x = xCoord;
  }

  public static void setY(Punto p, double yCoord) {
    p.y = yCoord;
  }
  
  public static double getX(Punto p) {
    return p.x;
  }

  public static double getY(Punto p) {
    return p.y;
  }

  public static String toString(Punto p) {
    return "(" + p.x + ", " + p.y + ")";
  }
}

---------------------------------------

class Cerchio {
  private Punto centro;
  private double raggio;

  public Cerchio() {
    centro = new Punto();
    raggio = 0;
  }

  public Cerchio(double x, double y, double r) {
    centro = new Punto(x,y);
    raggio = r;
  }

  public Cerchio(Punto c, double r) {
    centro = c;
    raggio = r;
  }

  public static void setCentro(Cerchio c, Punto p) {
    c.centro = p;
  }

  public static void setRaggio(Cerchio c, double r) {
    c.raggio = r;
  }
  
  public static Punto getCentro(Cerchio c) {
    return c.centro;
  }

  public static double getRaggio(Cerchio c) {
    return c.raggio;
  }

  public static String toString(Cerchio c) {
    return "cerchio: centro " + Punto.toString(c.centro) + 
      " raggio " + c.raggio;
  }
}

---------------------------------------

/** Programma per la prova di cerchi e punti */
class ProvaCerchio {

  public static void main (String[] args) {
    Punto p1 = new Punto();
    Punto p2 = new Punto(1,1);
    Cerchio c1 = new Cerchio();
    System.out.println(Cerchio.toString(c1));
    Cerchio c2 = new Cerchio(p1,0);
    System.out.println(Cerchio.toString(c2));
    Cerchio c3 = new Cerchio(p2,1);
    System.out.println(Cerchio.toString(c3));
  }
}

---------------------------------------

>javac ProvaCerchio.java
>java ProvaCerchio
cerchio: centro (0.0, 0.0) raggio 0.0
cerchio: centro (0.0, 0.0) raggio 0.0
cerchio: centro (1.0, 1.0) raggio 1.0

---------------------------------------

class Quadrato {
  private Punto altoSx;
  private Punto bassoDx;

  public Quadrato() {
    altoSx = new Punto(0,0);
    bassoDx = new Punto(0,0);
  }

  public Quadrato(double x1, double y1, double x2, double y2) {
    altoSx = new Punto(x1,y1);
    bassoDx = new Punto(x2,y2);
  }

  public Quadrato(Punto a, Punto b) {
    altoSx = a;
    bassoDx = b;
  }

  public static void setAltoSx(Quadrato q, Punto x) {
    q.altoSx = x;
  }

  public static  void setBassoDx(Quadrato q, Punto x) {
    q.bassoDx = x;
  }
  
  public static Punto getAltoSx(Quadrato q) {
    return q.altoSx;
  }

  public static Punto getBassoDx(Quadrato q) {
    return q.bassoDx;
  }

  public static String toString(Quadrato q) {
    return 
      "quadrato: alto Sx " + Punto.toString(q.altoSx) + 
      " basso Dx " + Punto.toString(q.bassoDx);
  }
}

---------------------------------------

/** Programma per la prova di cerchi, punti e quadrati*/
class ProvaCerchioQuadrato {

  public static void main (String[] args) {
    Punto p1 = new Punto();
    Punto p2 = new Punto(1,1);
    Cerchio c1 = new Cerchio();
    System.out.println(Cerchio.toString(c1));
    Cerchio c2 = new Cerchio(p1,0);
    System.out.println(Cerchio.toString(c2));
    Cerchio c3 = new Cerchio(p2,1);
    System.out.println(Cerchio.toString(c3));
    Quadrato q1 = new Quadrato();
    System.out.println(Quadrato.toString(q1));
    Quadrato q2 = new Quadrato(p1,p2);
    System.out.println(Quadrato.toString(q2));
  }
}

---------------------------------------

>javac ProvaCerchioQuadrato.java
>java ProvaCerchioQuadrato
cerchio: centro (0.0, 0.0) raggio 0.0
cerchio: centro (0.0, 0.0) raggio 0.0
cerchio: centro (1.0, 1.0) raggio 1.0
quadrato: alto Sx (0.0, 0.0) basso Dx (0.0, 0.0)
quadrato: alto Sx (0.0, 0.0) basso Dx (1.0, 1.0)