Calcolatrice java

[Fab996]

[FONT=&amp]Vorrei chiedere se qualcuno potesse dare un'occhiata al mio codice e dirmi cosa potrei migliorare, per ora ho fatto il layout
[/FONT]

import javax.swing.*;
import java.awt.*;
class Calcolatrice extends JFrame {
    //costruttore
    public Calcolatrice() {
        super(); //invoca costruttore di JFrame
        setTitle("Calcolatrice");
        setSize(300,300);
        setMinimumSize(new Dimension(300,300));
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setResizable(true);
        inizializzaGUI();
        setVisible(true);
    }
    public void inizializzaGUI() {
        JPanel intermedio; //pannello intermedio-principale
        JPanel tasti; //pannello secondario per i tasti
        JPanel cancella; //pannello secondario per cancellare
        JLabel etichetta;
        JButton cancellaC; //C
        JButton cancellaCE; //CE
        JButton zero,uno,due,tre,quattro,cinque,sei,sette,otto,nove,div,molt,som,sotr,virgola,segno,uguale,radice,percent;
        JButton definire; //pulsante da definire;
        // costruzione dei tre pannelli col rispettivo layout
        tasti = new JPanel();
        tasti.setLayout(new GridLayout(4,5));
        intermedio = new JPanel();
        intermedio.setLayout(new GridLayout(3,1));
        cancella = new JPanel();
        cancella.setLayout(new GridLayout(1,2));
        etichetta = new JLabel("0");
        //assegnazione di tutti i bottoni ed etichetta
        cancellaC = new JButton("C");
        cancellaCE = new JButton("CE");
        zero = new JButton("0");
        uno = new JButton("1");
        due = new JButton("2");    
        tre = new JButton("3");
        quattro = new JButton("4");
        cinque = new JButton("5");
        sei = new JButton("6");
        sette = new JButton("7");
        otto = new JButton("8");
        nove = new JButton("9");
        div = new JButton("/");
        molt = new JButton("*");
        som = new JButton("+");
        sotr = new JButton("-");
        virgola = new JButton(",");
        segno = new JButton("+/-");
        uguale = new JButton("=");
        radice = new JButton("sqrt");
        percent = new JButton("%");
        definire = new JButton("1/x");
        //aggiunta Component(atomici) ai vari pannelli
        cancella.add(cancellaCE);
        cancella.add(cancellaC);
        tasti.add(sette);
        tasti.add(otto);
        tasti.add(nove);
        tasti.add(div);
        tasti.add(radice);
        tasti.add(quattro);
        tasti.add(cinque);
        tasti.add(sei);
        tasti.add(molt);
        tasti.add(percent);
        tasti.add(uno);
        tasti.add(due);
        tasti.add(tre);
        tasti.add(sotr);
        tasti.add(definire);
        tasti.add(zero);
        tasti.add(segno);
        tasti.add(virgola);
        tasti.add(som);
        tasti.add(uguale);
        //aggiunta dei vari pannelli al pannello principale(Intermedio)
        intermedio.add(etichetta);
        intermedio.add(cancella);
        intermedio.add(tasti);
        //aggiunta pannelo principale(Intermedio) al Frame
        getContentPane().add(intermedio);
    }
    public static void main(String[] args) {
        new Calcolatrice();
    }
}

 

[DispatchCode]

Ciao,

Ci possono essere un pò di cose da rivedere.
Una cosa inutile è l'invocazione di super() all'interno del costruttore (avviene in automatico, è quindi ridondante). Piuttosto per settare il titolo potresti utilizzare il super stesso:

super("Calcolatrice");

Un aspetto che quasi sicuramente sarà causa di problemi è la dichiarazione e la definizione delle variabili all'interno di un metodo. Quando avrai bisogno i JButton al di fuori (magari perchè è stato generato un evento), non sarai in grado di utilizzarli.

Potresti valutare l'utilizzo di un ArrayList per contenere tutti i JButton. Alla creazione di ogni JButton aggiungerai direttamente un listener e magari anche un command (setActionCommand()).

Anche nel set dei Layout sui JPanel ci sono ripetizioni inutili. Il costruttore può già ricevere un LayoutManager.

Di solito si consiglia l'inizializzazione dell'applicazione al di fuori del contesto dell'EDT (nel tuo caso non è d'obbligo, per ora almeno).

Qui puoi avere maggiori info: https://docs.oracle.com/javase/tutorial/uiswing/concurrency/index.html

 

[Fab996]

Ciao,

Ci possono essere un pò di cose da rivedere.
Una cosa inutile è l'invocazione di super() all'interno del costruttore (avviene in automatico, è quindi ridondante). Piuttosto per settare il titolo potresti utilizzare il super stesso:

super("Calcolatrice");

Un aspetto che quasi sicuramente sarà causa di problemi è la dichiarazione e la definizione delle variabili all'interno di un metodo. Quando avrai bisogno i JButton al di fuori (magari perchè è stato generato un evento), non sarai in grado di utilizzarli.

Potresti valutare l'utilizzo di un ArrayList per contenere tutti i JButton. Alla creazione di ogni JButton aggiungerai direttamente un listener e magari anche un command (setActionCommand()).

Anche nel set dei Layout sui JPanel ci sono ripetizioni inutili. Il costruttore può già ricevere un LayoutManager.

Di solito si consiglia l'inizializzazione dell'applicazione al di fuori del contesto dell'EDT (nel tuo caso non è d'obbligo, per ora almeno).

Qui puoi avere maggiori info: https://docs.oracle.com/javase/tutorial/uiswing/concurrency/index.html

Intanto grazie per la risposta, non capisco perchè l'invocazione di super() avviene in automatico, che poi sinceramente non ho ben afferrato perchè devo estendere JFrame, cioè alla fine io non ho aggiunto nessun metodo ulteriore, se fosse così mi viene da pensare che anche quando vado ad usare la classe Math devo estendere Math.
Per le variabili, ho visto che in molti esempi che vengono dichiarate d'istanza, ossia fuori dalla classe come hai suggerito tu, però ancora non ho domestichezza con classi abbastanza complicate, ero abituato a classi più semplici e quindi ho dichiarato le variabili internamente al metodo, come sempre.
Come faccio a fargli ricevere direttamente un LayoutManager? E ultimo in che senso si consiglia l'inizializzazione dell'applicazione al di fuori del contesto dell'EDT(editor di testo?), forse è il problema che ho che quando eseguo mi si apre anche il terminale oltre che l'applicazione(?)

 

[DispatchCode]

Intanto grazie per la risposta, non capisco perchè l'invocazione di super() avviene in automatico,

Quando hai una gerarchia di classi la chiamata avviene in un determinato ordine; tu hai una gerarchia di classi in quanto stai utilizzando l'ereditarietà (estendendo JFrame).

Avviene in automatico poichè viene aggiunta in fase di compilazione (ecco perchè dicevo che è ridondante). Se la inserisci esplicitamente tu, non incorri in nessun errore, ovviamente (nemmeno "logico").

che poi sinceramente non ho ben afferrato perchè devo estendere JFrame, cioè alla fine io non ho aggiunto nessun metodo ulteriore, se fosse così mi viene da pensare che anche quando vado ad usare la classe Math devo estendere Math.

Questo è uno dei principi della OOP. Quando estendi una classe stai dicendo che la tua classe è un; puoi anche evitare di estendere JFrame e creare un'istanza dello stesso all'interno della tua classe. In questo caso si dice che la tua classe ha un.
Da un punto di vista di funzionamento, non cambia nulla. Da un punto di vista legato all'utilizzo cambia molto: se crei un oggetto JFrame dovrai richiamare su esso tutti i metodi che ora stai invocando direttamente (setSize(), setTitle(),...).
Quando estendi un JFrame stai creando una tua versione di JFrame personalizzata, con campi di testo ed elementi vari. Estendendo la classe puoi anche fare ovviamente l'override di uno o più metodi.

Per le variabili, ho visto che in molti esempi che vengono dichiarate d'istanza, ossia fuori dalla classe come hai suggerito tu, però ancora non ho domestichezza con classi abbastanza complicate, ero abituato a classi più semplici e quindi ho dichiarato le variabili internamente al metodo, come sempre.

Quello sarebbe l'approccio corretto, altrimenti al di fuori di quel metodo non potrai utilizzare nessuno dei tuoi componenti. Ti consiglio di dichiarare fuori tutto ciò che prevedi di utilizzare in giro per il codice. Spesse volte è utile anche dichiarare fuori i JPanel, dipende da ciò che si deve fare.

Come faccio a fargli ricevere direttamente un LayoutManager?

La classe fornisce una versione del costruttore che riceve un LayoutManager. Ad esempio:

JPanel tasti = new JPanel(new GridLayout(4,5));

E ultimo in che senso si consiglia l'inizializzazione dell'applicazione al di fuori del contesto dell'EDT(editor di testo?), forse è il problema che ho che quando eseguo mi si apre anche il terminale oltre che l'applicazione(?)

Event Dispatch Thread. Il link di prima affronta proprio tutto ciò. ;)

 

[Fab996]

Questo è uno dei principi della OOP. Quando estendi una classe stai dicendo che la tua classe è un; puoi anche evitare di estendere JFrame e creare un'istanza dello stesso all'interno della tua classe. In questo caso si dice che la tua classe ha un.
Da un punto di vista di funzionamento, non cambia nulla. Da un punto di vista legato all'utilizzo cambia molto: se crei un oggetto JFrame dovrai richiamare su esso tutti i metodi che ora stai invocando direttamente (setSize(), setTitle(),...).
Quando estendi un JFrame stai creando una tua versione di JFrame personalizzata, con campi di testo ed elementi vari. Estendendo la classe puoi anche fare ovviamente l'override di uno o più metodi.

Grazie per la spiegazione molto chiara, ti ho allegato due immagini in cui viene realizzata la stessa applicazione sia con che senza estensione di JFrame. L'unica differenza che noto è che come hai detto se non estendo la classe devo richiamare l'oggetto, nel caso dell'immagine l'oggetto win, però nell'immagine che invece estende JFrame comunque viene fatta l'invocazione sull'oggetto this; mentre io ho fatto direttamente setSize()... io fin'ora ho sempre usato this per riferirmi alle variabili d'istanza, non capisco questo uso fatto dall'immagine...

Quello sarebbe l'approccio corretto, altrimenti al di fuori di quel metodo non potrai utilizzare nessuno dei tuoi componenti. Ti consiglio di dichiarare fuori tutto ciò che prevedi di utilizzare in giro per il codice. Spesse volte è utile anche dichiarare fuori i JPanel, dipende da ciò che si deve fare.

Ho dichiarato i vari JButton,JLabel come variabili distanza, solo non le ho assegnate in quanto mi dava come errore <identifier expected>, quindi le ho assegnate direttamente nel metodo; però le dichiarazioni delle variabili al di fuori dei metodi le devo fare static o normali per poterle riutilizzare in tutti i metodi? Perchè non ho ben capito quando dichiarare static una variabile(variabile di classe) o normale(variabile d'istanza), alla fine tutte possono accedere a tutti i metodi della classe, l'unica differenza è che i metodi statici possono accedere e modificare solo le variabili di classe, mentre i metodi non-static possono accedere e modificare sia variabili dichiarate static che non.

 

[DispatchCode]

L'unica differenza che noto è che come hai detto se non estendo la classe devo richiamare l'oggetto, nel caso dell'immagine l'oggetto win, però nell'immagine che invece estende JFrame comunque viene fatta l'invocazione sull'oggetto this; mentre io ho fatto direttamente setSize()... io fin'ora ho sempre usato this per riferirmi alle variabili d'istanza, non capisco questo uso fatto dall'immagine...

Anche quello è ridondante. La parola chiave this la si utilizza per riferirsi all'oggetto corrente, quello della classe in cui ti trovi più precisamente. Quindi richiamare un metodo come il setSize() in quel modo, anteponendo il this, è come non utilizzarlo. Personalmente non utilizzo codice inutile, tende - a mio avviso - a complicare un pò la lettura in determinate situazioni.
La parola chiave this ha anche altre applicazioni: se hai due variabili con lo stesso nome, una come variabile di istanza ed una come parametro di una funzione, la parola chiave this ti permette di far riferimento alla variabile di istanza della classe. Per essere chiaro:

class Example {
  private String name;

  // .........
  // .........

  void setName(String name) {
    this.name = name;
  }

}

Stesso discorso se utilizzata in un costruttore.
Codice come questo lo vedrai molto spesso.

Ho dichiarato i vari JButton,JLabel come variabili distanza, solo non le ho assegnate in quanto mi dava come errore <identifier expected>, quindi le ho assegnate direttamente nel metodo; però le dichiarazioni delle variabili al di fuori dei metodi le devo fare static o normali per poterle riutilizzare in tutti i metodi? Perchè non ho ben capito quando dichiarare static una variabile(variabile di classe) o normale(variabile d'istanza), alla fine tutte possono accedere a tutti i metodi della classe, l'unica differenza è che i metodi statici possono accedere e modificare solo le variabili di classe, mentre i metodi non-static possono accedere e modificare sia variabili dichiarate static che non.

Le variabili static sono variabili globali, è meglio non abusarne. Se crei una variabile d'istanza dichiarata come static non verrà fatta alcuna copia di quella variabile quando viene istanziata la classe. In pratica: tutti gli oggetti condividono la stessa copia della variabile e la modifica fatta da un oggetto si riflette su tutti gli altri. Hanno limitazioni, così come i metodi static.
Esempi di metodi statici sono quelli della classe Math che hai citato prima. Questi metodi vengono chiamati infatti utilizzando il nome della classe (segno che i metodi interni sono statici), così come le costanti al suo interno. Esempi sono: Math.pow(), Math.sqrt() e gli altri.

Per quanto riguarda gli errori, dovresti mostrare il codice aggiornato. ;)

 

[Fab996]

Grazie mille!:D Più che altro la funzione del this standard la conoscevo(quella per riferirsi alle variabili d'istanza per non avere ambiguità), mentre quella che hai citato tu per riferirsi all'oggetto corrente non mi è del tutto familiare, tipo in questo codice l'assegnazione t=this come devo interpretarla?

class NodoLista {

    public Object info;
    public NodoLista next;


    public NodoLista() {
        this.info = null;
        this.next = null;
    }
    public NodoLista add(Object v) {
        NodoLista t;
        if (this.info != null) {
            t = new NodoLista(v);
            this.next = t;
        }
        else {
            this.info = v;
            t = this;
        }
        return t;
    }
    
    public static void main(String[] args) {
        NodoLista a = new NodoLista();
        a.add("ciao").add(8).add("hey");
    }

Per quanto riguarda gli errori, dovresti mostrare il codice aggiornato. ;)

Questa è la calcolatrice, ho modificato un pò la grafica, anche se mancano gli eventi

import javax.swing.*;import java.awt.*;
class Calcolatrice extends JFrame {
    JButton zero,uno,due,tre,quattro,cinque,sei,sette,otto,nove,div,molt,som,sotr,virgola,segno,uguale,radice,percent,definire;
    //costruttore
    public Calcolatrice() {
        super("Calcolatrice"); //invoca costruttore di JFrame
        setSize(320,300);
        setMinimumSize(new Dimension(320,300));
        setMaximumSize(new Dimension(500,500));
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setResizable(true);
        inizializzaGUI();
        setVisible(true);
    } 
    public void inizializzaGUI() {
        JPanel intermedio; //pannello intermedio-principale
        JPanel tasti3; //pannello secondario per i tasti
        JPanel tasti4;
        JPanel tasti5;
        JPanel tasti6;
        JPanel cancella; //pannello secondario per cancellare
        JLabel etichetta;
        JButton cancellaC; //C
        JButton cancellaCE; //CE
        // costruzione dei tre pannelli col rispettivo layout
        tasti3 = new JPanel(new GridLayout(1,5));
        tasti4 = new JPanel(new GridLayout(1,5));
        tasti5 = new JPanel(new GridLayout(1,5));
        tasti6 = new JPanel(new GridLayout(1,5));
        intermedio = new JPanel(new GridLayout(6,1));
        cancella = new JPanel(new GridLayout(1,2));
        //assegnazione componenti 
        etichetta = new JLabel("0");
        cancellaC = new JButton("C");
        cancellaCE = new JButton("CE");
        zero = new JButton("0");
        uno = new JButton("1");
        due = new JButton("2");    
        tre = new JButton("3");
        quattro = new JButton("4");
        cinque = new JButton("5");
        sei = new JButton("6");
        sette = new JButton("7");
        otto = new JButton("8");
        nove = new JButton("9");
        div = new JButton("/");
        molt = new JButton("*");
        som = new JButton("+");
        sotr = new JButton("-");
        virgola = new JButton(",");
        segno = new JButton("+/-");
        uguale = new JButton("=");
        radice = new JButton("sqrt");
        percent = new JButton("%");
        definire = new JButton("1/x");
        //aggiunta Component(atomici) ai vari pannelli
        cancella.add(cancellaCE);
        cancella.add(cancellaC);
        tasti3.add(sette);
        tasti3.add(otto);
        tasti3.add(nove);
        tasti3.add(div);
        tasti3.add(radice);
        tasti4.add(quattro);
        tasti4.add(cinque);
        tasti4.add(sei);
        tasti4.add(molt);
        tasti4.add(percent);
        tasti5.add(uno);
        tasti5.add(due);
        tasti5.add(tre);
        tasti5.add(sotr);
        tasti5.add(definire);
        tasti6.add(zero);
        tasti6.add(segno);
        tasti6.add(virgola);
        tasti6.add(som);
        tasti6.add(uguale);
        //aggiunta dei vari pannelli al pannello principale(Intermedio)
        intermedio.add(etichetta);
        intermedio.add(cancella);
        intermedio.add(tasti3);
        intermedio.add(tasti4);
        intermedio.add(tasti5);
        intermedio.add(tasti6);
        //aggiunta pannelo principale(Intermedio) al Frame
        getContentPane().add(intermedio);
    }
    public static void main(String[] args) {
        new Calcolatrice();
    }
}

 

[DispatchCode]

Questo codice:

class NodoLista {

    public Object info;
    public NodoLista next;


    public NodoLista() {
        this.info = null;
        this.next = null;
    }
    public NodoLista add(Object v) {
        NodoLista t;
        if (this.info != null) {
            t = new NodoLista(v);
            this.next = t;
        }
        else {
            this.info = v;
            t = this;
        }
        return t;
    }
    
    public static void main(String[] args) {
        NodoLista a = new NodoLista();
        a.add("ciao").add(8).add("hey");
    }

E' di fatto identico a:

class NodoLista {

    public Object info;
    public NodoLista next;


    public NodoLista() {
        info = null;
        next = null;
    }
    public NodoLista add(Object v) {
        NodoLista t;
        if (info != null) {
            t = new NodoLista(v);
            next = t;
        }
        else {
            info = v;
            t = this;
        }
        return t;
    }
    
    public static void main(String[] args) {
        NodoLista a = new NodoLista();
        a.add("ciao").add(8).add("hey");
    }

Inoltre, a dirla tutta, anche l'inizializzazione all'interno del costruttore non servirebbe. I riferimenti agli oggetti (dichiarati nei "campi di istanza") hanno di default il valore null; gli interi a 0, le stringhe, essendo oggetti, a null, i boolean a false, e quelli in virgola mobile a 0.0.

Il t = this; sta assegnando a t, che è un NodoLista, l'oggetto corrente; ovvero sta assegnando l'oggetto che ha come campi di istanza i valori di info e next dichiarati nei campi di istanza in alto.
Per comprendere il meccanismo ti consiglio di eseguire il codice e fare delle prove. Non so se mi sono spiegato bene, ma il fatto di utilizzare ad esempio this.info in quel codice equivale ad utilizzare direttamente info, poichè la variabile che utilizzi, a cui ri tiferisci, è sempre la medesima. Se ci fosse come parametro del metodo una variabile chiamata info, allora la cosa cambierebbe. Se non utilizzassi il this, come mostrato sopra, accederesti al parametro del metodo.


Secondo me ti sei complicato un pò la vita con i layout. Però il risultato l'hai ottenuto. :P
Ad ogni modo fai attenzione all'incapsulamento dei dati anche. I campi di istanza, solitamente, hanno accesso private.

 

[Fab996]

Scusami se ti rispondo tardivamente, in qualche post precedente avevo scritto che dato che estendo la classe devo fare this.metodo(); però il this hai detto che posso anche ometterlo, però per capire, dato che il this si riferisce all'oggetto corrente, in questo caso l'oggetto corrente sarebbe quello creato da super?

public Calcolatrice() { 
super("calcolatrice");
this.setSize()

Secondo me ti sei complicato un pò la vita con i layout. Però il risultato l'hai ottenuto.

Potevo realizzarlo quindi in un modo più semplice? Anche perchè ho visto che esistono degli editor che facilitano molto la gestione della GUI, inoltre non sapevo che il contentPane avesse di default il BorderLayout, se volessi modificare quest'ultimo come posso fare?

 

[DispatchCode]

Ciao,

Scusami se ti rispondo tardivamente, in qualche post precedente avevo scritto che dato che estendo la classe devo fare this.metodo(); però il this hai detto che posso anche ometterlo, però per capire, dato che il this si riferisce all'oggetto corrente, in questo caso l'oggetto corrente sarebbe quello creato da super?

public Calcolatrice() { 
super("calcolatrice");
this.setSize()

Il this si riferisce al contesto corrente, che nel caso di specie è la tua classe Calcolatrice. Quindi qualsiasi utilizzo di una variabile di quella classe, o di un suo metodo, senza il this, sortirà lo stesso risultato che avresti con il suo utilizzo.
In questo caso il this richiama il metodo setSize() della superclasse di Calcolatrice che è JFrame. Ti ricordo a tal proposito che Calcolatrice estende JFrame, quindi Calcolatrice è[/b ] un JFrame.

Spoiler

class A 
{

  A() 
  {
    System.out.println("Costruttore di A");
  }


  void metodo() 
  {
    System.out.println("A");
  }

}

class B extends A 
{

  B() 
  {
    System.out.println("Costruttore di B");
    metodo();
    this.metodo();
    super.metodo();
  }

  void metodo() 
  {
    System.out.println("B");
  }
  

}

class Main 
{
  public static void main(String[] args) 
  {
  
    B b = new B();
  
  }

}

Come dicevo sopra, le chiamate risalgono i costruttori. In questo caso io creo solo un oggetto B. L'output è il seguente:

Costruttore di A
Costruttore di B
B
B
A

Osserva le stampe dei metodi: i primi due, l'invocazione a metodo() e a this.metodo(), danno lo stesso risultato. Utilizzando invece super, chiamo il metodo della superclasse (A).
Se noti nel mio costruttore che ho definito per B non ho utilizzato il super. Come dicevo in qualche post sopra, viene inserito in fase di compilazione; ecco perchè avviene prima la chiamata alla superclasse con la conseguente stampa "Costruttore di A".
Usata invece sul nome del metodo chiamo il metodo della superclasse.

Se una classe non definisce un metodo, come il setSize() citando il tuo codice, viene richiamato quello della superclasse. Un codice come il seguente quindi è perfettamente valido:

Spoiler

class A 
{

  A() 
  {
    System.out.println("Costruttore di A");
  }


  void metodo() 
  {
    System.out.println("A");
  }
  
  void altroMetodo()
  {
    System.out.println("Altro metodo, A");
  }

}

class B extends A 
{

  B() 
  {
    System.out.println("Costruttore di B");
    metodo();
    this.metodo();
    super.metodo();
  }

  void metodo() 
  {
    System.out.println("B");
  }
  

}

class Main 
{
  public static void main(String[] args) 
  {
  
    B b = new B();
    b.altroMetodo();
  
  }

}

Output:

Costruttore di A
Costruttore di B
B
B
A
Altro metodo, A

Il modo migliore per comprendere il funzionamento è fare delle prove tu stesso. prendi quel codice che mi hai mostrato, e fai prove sia con il this.metodo() sia togliendolo (o modifica quello di esempio che ti ho mostrato qui sopra); noterai che non cambierà nulla proprio perchè fa riferimento allo stesso metodo (che è poi ciò che si evince dall'output che ho incollato).

Quando inizierai a vedere il polimorfismo ed a sfruttare i riferimenti (magari alle interfacce)... noterai la potenza di molti altri meccanismi.

Potevo realizzarlo quindi in un modo più semplice? Anche perchè ho visto che esistono degli editor che facilitano molto la gestione della GUI, inoltre non sapevo che il contentPane avesse di default il BorderLayout, se volessi modificare quest'ultimo come posso fare?

No, quel tipo di semplicità (gli IDE) non ti permetterebbe di imparare il linguaggio e la libreria che stai usando (specie perchè a quanto ho capito sei agli inizi, diciamo così). Quindi evita gli IDE agli inizi, impara senza. ;) Questo è il mio consiglio, poi, se preferisci usare gli IDE per creare la GUI, allora puoi scegliere tra alcuni: i principali sono Netbeans ed Eclipse.

Non riesco a mostrarti ora degli esempi di GUI visto l'orario, ma domani appena ho tempo cercherò di scrivere 2 righe.

 

[Fab996]

Ti ringrazio molto per gli esempi, comunque si sto all'inizio ho finito il primo anno di ingegneria informatica, magari posterò nuovamente il codice quando riuscirò a gestire gli eventi.
Grazie ancora :)