[Java] Problemi programmazione

[Fonta_88]

Ciao a tutti,

sto programmando in java (su eclipse) una calcolatrice molto semplice, presa da un tutorial che ho trovato su internet, è composta da una finestra che estende la classe JFrame e contiene oggetti JButton e un'etichetta (il display) creato da JTextField.

Il codice è di per sè corretto, in quanto non rileva errori, ma quando istanzio un oggetto di classe Finestra nel main mi dà un errore...

In particolare il messaggio di errore è:
"No enclosing instance of type GUI_1 is accessible. Must qualify the allocation with an enclosing instance of type GUI_1 (e.g. x.newA() where A is an instance of GUI_1)."

Dove GUI_1 è il nome della classe principale e del progetto (che devono essere uguali, no?)... Qualcuno sa dirmi cosa non va?

lascio qui sotto il codice...



import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class GUI_1 {


public class CalcFinestra extends JFrame{
private JTextField display;
private CalcPannello tastiera;
private double operandoCorrente = 0.0;
private char operatoreCorrente = '?';
private boolean resetDisplay = true;

public CalcFinestra(String Testo){
super(Testo);
display = new JTextField();
tastiera = new CalcPannello(this);

add(display,BorderLayout.NORTH);
add(tastiera,BorderLayout.CENTER);

display.setEditable(false);
display.setFont(new Font("SansSerif", Font.ITALIC, 22));
display.setHorizontalAlignment(JTextField.RIGHT);
display.setBackground(Color.WHITE);
}

public void inseritaCifra(char c){
if(resetDisplay=true){
display.setText("");
resetDisplay = false;
}
display.setText(display.getText()+c);
}

public void inseritoPunto(char c){
if(resetDisplay = true){
display.setText("");
resetDisplay = false;
}
display.setText(display.getText()+c);
}

public void inseritoOperatore(char c){
if (c=='='){
if(operatoreCorrente != '?'){
double operando = Double.parseDouble(display.getText()); //se è stato selez. = e l'operatore corrente non è ? allora converto il numero in display in numero con la virgola e lo salvo in operando
double risultato = calcolaRisultato(operandoCorrente, operando, operatoreCorrente);
display.setText(String.valueOf(risultato)); // scrivo a display il valore di risultato dopo averlo convertito in stringa
operatoreCorrente = '?';
resetDisplay = true;
}
} else {
if(operatoreCorrente == '?'){
operandoCorrente = Double.parseDouble(display.getText()); // vuol dire che non ho operazioni in ballo e che devo salvare il primo termine dell'operazione
} else {
double operando = Double.parseDouble(display.getText()); // vuol dire che ho un'operazione in ballo, llora salvo il termine in operando
operandoCorrente = calcolaRisultato(operandoCorrente, operando, operatoreCorrente); // ho risolto l'operazione ma non ho permuto uguale, così alvo il risultato in operatoreCorrente xk sono in attesa di 1 nuova operazione
display.setText(String.valueOf(operandoCorrente));
}
operatoreCorrente = c;
resetDisplay = true;
}
}
}




public double calcolaRisultato(double op1, double op2, char oper){
switch (oper) {
case '+' : return (op1+op2);
case '-' : return (op1-op2);
case '*' : return (op1*op2);
case '/' : return (op1/op2);
default : return 0.0;
}};




public class CalcPannello extends JPanel{
private JButton bottoni[] = {new JButton("1"), new JButton("2"), new JButton("3"), new JButton("4"), new JButton("5"), new JButton("6"), new JButton("7"), new JButton("8"), new JButton("9"), new JButton("0"), new JButton("+"), new JButton("-"), new JButton("*"), new JButton ("/"), new JButton("=")};

private CalcFinestra mainFrame;
public CalcPannello(CalcFinestra calcFin){
mainFrame = calcFin;
setLayout(new GridLayout(4,4));

}

private class BottoniListener implements ActionListener{ // ho usato implements perchè è un'interfaccia derivata, non una classe derivata
public void actionPerformed(ActionEvent ev){
JButton pressed = (JButton)ev.getSource();
char c = pressed.getText().charAt(0);
if ((c>='0') && (c<= '9')){
mainFrame.inseritaCifra(c);
}else if (c=='.'){
mainFrame.inseritoPunto();
}else {
mainFrame.inseritoOperatore(c);
}
}


}
}






public static void main(String[] args){
String s = "Calcolatrice";
CalcFinestra calcolatriceFinestra = new CalcFinestra(s);
calcolatriceFinestra.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
calcolatriceFinestra.setSize(300,300);
calcolatriceFinestra.setVisible(true);
}
}

[ndakota]

metti la classe CalcFinestra in un altro file .java.

La prossima volta metti il linguaggio interessato tra parentesi quadre [Java] prima del titolo, altrimenti il thread verrà chiuso. Il titolo è anche un pochetto generico

[clockover]

E metti il codice tra il tag CODE...

[PGI-Bis]

Il "problema" è qui:

CalcFinestra calcolatriceFinestra = new CalcFinestra(s);

Compila se scrivi:

GUI_1 gui = new GUI_1();
CalcFinestra calcolatriceFinestra = gui.new CalcFinestra(s);

La ragione è in verità piuttosto semplice: in Java quando una "cosa" non è static per poterla usare devi avere a disposizione un certo riferimento. Più precisamente l'espressione di accesso ad un membro non statico o l'espressione di istanziazione di un tipo annidato non statico deve essere qualificata da un riferimento ad un'istanza del tipo in cui il membro o tipo annidato è dichiarato.

Nel caso di:

CalcFinestra calcolatriceFinestra = new CalcFinestra(s);

si tratta di un'istanziazione (new CalcFinestra). Se guardiamo il codice vediamo che CalcFinestra è dichiarato nel corpo (cioè è contenuto nella coppia di parentesi che si apre dopo la dichiarazione di GUI_1 e si chiude alla fine del sorgente di GUI_1) della classe GUI_1.

public class GUI_1 {
    //qui siamo nel corpo della classe GUI_1

    public class CalcFinestra extends JFrame {

E' quindi un tipo annidato. Non è "static", cioè non è dichiarato:

public class GUI_1 {

    public static class CalcFinestra extends JFrame {

Il fatto che non sia static (che, en passant, qualifica CalcFinestra come tipo annidato interno) ci dice che per poter creare un'istanza di CalcFinestra dobbiamo avere per le mani un'istanza di ciò all'interno di cui CalcFinestra è dichiarato. CalcFinestra è dichiarato all'interno di GUI_1, da cui:

GUI_1 gui = new GUI_1();
CalcFinestra cf = gui.new CalcFinestra("pippo");

Nota come una cosa simile a questa avvenga in CalcFinestra, alla riga 24 del costruttore:

tastiera = new CalcPannello(this);

Anche quel "new CalcPanello" è istanziazione di una classe annidata interna e anche in quel caso l'istanziazione è qualificata da un riferimento a GUI_1. Quel riferimento è automaticamente inserito dal compilatore nel caso in cui manchi e, se reso esplicito, risulterebbe uguale a:

tastiera = GUI_1.this.new CalcPannello(this);

Non è necessario che il nome di un progetto coincida con il nome di una qualche classe appartenente a quel progetto (il progetto in effetti non è parte delle specifiche del linguaggio di programmazione Java o della piattaforma Java SE ma è una necessità organizzative dell'editor che usi).

Si può fare anche senza tipi interni. Ci sono delle differenze meccaniche e semantiche tra due tipi separati e due tipi di cui uno sia interno all'altro. Dal primo punto di vista, un tipo interno ha accesso ai membri privati del tipo che lo racchiude. Dal punto di vista del significato, il tuo codice dice: "in tanto ha senso che esistano dei tipi CalcFinestra e CalcPannello in quanto essi siano associati ad un determinato oggetto GUI_1". Esattamente come faremmo per un testo scritto in linguaggio naturale, dobbiamo poi decidere se questa frase abbia o non abbia un senso compiuto nel contesto di ciò che il programma rappresenta. Se ce l'ha, allora la dichiarazione di CalcFinestra e CalcPannello come tipi interni di GUI_1 è giustificabile, altrimenti no.

[Fonta_88]

Grazie per l'aiuto, ora la calcolatrice parte!!!
E scusate se non ho indicato il linguaggio di programmazione tra parentesi, non avevo capito che fosse obbligatorio...

Buona serata...