LINGUAGGI E TRADUTTORI

LINGUAGGI e TRADUTTORI
Marsili Chiara
Relazione2: Classi derivate e astratte
Problema:
1. Costruire un ADT DrawPad che fornisca servizi per disegnare triangoli, rettangoli
e cerchi disponendo dell’astrazione SimpleDrawPad in grado di disegnare linee e
punti.
Realizzare un componente software che crei un oggetto draw
pad e testarlo
richiedendo il disegno di alcune linee, triangoli, rettangoli,cerchi,…di colori e
spessori diversi.
2. Data la classe astratta Shape, derivare nuove classi relative alle figure che
specifichino come disegnarsi.
Costruire un componente software che testi tali classi.
Analisi:
1. Per realizzare questo progetto è necessari derivare la classe DrawPad da quella già
disponibile SimpleDrawPad in grado di disegnare linee e punti di diversi colori e
dimensioni, e determinare delle funzioni in grado di disegnare anche rettangoli,
triangoli e cerchi.
2. Per il secondo problema bisogna invece costruire diverse classi, una per ogni
figura geometrica derivandole dalla classe astratta Shape; in questo modo, ongi
volta che si vuole implementare il programma ocn ulteriori figure, invece di creare
astrazioni da DrawPad, basta aggiungere nuove classi derivate da Shape.
Progetto:
1. La classe **DrawPad** è un oggetto derivato dall’oggetto astratto
**SimpleDrawPad** fornitoci in partenza. Quest’ultimo è già in grado di tracciare
linee e fare punti di diverse dimensioni e colori, mentre la nuova classe derivata
sarà in grado di disegnare rettangoli (o quadrati), triangoli e cerchi.
I metodi della classe **DrawPad** sono tre:
drawBox – dati in ingresso le coordinate di due estremi opposti (in alto a sinistra
e in basso a destra), questo disegna un rettangolo o un quadrato;
drawTriangle – dati in ingress le coordinate dei tre vertici, esso disegna un
triangolo;
drawCircle – dati in ingresso le coordinate del centro e la musura del raggio,
viene disegnato un cerchio.
In un secondo momento ho derivato il DrawPad creando una nuova classe
**DrawPad2** ed a questa sono stati aggiunti nuovi metodi quali:
drawArc – richiede in ingresso gli stessi dati del cerchio più il valore dei gradi di
partenza e di arrivo per disegnare un arco;
spinBox – richiede in ingresso i dati del drawBox più l’angolo di rotazione del
rettangolo restituendo un rettangolo ruotato;
flowerBox – anche questo richiede tutti i dati del drawBox e la quantità di
rettangoli che si vogliono disegnare per formare un fiore.
2. Nel secondo progetto si sono costruite tre classi, **Box.java**, **Triangle.java**,
**Circle.java**, derivate dalla classe astratta Shape.
La classe **Box** determina il metodo di costruzione di un rettangolo Box coi
seguenti parametri: coordinate dei due spigoli opposti, colore ( rosso, verde e blu)
e spessore; inoltre presenta il metodo per disegnarsi draw(pad).
La stessa cosa per le alte due classi Triangle e Circle che vogliono i parametri
descritti sopra nel drawTriangle e nel drawCircle rispettivamente più il colore e lo
spessore, e di seguiti dicono come disegnarsi.
Implementazione:
1. La classe **DrawPad** è in grado di eseguire alcuni metodi per
disegnare rettangoli, triangoli e cerchi grazie a determinate funzioni di seguito
spiegate.
Il metodo drawBox chiede l’immissione delle coordinate di due soli punti degli
spigoli opposti di un rettangolo perchè da essi si possono determinare anche le
coordinate degli altri due spigoli, dato che abbiamo tutti i valori delle x e delle y e,
tracciando delle linee da un punto all’altro, si può disegnare il rettangolo.
Il metodo drawTriangle richiede le coordinate dei tre vertici e, senza nessun
calcolo, traccia le linee da un vertice all’altro per disegnare un triangolo.
Il metodo drawCircle chiede invece le coordinate del centro e la lunghezza del
raggio; con un ciclo ‘for’ che parte da 0 e arriva a 2*PI aumentando di un grado
alla volta, determina e disegna un punto per formare così una circonferenza.
I metodi della classe **DrawPad2** sono invece strutturati come segue.
DrawArc, che chiede in ingresso le coordinate del centro, la lunghezza del raggio
e i gradi di partenza (a) e di arrivo (b), si comporta come il cerchio partendo però
da ‘a’ e arrivando a ‘b’.
Poi c’è il metodo spinBox che, ricevuti i dati richiesti anche da drawBox più il
grado di rotazione, calcola mediante funzioni matematiche le coordinate di tutti
gli spigoli tranne il primo che rimane fermo e ne traccia le linee.
Infine il metodo flowerBox disegna un fiore mediante la rotazione di un
determinato numero ‘a’ di rettangoli deciso da input, aumentando il grado di
rotazione ogni volta di 2*PI/a. Ogni rettangolo viene disegnato con un intervallo
l’uno dall’altro di 0,1 secondi.
2. Il secondo progetto estende la classe **Shape** determinando, prima il metodo
per costruire i diversi oggetti chiedendo anche l’immissione dei valori dei
colori(rosso, verde, blu) e dello spessore, e poi il metodo mediante il quale si
disegnano che è lo stesso dei corrispondenti metodi visti sopra.
Casi d’uso:
In primo luogo è stato progettato e sviluppato un componente software in grado di
disegnare rettangoli, triangoli, cerchi; è stato poi implementato con l’utilizzo del
DrawPad2 che è in grado di disegnare anche archi, rettangoli ruotati e fiori.
Quindi è stata prima creata una classe **Example** che crea un DrawPad pad e lo
mostra show. Vengono subito impostati lo spessore e il colore dei disegni che
verranno a seguire con i metodi setCurrentThickness e setCurrentColor.
E’ stata poi disegnata una faccia simpatica con l’utilizzo di un quadrato per il
contorno del viso, due linee per la bocca sorridente, un cerchio per il naso e due
tringoli simmetrici con due punti all’interno per gli occhi, ogni volta cambiando
colore e spessore a seconda dell’uso. Infine è stata aggiunto dopo una breve pausa
un semplice messaggio di saluto creato con delle linee, un triangolo e un cerchio.
Un esempio di come sono stati utilizzati i metodi:
pad.drawCircle(200,200,20);
x del centro
lunghezza raggio
y del centro
pad.setCurrentColor(0.8f,0.4f,0.2f);
rosso
verde
blu
la f dopo la componente di ogni colore sta ad indicare che non è un numero intero
ma reale.
Ed ecco il risultato a video dell’esecuzione di Example.class:
E’ stato poi creato un’altro componente software **Example2** per utilizzare i metodi
di DrawPad2 ed è stato creato un’altro pad che disegnasse quanto segue:
prima è stata disegnata l’erba con dei triangolini, poi il fiore col gambo fatto da un
arco; è stato pio aggiunto il sole con un cerchio e i suioi raggi con delle linee, ed il
risultato è il seguente:
Per il secondo progetto è stato creato un terzo esempio **Example3** con l’utilizzo
delle tre classi Box, Triangle e Circle.
Quì è stato creato un oggetto SimpleDrawPad pad e poi dato il comando show per
mostrarlo. Poi sono stati creati tre oggetti Shape: shape1 come nuovo Box, shape2
come nuovo Triangle e shape3 come nuovo Cirlce. Dopo la creazione gli è stato dato
il comando per disegnarsi draw(pad) e, dopo aver visualizzato il primo per 2 secondi,
è stato cancellato col clear e visualizzati come questo anche gli altri due col seguente
risultato:
Concetti e tecniche acquisite:
Con la realizzazione di questo progetto ho applicato le mie conoscenze sulle classi
astratte e derivate.
Ho avuto più problemi con la realizzazione del secondo progetto poichè non avevo
compreso bene il concetto di classi astratte, ma con l’applicazione sono riuscita a
prendere più familiarità con quest’ultime.
Col primo progetto invece sono riuscita a prendere più confidenza sin dall’inizio
riuscendo ad implementrlo a mio piacere.
Penso anche di aver capito meglio come strutturare la relazione scritta.
Progetti:
**DrawPad.java**
/*
* DrawPad.java
*/
import tools.*;
/**
* DrawPad is an object that draws boxes,
* triangles and circles.
*/
public class DrawPad extends SimpleDrawPad {
public DrawPad() { }
/**
* Draws a box (square or rectangle) providing two diagonal extremes
* points; the hightest one on the left, and the lowest one on the right.
*/
public void drawBox(int x1, int y1, int x2, int y2) {
drawLine(x1,y1,x1,y2);
drawLine(x1,y2,x2,y2);
drawLine(x2,y2,x2,y1);
drawLine(x2,y1,x1,y1); }
/**
* Draw a triangle providing the coordinates of the three vertexes.
*/
public void drawTriangle(int x1, int y1, int x2, int y2, int x3, int y3) {
drawLine(x1,y1,x2,y2);
drawLine(x2,y2,x3,y3);
drawLine(x3,y3,x1,y1); }
/**
* Draw a circle receiving the coordinates of the center and the lenght of the ray.
*/
public void drawCircle(int xo, int yo, int r) {
double xc, yc, a;
for(a=0; a<(2*Math.PI); a+=(Math.PI/180))
{ xc = xo+r*Math.cos(a);
yc = yo+r*Math.sin(a);
drawPoint((int) xc,(int) yc); }
}
}
**Example.java**
/*
* Example.java
*/
import tools.*;
public class Example extends java.lang.Object {
public static void main (String args[]) {
// create a new pad
DrawPad pad = new DrawPad();
// show the pad
pad.show();
// set thickness and color
pad.setCurrentThickness(4);
pad.setCurrentColor(0.8f,0.4f,0.2f);
// draw a line
pad.drawLine(140,240,200,270);
pad.drawLine(260,240,200,270);
// draw a point
pad.setCurrentThickness(10);
pad.setCurrentColor(0,1,0);
pad.drawPoint(150,170);
pad.drawPoint(250,170);
// draw a box
pad.setCurrentColor(1,1,0);
pad.setCurrentThickness(2);
pad.drawBox(100,100,300,300);
//draw a triangle
pad.setCurrentColor(0,0.5f,0.8f);
pad.drawTriangle(110,160,170,190,130,120);
pad.drawTriangle(290,160,230,190,270,120);
// draw a circle
pad.setCurrentThickness(5);
pad.setCurrentColor(1,0,0);
pad.drawCircle(200,200,20);
// wait a little
try {
Thread.currentThread().sleep(1000);
} catch (Exception ex){
}
// print a word
pad.setCurrentThickness(3);
pad.setCurrentColor(0.5f,0,0.5f);
pad.drawLine(160,310,150,350);
pad.drawLine(190,310,180,350);
pad.drawLine(155,330,185,330);
pad.drawLine(210,310,200,350);
pad.drawTriangle(230,310,250,310,240,340);
pad.drawCircle(240,350,7);
// wait a little
try {
Thread.currentThread().sleep(5000);
} catch (Exception ex){
}
// exit
System.exit(0);
}
}
**DrawPad2.java**
/*
* DrawPad2.java
*/
/**
* DrawPad2 is an object that draws
* arcs, spun box and flowers.
*/
public class DrawPad2 extends DrawPad {
public DrawPad2() { }
/**
* Draws an arc receiving the coordinates of the cente, the lenght of the ray,
* and the value of the initial and final degree.
*/
public void drawArc(int xo, int yo, int r, double a, double b) {
double xc, yc;
double i;
for(i=a; i<b; i+=(Math.PI/180))
{ xc = xo+r*Math.cos(i);
yc = yo+r*Math.sin(i);
drawPoint((int) xc,(int) yc); }
}
/**
* Draws a spun box (square or rectangle) providing two diagonal extremes
* points and the degree of rotation.
*/
public void spinBox(int x1, int y1, int x2, int y2, double a) {
double x3, y3, x4, y4, x5, y5, b;
b = a+(Math.PI/2);
x3 = (x2-x1)*Math.cos(a)+x1;
y3 = (x2-x1)*Math.sin(a)+y1;
x4 = (x2-x1)*Math.cos(a)+(y2-y1)*Math.cos(b)+x1;
y4 = (x2-x1)*Math.sin(a)+(y2-y1)*Math.sin(b)+y1;
x5 = (y2-y1)*Math.cos(b)+x1;
y5 = (y2-y1)*Math.sin(b)+y1;
drawLine(x1,y1,(int) x3,(int) y3);
drawLine((int) x3,(int) y3,(int) x4,(int) y4);
drawLine((int) x4,(int) y4,(int) x5,(int) y5);
drawLine((int) x5,(int) y5, x1, y1); }
/**
* Draws a flower joining a determinated number of spin box.
*/
public void flowerBox(int x1, int y1, int x2, int y2,int b) {
double a;
for (a=0;a<(2*Math.PI);a+=(Math.PI/b)) {
spinBox(x1,y1,x2,y2,a);
try {
Thread.currentThread().sleep(100); }
catch (Exception ex){ }
}
}
}
**Example2.java**
/*
* Example2.java
*/
import tools.*;
public class Example2 extends java.lang.Object {
public static void main (String args[]) {
// create a new pad
DrawPad2 pad = new DrawPad2();
// show the pad
pad.show();
// draw the grass
pad.setCurrentThickness(3);
pad.setCurrentColor(0,1,0);
pad.drawTriangle(160,370,170,370,150,350);
pad.drawTriangle(150,370,160,370,140,350);
pad.drawTriangle(140,370,150,370,130,350);
pad.drawTriangle(190,370,200,370,210,350);
pad.drawTriangle(180,370,190,370,200,350);
pad.drawTriangle(170,370,180,370,190,350);
//draw a flower
pad.setCurrentThickness(3);
pad.setCurrentColor(1,0.8f,0);
pad.flowerBox(220,250,270,300,10);
pad.setCurrentThickness(3);
pad.setCurrentColor(0,1,0);
pad.drawArc(320,360,150,3,3.9);
//draw the sun
pad.setCurrentThickness(3);
pad.setCurrentColor(1,1,0);
pad.drawCircle(50,50,50);
pad.drawLine(10,90,10,290);
pad.drawLine(30,100,50,300);
pad.drawLine(50,110,80,310);
pad.drawLine(70,110,120,300);
pad.drawLine(90,100,140,250);
pad.drawLine(100,90,250,140);
pad.drawLine(110,70,300,120);
pad.drawLine(110,50,310,80);
pad.drawLine(100,30,290,50);
pad.drawLine(90,10,280,10);
// wait a little
try {
Thread.currentThread().sleep(10000);
} catch (Exception ex){
}
// exit
System.exit(0);
}
}
**Example2.java**
/**
* Box is an object that draws a rectangle or a square providing 2 diagonal
* extremes points, red component, green component, blue component, and the
* thickness.
*/
import tools.*;
public class Box extends Shape {
/**
* Costructs a box.
*/
public Box(int xr, int yr, int xl, int yl, float rx, float gx, float bx, int tx) {
super(rx, gx, bx, tx);
x1=xr; y1=yr;
x2=xl; y2=yl;
r=rx; g=gx;
b=bx; t=tx; }
/**
* Draws a box providing a SimpleDrawPad object.
*/
public void draw(SimpleDrawPad pad) {
pad.setCurrentColor(r, g, b);
pad.setCurrentThickness(t);
pad.drawLine(x1, y1, x1, y2);
pad.drawLine(x1, y2, x2, y2);
pad.drawLine(x2, y2, x2, y1);
pad.drawLine(x2, y1, x1, y1);
// Private data.
private int x1, x2, y1, y2, t;
private float r, g, b;
}
}
**Triangle.java**
/**
* Draw a triangle providing the coordinates of the three vertexes,
* red component, green component, blue component, and the
* thickness.
*/
import tools.*;
public class Triangle extends Shape {
/**
* Costructs a triangle.
*/
public Triangle(int xa, int ya, int xb, int yb, int xc, int yc, float rx, float gx, float bx, int tx) {
super(rx, gx, bx, tx);
x1=xa; y1=ya;
x2=xb; y2=yb;
x3=xc; y3=yc;
r=rx; g=gx;
b=bx; t=tx; }
/**
* Draws a triangle providing a SimpleDrawPad object.
*/
public void draw(SimpleDrawPad pad) {
pad.setCurrentColor(r, g, b);
pad.setCurrentThickness(t);
pad.drawLine(x1, y1, x2, y2);
pad.drawLine(x2, y2, x3, y3);
pad.drawLine(x3, y3, x1, y1); }
// Private data.
private int x1, y1, x2, y2, x3, y3, t;
private float r, g, b;
}
**Circle.java**
/**
* Draw a circle providing the coordinates of the center,
* the lenght of the ray, red component, green component,
* blue component, and the thickness.
*/
import tools.*;
public class Circle extends Shape {
/**
* Costructs a circle.
*/
public Circle(int x, int y, int c, float rx, float gx, float bx, int tx) {
super(rx, gx, bx, tx);
xo=x; yo=y; ray=c;
r=rx; g=gx;
b=bx; t=tx; }
/**
* Draws a circle providing a SimpleDrawPad object.
*/
public void draw(SimpleDrawPad pad) {
double xc, yc,a;
pad.setCurrentColor(r, g, b);
pad.setCurrentThickness(t);
for (a=0; a<(2*Math.PI); a+=(Math.PI/180))
{ xc=xo+ray*Math.cos(a);
yc=yo+ray*Math.sin(a);
pad.drawPoint((int) xc, (int) yc); }
}
// Private data.
private int xo, yo, ray, t;
private float r, g, b;
}
**Example3**
/*
* Example3.java
*/
import tools.*;
public class Example3 extends java.lang.Object {
public static void main (String args[]) {
// create a new pad
SimpleDrawPad pad = new SimpleDrawPad();
// show the pad
pad.show();
//create a shape
Shape shape1 = new Box(100,100,200,250,1,1,0,10);
shape1.draw(pad);
// wait a little
try {
Thread.currentThread().sleep(2000);
} catch (Exception ex){
}
pad.clear();
//create a shape
Shape shape2 = new Triangle(150,150,100,300,300,250,0,1,1,6);
shape2.draw(pad);
// wait a little
try {
Thread.currentThread().sleep(2000);
} catch (Exception ex){
}
pad.clear();
//create a shape
Shape shape3 = new Circle(200,200,140,1,0,1,4);
shape3.draw(pad);
// wait a little
try {
Thread.currentThread().sleep(2000);
} catch (Exception ex){
}
pad.clear();
// exit
System.exit(0);
}
}