Struttura a nido d’ape con Java

Consegna :

Inserire il codice che disegna un esagono reiterato in una struttura a nido d’ape.

Struttura a nido d’ape
Risultato

Codice:

Classe Tela

package esagoni;
import java.awt.*;
import javax.swing.*;
public class Tela extends JPanel{
 
public void paintComponent(Graphics g)
{
//serve a disegnare nella finestra    
super.paintComponent(g);
 
//viene impostato il colore dello sfondo
this.setBackground(Color.WHITE);
 
//viene impostato il colore di g, quindi il colore con cui appariranno
//i disegni fatti utilizzando g
g.setColor(Color.BLACK);
 
//inizializziamo i due vettori x e y. il vettore x contiene le ascisse dei sei punti
//dell'esagono, mentre il vettore y contiene le ordinate dei punti. l'esagono
//ha 6 punti quindi i vettori hanno 6 elementi.
int x[] = new int[6];
int y[] = new int[6];
 
//i vettori vengono riempiti con le coordinate dei punti
vettoreX1(x);
vettoreY(y);
 
//
for (int i = 0; i<10; i++){
    //vengono disegnati 10 esagoni distanti 40 orizzontalmente
    for (int a = 0; a < 10; a++){
        esagoniX(x,y,g);
    }
    //il punto da cui si parte a disegnare si sposta verso il basso di 10
    cambioY(x,y,g);
    //si riempie il vettore x con altre coordinate quindi il punto da cui si
    //inizia a disegnare si sposta di 10 in orizzontale, per evitare che 
    //gli esagoni si sovrappongano
    vettoreX2(x);
    //vengono disegnati altri 10 esagoni
    for (int a = 0; a < 10; a++){
        esagoniX(x,y,g);
    }
    //il punto da cui si parte a disegnare si sposta verso il basso di 10
    cambioY(x,y,g);
    //viene riutilizzato il primo vettore, con le coordinate x uguali a 
    //quelle della prima riga
    vettoreX1(x);
}
}
 
public int[] vettoreX1 (int x[]){
    x[0] = -40;
    x[1] = x[0]+10;
    x[2] = x[1]+10;
    x[3] = x[2]+10;
    x[4] = x[2];
    x[5] = x[1];
    return x;
}
 
public int[] vettoreX2(int x[]){
    x[0] = -20;
    x[1] = x[0]+10;
    x[2] = x[1]+10;
    x[3] = x[2]+10;
    x[4] = x[2];
    x[5] = x[1];
    return x;
}
 
public int[] vettoreY (int y[]){
    y[0] = 10;
    y[1] = y[0]+10;
    y[2] = y[1];
    y[3] = y[0];
    y[4] = y[0]-10;
    y[5] = y[4];
    return y;
}
 
public void esagoniX (int x[], int y[], Graphics g){
    for (int i = 0; i < x.length; i++){
        x[i] = x[i]+40;
    }
    //x = vettore che contiene 6 coordinate orizzontali
    //y = vettore che contiene 6 coordinate verticali
    //6 = numero dei punti
    g.drawPolygon(x, y, 6);
}
 
public void cambioY (int x[], int y[], Graphics g){
    for (int i = 0; i < y.length; i++){
        y[i] = y[i]+10;
    }
}
}

Classe Esagoni

package esagoni;
//importare java swing serve a poter usare i componenti che contiene, per
//esempio jframe
import javax.swing.*;
public class Esagoni {
public static void main(String[] args) {
     
    //serve a cambiare la scritta in alto a sinistra
    JFrame t = new JFrame("Esagoni");
     
    //setDefaultCloseOperation() contiene tra parentesi l'operazione
    //che il programma esegue quando viene cliccata la x in alto a destra
//la scritta tra parentesi indica che quando viene cliccata
//la x, l'operazione di default
//è chiudere la finestra
    t.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
     
    //l'altra classe si chiama Tela, quindi viene creato un nuovo oggetto Tela
    Tela p = new Tela();
     
    //t è il JFrame, a cui viene aggiunto l'oggetto p(tela)
    t.add(p);
     
    //dimensioni della tela(la finestra che viene aperta quando si esegue
    //il programma)
    t.setSize(1000, 1000);
     
    //prima è stata solo creata, e ora è resa visibile
    t.setVisible(true);
}
}

Procedimento:

Dopo aver creato un nuovo progetto chiamato disegno, abbiamo creato due classi. Quella con il main è Esagoni, mentre l’altra è Tela.

Per disegnare gli esagoni con la struttura a nido d’ape bisogna disegnare degli esagoni. E’ possibile farlo in due modi:

•g.drawPolygon(obj Polygon)

•g.drawPolygon(x[], y[], i)

Il primo metodo permette di disegnare un poligono mettendo tra parentesi l’oggetto poligono, mentre il secondo permette di farlo con due array di interi e un numero intero. Il vettore x contiene le coordinate x dei punti e quello y le coordinate y dei punti, mentre i è il numero di punti del poligono, cioè dei vertici.

Nella struttura a nido d’ape ci sono tanti esagoni di fila disposti in più righe, quindi bisogna disegnare degli esagoni uguali, nella stessa riga, disposti a una certa distanza orizzontale.

Dopo che si è disegnata la prima riga, si fa la stessa cosa per la seconda, ma in questo caso la coordinata x del primo punto dell’esagono non è la stessa di quella del primo punto del primo esagono della riga sotto, quindi bisogna partire da un punto x diverso. Nella terza riga, invece, la coordinata x del primo punto del primo esagono è uguale a quella del primo punto del primo esagono della prima riga, quindi le coordinate x dei punti sono uguali ogni due righe.

Leave a Reply

Your email address will not be published.

This site uses Akismet to reduce spam. Learn how your comment data is processed.