Una mano per capire alcune righe di un programma

[crissstian96]

premetto che sono un novellino, sto iniziando a sviluppare con interfaccia grafica solo da poco tempo, e sono decisamente convinto di voler capire il FlowLayout, con questa occasione vado nella documentazione ufficiale, e per acquisire più familiarità col codice decido di scaricare la demo. Quello che vi chiedo in questo momento, è quello di spiegarmi gentilmente alcune righe di cui non riesco a comprendere l'utilizzo, riporto qua sotto il codice per comodità:

package layout;

/*
*
* FlowLayoutDemo.java
*
*/

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.util.*;

public class FlowLayoutDemo extends JFrame{
    JRadioButton RtoLbutton;
    JRadioButton LtoRbutton;
    FlowLayout experimentLayout = new FlowLayout();
    final String RtoL = "Right to left";
    final String LtoR = "Left to right";
    JButton applyButton = new JButton("Apply component orientation");
    
    public FlowLayoutDemo(String name) {
        super(name);   ///
    }
    
    public void addComponentsToPane(final Container pane) {
        final JPanel compsToExperiment = new JPanel();
        compsToExperiment.setLayout(experimentLayout);
        experimentLayout.setAlignment(FlowLayout.TRAILING);
        JPanel controls = new JPanel();
        controls.setLayout(new FlowLayout());
        
        LtoRbutton = new JRadioButton(LtoR);
        LtoRbutton.setActionCommand(LtoR);
        LtoRbutton.setSelected(true);
        RtoLbutton = new JRadioButton(RtoL);
        RtoLbutton.setActionCommand(RtoL);
        
        //Add buttons to the experiment layout
        compsToExperiment.add(new JButton("Button 1"));
        compsToExperiment.add(new JButton("Button 2"));
        compsToExperiment.add(new JButton("Button 3"));
        compsToExperiment.add(new JButton("Long-Named Button 4"));
        compsToExperiment.add(new JButton("5"));
        //Left to right component orientation is selected by default
        compsToExperiment.setComponentOrientation(
                ComponentOrientation.LEFT_TO_RIGHT);
        
        //Add controls to set up the component orientation in the experiment layout
        final ButtonGroup group = new ButtonGroup();
        group.add(LtoRbutton);
        group.add(RtoLbutton);
        controls.add(LtoRbutton);
        controls.add(RtoLbutton);
        controls.add(applyButton);
        
        //Process the Apply component orientation button press
        applyButton.addActionListener(new ActionListener(){
            public void actionPerformed(ActionEvent e){
                String command = group.getSelection().getActionCommand();
                //Check the selection
                if (command.equals("Left to right")) {
                    compsToExperiment.setComponentOrientation(
                            ComponentOrientation.LEFT_TO_RIGHT);
                } else {
                    compsToExperiment.setComponentOrientation(
                            ComponentOrientation.RIGHT_TO_LEFT);
                }
                //update the experiment layout
                compsToExperiment.validate(); ///
                compsToExperiment.repaint(); ///
            }
        });
        pane.add(compsToExperiment, BorderLayout.CENTER);
        pane.add(controls, BorderLayout.SOUTH); ;
    }
    
    /**
     * Create the GUI and show it.  For thread safety,
     * this method should be invoked from the
     * event dispatch thread.
     */
    private static void createAndShowGUI() {
        //Create and set up the window.
        FlowLayoutDemo frame = new FlowLayoutDemo("FlowLayoutDemo");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        //Set up the content pane.
        frame.addComponentsToPane(frame.getContentPane());
        //Display the window.
        frame.pack();   ///
        frame.setVisible(true);
    }
    
    public static void main(String[] args) {
        /* Use an appropriate Look and Feel */
        try {
            //UIManager.setLookAndFeel("com.sun.java.swing.plaf.windows.WindowsLookAndFeel");
            UIManager.setLookAndFeel("javax.swing.plaf.metal.MetalLookAndFeel");
        } catch (UnsupportedLookAndFeelException ex) {
            ex.printStackTrace();
        } catch (IllegalAccessException ex) {
            ex.printStackTrace();
        } catch (InstantiationException ex) {
            ex.printStackTrace();
        } catch (ClassNotFoundException ex) {
            ex.printStackTrace();
        }
        /* Turn off metal's use of bold fonts */
        UIManager.put("swing.boldMetal", Boolean.FALSE); ///
        //Schedule a job for the event dispatchi thread:
        //creating and showing this application's GUI.
        javax.swing.SwingUtilities.invokeLater(new Runnable() { ///
            public void run() {
                createAndShowGUI();
            }
        });
    }
}

ho contrassegnato con 3 slash (///) tutto ciò che non ho capito. Vorrei anche capire come mai tratta come frame l'oggetto "FlowLayoutFrame" anzichè creare un oggetto JFrame.
Spero di non chiedere troppo. Grazie.

[valia]

Originariamente inviato da crissstian96
premetto che sono un novellino, sto iniziando a sviluppare con interfaccia grafica solo da poco tempo, e sono decisamente convinto di voler capire il FlowLayout, con questa occasione vado nella documentazione ufficiale, e per acquisire più familiarità col codice decido di scaricare la demo. Quello che vi chiedo in questo momento, è quello di spiegarmi gentilmente alcune righe di cui non riesco a comprendere l'utilizzo, riporto qua sotto il codice per comodità:

......


Spero di non chiedere troppo. Grazie

quanto ne sai di OOP? di java? di programmazione in generale? La grafica è l'ultima cosa che si guarda quando si vuole imparare a programmare, tieni conto che tutti i dubbi che tu hai sarebbero chiariti da un serio studio prima della OOP e poi delle librerie che vuoi usare.

[neroux]

Alcune righe? 118

Devo porre la stessa domanda come valia. Non c'è niente di eccezionale in questo codice. Sta chiamando alcune metodi, il constructor della classe base e usa una classe anonima.

[crissstian96]

quanto ne sai di OOP? di java? di programmazione in generale? La grafica è l'ultima cosa che si guarda quando si vuole imparare a programmare, tieni conto che tutti i dubbi che tu hai sarebbero chiariti da un serio studio prima della OOP e poi delle librerie che vuoi usare.

Ho letto un ottimo libro su Java e credo che di aver capito tutto sull'OOP, però il libro parla (appunto) solo delle basi, e arriva fino all'interfaccia grafica, dove spiega tutti i layout. Navigando tra la documentazione ufficiale ho guardato un po' tutti i layout, e poiché no ne ho capito molto della spiegazione, ho scaricato la demo. Guardando la demo, mi sono accorto che ci sono molte cose che non ho capito, anche se ho studiato (ad esempio il metodo super so a che cosa serve, ma non riesco a capire che funzione abbia all'interno del programma), e dunque ho chiesto aiuto a voi! Forse il mio errore più grande è stato quello di fare questo salto da colui che no ne sa una ceppa sul FlowLayout a quello che vuole capire il programma, ma vi chiedo per favore se potreste aiutarmi altrimenti mi rimarrà il dubbio a vita e non potrò portarmi avanti su questo argomento però bhè, se mi dite che sto chiedendo troppo cambia strada.

@neroux non sono 118, le righe che ho contrassegnato con gli slash sono circa 5 xD

[Patrick Jane]

Originariamente inviato da crissstian96
Ho letto un ottimo libro su Java e credo che di aver capito tutto sull'OOP

In bocca al lupo.
Comunque quelle righe mi fanno pensare che non ti sia molto chiaro qualcosa, o che ti sei perso qualcosa.

super(name);   ///

Passa il parametro al costruttore della superclasse.

                //update the experiment layout
                compsToExperiment.validate(); ///
                compsToExperiment.repaint(); ///

Come dice il commento stesso serve per rivalidare e disegnare nuovamente sul pannello (altrimenti non vedi le modifiche).

frame.pack();   ///

La finestra avrà la dimensione minima richiesta dai componenti.

        UIManager.put("swing.boldMetal", Boolean.FALSE); ///

http://docs.oracle.com/javase/7/docs...lang.Object%29

        javax.swing.SwingUtilities.invokeLater(new Runnable() { ///

Avvia l'applicazione in un nuovo thread,fuori dal contesto dell'EDT (e restituendo subito il controllo).
L'approccio è utilizzato quando la GUI deve essere aggiornata.

[valia]

Originariamente inviato da crissstian96
Ho letto un ottimo libro su Java e credo che di aver capito tutto sull'OOP, però il libro parla (appunto) solo delle basi, e arriva fino all'interfaccia grafica, dove spiega tutti i layout.

ti posso dire che non hai capito molto di OOP, quelle domande non c'entrano niente con la grafica, ma qui si tratta di capire come funziona l'ereditarietà e come sono organizzate le classi.
L'uso della libreria swing presuppone che tu conosca bene le basi, che vanno dalla definizione della classe, comprensione delle gerarchie (e di cosa significa avere delle parole chiave o determinate strutture), comprensione che va oltre "l'aver letto un libro". Tecnicamente la grafica è l'ultima cosa che uno sviluppatore può imparare, perchè in realtà puoi fare tutto senza avere una GUI.

Originariamente inviato da crissstian96
Navigando tra la documentazione ufficiale ho guardato un po' tutti i layout, e poiché no ne ho capito molto della spiegazione, ho scaricato la demo. Guardando la demo, mi sono accorto che ci sono molte cose che non ho capito, anche se ho studiato (ad esempio il metodo super so a che cosa serve, ma non riesco a capire che funzione abbia all'interno del programma), e dunque ho chiesto aiuto a voi! Forse il mio errore più grande è stato quello di fare questo salto da colui che no ne sa una ceppa sul FlowLayout a quello che vuole capire il programma, ma vi chiedo per favore se potreste aiutarmi altrimenti mi rimarrà il dubbio a vita e non potrò portarmi avanti su questo argomento però bhè, se mi dite che sto chiedendo troppo cambia strada.

come ti ripeto, se hai ben chiare le basi (e va oltre alla semplice lettura di un testo), le spiegazioni della documentazione ufficiale sono molto chiare e personalmente ti assicuro che spesso rimando alla documentazione ufficiale (più che altro perché evito di copiare e perdermi qualcosa).
Se non sai cosa è super e perché si usa, non ti rendi conto che un oggetto necessita di inizializzazione, nel caso di gerarchie, chiamare super implica l'inizializzazione di tutto ciò che sta prima della definizione della classe, torna tra le basi della OOP.

Originariamente inviato da crissstian96
@neroux non sono 118, le righe che ho contrassegnato con gli slash sono circa 5 xD

ha detto giusto, perché le altre non è che facciano molto.

Un consiglio, lascia perdere la grafica e comprendi bene le basi. comprendere significa saper applicare e saper leggere il codice (anche quello delle demo)