In questo breve articolo voglio descrivere il processo di creazione di un piccolo programma che supporta la GUI nella lingua Giava. Si presume che il lettore abbia familiarità con le basi della lingua. Giava.

E quindi, di quali strumenti abbiamo bisogno:

• Java Virtual Machine (OpenJDK o Oracle JDK)
• Intellij IDEA (o un altro IDE per Java)

Dopo aver installato il software necessario, apri IntelliJ IDEA e crea un nuovo progetto: File -> Nuovo progetto...

Ho chiamato il progetto guiBase. Come puoi vedere nello screenshot, la cartella src non contiene nulla, quindi creiamo al suo interno la nostra classe principale contenente la funzione principale.

Classe pubblica Main ( public static void main(String args) ( System.out.println("Hello, Govzalla!"); ) )

Vedi i contenuti della classe principale sopra. Ora possiamo creare un progetto ( costruire progetto ) ed eseguirlo ( Correre ). Giù nel terminale del tuo IDE vedrai un messaggio Ciao, Govzalla!. Ma come hai capito tu stesso, non supporta la GUI.

In questa fase, abbiamo già un programma funzionante, ma senza il supporto della GUI. E ora nella stessa cartella src creare Modulo GUI: Nuovo -> Modulo GUI

Aprire il modulo GUI creato, fare clic su jPannello e imposta il suo identificatore nel campo nome del campo, Ho chiesto pannello.

Quindi trascina e rilascia sul modulo sul lato destro JTextField, JPasswordField e jPulsante:

Resta da aggiungere il codice e collegare ad esso il nostro modulo. Quando abbiamo aggiunto il modulo finestra principale, la classe è stata creata automaticamente finestra principale, questa classe è la classe del modulo generato, cioè questa classe servirà tutti gli eventi della forma data.

Sebbene la nostra classe window contenga gli elementi necessari, anche ora non ha nulla a che fare con la GUI, quindi estendiamola con jFrame ed ereditare tutte le funzionalità di base e necessarie della GUI .

A questo momento abbiamo la forma finestra principale e classe finestra principale esteso con jFrame. Ora dobbiamo definire tutti gli elementi della GUI aggiunti come contenuto di classe finestra principale this.getContentPane().add(pannello); Successivamente, il contenuto del file MainWindow.java verrà modificato come segue:

Importa javax.swing.*; public class MainWindow estende JFrame ( private JTextField textField1; private JPasswordField passwordField1; private JButton button1; private JPanel panel; public MainWindow() ( this.getContentPane().add(panel); ) )

Se provi a eseguire il codice, vedrai di nuovo lo stesso messaggio "Hello, Govzalla!". Il problema è che abbiamo creato una classe e il relativo modulo, ma non abbiamo creato un'istanza di questa classe.

È ora di cambiare il file Main.java e aggiungere il codice per creare la nostra GUI lì:

Importa java.awt.*; public class Main ( public static void main(String args) ( // Crea un'istanza della classe MainWindow MainWindow mainWindow = new MainWindow(); // Comprimi tutti gli elementi dal nostro form mainWindow.pack(); // Ridimensiona la finestra mainWindow.setSize( new Dimension(200, 200)); // Visualizza la finestra creata mainWindow. setVisible(true); ) )

Esecuzione del codice

Cliccando sul Pulsante noterai che il programma non reagisce in alcun modo. Il fatto è che non abbiamo ancora aggiunto l'ascoltatore ( Ascoltatore) per eventi ( Eventi) del Pulsante.

ascoltatore di eventi ( ascoltatore di eventi) jPulsante deve essere un'implementazione dell'adattatore Ascoltatore d'azione, quindi aggiungi il codice seguente al corpo della classe finestra principale:

La classe privata MyButtonListener implementa ActionListener ( @Override public void actionPerformed(ActionEvent actionEvent) ( ) )

Metodo azione eseguita() gestirà tutti gli eventi del pulsante button1, ma prima devi ancora dire a button1 quale classe gestirà, quindi aggiungi il seguente codice al costruttore di classi MainWINdow: this.button1.addActionListener(new MyButtonListener()); In modo che il nostro gestore non sia privo di significato, aggiungi il codice seguente al metodo azione eseguita():

@Override public void actionPerformed(ActionEvent actionEvent) ( if (textField1.getText().equals(passwordField1.getText())) ( JOptionPane.showMessageDialog(null, "Success"); ) else ( JOptionPane.showMessageDialog(null, "Failure "); ) )

Ora il programma risponderà correttamente agli eventi, non a tutti gli eventi, ovviamente. Ad esempio, se provi a disabilitare il programma facendo clic sulla croce, la finestra scomparirà, ma il programma funzionerà comunque, perché. gestore eventi della finestra principale non aggiunto.

Davydov Anton Valerievich
Studente della TSU, Russia, Togliatti
Consulente scientifico: Erofeeva E.A.

L'interfaccia utente in Java ha attraversato un percorso di formazione e sviluppo molto spinoso. Il suo per molto tempo accusato di essere avido di risorse di sistema, lavoro lento e funzionalità limitate. L'avvento di .NET con componenti grafici più veloci ha ulteriormente scosso la posizione di Java. Ma tale concorrenza ha solo spinto gli sviluppatori Java a sviluppare e migliorare le librerie grafiche. E in questo articolo vedremo cosa ne è venuto fuori.

Kit di strumenti per finestre astratte

L'Abstract Window Toolkit (abbreviato in AWT) è stato rilasciato per la prima volta nel 1995 da Sun Microsystems. È stato il primo tentativo di creare una GUI per Java. AWT fungeva da livello che richiamava metodi dalle librerie scritte in C. E questi metodi, a loro volta, utilizzavano componenti grafici sistema operativo. Da un lato, un programma costruito in questo modo sembrava simile nell'aspetto a tutti gli altri programmi sul sistema operativo utilizzato, ma dall'altro, lo stesso programma può apparire completamente diverso su sistemi operativi diversi, il che complica lo sviluppo. Inoltre, per motivi di multipiattaforma, è stato necessario unificare le interfacce di chiamata dei componenti, il che ha portato a funzionalità alquanto troncate. Anche l'insieme dei componenti è piuttosto modesto. Ad esempio, non ci sono tabelle e non è possibile inserire icone nei pulsanti. AWT tenta di rilasciare automaticamente le risorse utilizzate. Ciò influisce sulle prestazioni e complica l'architettura. AWT è facile da imparare, ma scrivere qualcosa di complesso è difficile. Ora AWT viene utilizzato principalmente per le applet. Oracle sta attualmente incoraggiando gli sviluppatori a passare a Swing poiché è più sicuro.

Fig.1 - Un programma di esempio scritto utilizzando AWT in ambiente Windows

Dopo AWT, nel 1998, Sun pubblicò Swing. È scritto interamente in Java e utilizza il 2D per il rendering. Swing ha una varietà di componenti molto più ampia rispetto a AWT. I componenti stessi sono diventati molto più facili da creare ereditando da quelli esistenti. È stata inoltre introdotta la possibilità di utilizzare stili e skin diversi. Tuttavia, la velocità di lavoro prime versioni Lo swing era piuttosto basso e gli errori nella scrittura di un programma potevano persino causare il blocco del sistema operativo.

Tuttavia, a causa della facilità di apprendimento e della disponibilità un largo numero documentazione, Swing è diventata la GUI più popolare in Java. Sulla base di esso, sono apparse molte estensioni, come SwingX e JGoodies, che rendono ancora più semplice la creazione di applicazioni visivamente complesse. Tutti i moderni ambienti di programmazione Java includono editore grafico Oscillazione. Anche se ora esistono framework più moderni, Swing rimane il più popolare.

Fig. 2 - Esempio di programma scritto con Swing

Kit di strumenti widget standard

SWT è stato rilasciato da IBM in un momento in cui Swing era ancora lento e principalmente per promuovere l'ambiente di programmazione Eclipse. Come AWT, SWT utilizza componenti del sistema operativo, ma vengono utilizzate diverse interfacce di interoperabilità per piattaforme diverse. Pertanto, è necessario fornire una libreria JAR separata per ciascun sistema operativo. Ciò consente di utilizzare in modo più completo le funzioni corrispondenti ai diversi sistemi operativi. E i componenti mancanti sono stati implementati utilizzando il 2D. Tuttavia, SWT si è rivelato più difficile da padroneggiare rispetto a Swing. Inoltre, il programmatore stesso deve attuare il rilascio di risorse da parte dell'applicazione.

Fig.3 - Esempio di programma scritto con Swing

JavaFX è stato rilasciato nel 2008 da Oracle. È posizionato come piattaforma per la creazione di una ricca applicazione Internet. Per il rendering viene utilizzata una pipeline grafica, che velocizza notevolmente l'applicazione. C'è un ampio set di componenti integrati. Ci sono anche componenti separati per tracciare i grafici. Supporto implementato per contenuti multimediali, animazioni e persino multi-touch. L'aspetto dei componenti è configurato utilizzando gli stili CSS. Inoltre, il set di utility JavaFX include la possibilità di realizzare un installer nativo per le piattaforme più diffuse: exe o msi per Windows, deb o rpm per Linux, dmg per Mac. Il sito Web di Oracle contiene una documentazione dettagliata e un gran numero di esempi già pronti.

Pertanto, dopo aver descritto le caratteristiche principali e gli svantaggi delle interfacce utente grafiche di cui sopra, possiamo decidere per quali attività sono più adatte. Abstract Window Toolkit è più adatto per la creazione di applet. Un principiante può consigliare Swing in considerazione del fatto che puoi trovare un'enorme quantità di documentazione su Internet, anche in russo. JavaFX è ottimo per creare applicazioni Internet avanzate.

Elenco delle fonti utilizzate

Ryzhenko A. V. Programmazione orientata agli oggetti: complesso educativo e metodologico per la disciplina per la specialità 010501 - "Matematica e informatica applicata". – 2007.

Khabibullin I. Sh. Java 7 (4a ed.). - BHV-Pietroburgo, 2012.

Clarke J., Connors J., Bruno EJ JavaFX: sviluppo di applicazioni Internet avanzate. – Educazione Pearson, 2009.

Northover S., Wilson M. Swt: il toolkit widget standard, volume 1. - Addison Wesley Professional, 2004.

L'interfaccia grafica in Java ha attraversato un percorso di sviluppo e formazione molto spinoso. Per molto tempo è stato accusato di lavoro lento, avidità per le risorse di sistema e funzionalità limitate.

Java AWT

Il primo tentativo di Sun di creare una GUI per Java è stata la libreria A.W.T.(Abstract Window Toolkit) - un toolkit per lavorare con vari ambienti di finestre. Sun ha creato un livello Java che richiama i metodi dalle librerie scritte in C. I metodi della libreria AWT creano e utilizzano i componenti grafici dell'ambiente operativo. Da un lato, questo è positivo, poiché un programma Java è simile ad altri programmi all'interno dello stesso sistema operativo. Ma quando lo si esegue su una piattaforma diversa, potrebbero esserci differenze nelle dimensioni dei componenti e dei caratteri che andranno a male aspetto esteriore programmi.

Per garantire multipiattaforma A.W.T. le interfacce di chiamata dei componenti sono state unificate, risultando in una funzionalità leggermente ridotta. E il set di componenti si è rivelato piuttosto piccolo. Ad esempio, non ci sono tabelle in AWT e le icone non sono supportate nei pulsanti. Tuttavia, il pacchetto java.awt incluso con Java sin dalla prima versione e può essere utilizzato per creare GUI.

Quindi i componenti A.W.T. non fare nessun "lavoro". È solo un "involucro Java" per i controlli del sistema operativo su cui girano. Tutte le richieste a questi componenti vengono reindirizzate al sistema operativo, che fa tutto il lavoro.

Risorse utilizzate A.W.T. tenta di rilasciare automaticamente. Questo complica leggermente l'architettura e influisce sulle prestazioni. Scrivere qualcosa di serio usando AWT sarà alquanto difficile. Ora è usato solo per le applet.

Concetti di base di SWING

Dopo A.W.T. Sun ha sviluppato una libreria di componenti grafici Oscillazione, scritto interamente in Java. Il 2D viene utilizzato per il rendering, il che porta con sé numerosi vantaggi contemporaneamente. Kit componenti standard supera significativamente AWT in termini di varietà e funzionalità. Swing semplifica la creazione di nuovi componenti ereditando quelli esistenti e supporta una varietà di stili e skin.

Creatori della nuova libreria dell'interfaccia utente Oscillazione non hanno "reinventato la ruota" e hanno scelto AWT come base per la loro libreria. Naturalmente, non stavamo parlando dell'uso di componenti AWT dei pesi massimi specifici (rappresentati dalle classi Button, Label e simili). Solo i componenti leggeri hanno fornito il grado richiesto di flessibilità e controllabilità. Il diagramma di ereditarietà mostra la relazione tra AWT e Swing.

La differenza più importante Oscillazione da AWT è che i componenti Swing non sono affatto collegati al sistema operativo e sono quindi molto più stabili e veloci. Tali componenti sono chiamati leggeri in Java e la comprensione dei principi di base di come funzionano aiuterà molto a spiegare come funziona Swing.

Contenitori oscillanti di livello superiore

Per creare un'interfaccia grafica per un'applicazione, è necessario utilizzare componenti speciali della libreria Swing, chiamati contenitori. livello superiore(contenitori di livello superiore). Sono finestre del sistema operativo che ospitano i componenti dell'interfaccia utente. I contenitori di primo livello includono le finestre JFrame e JWindow, la finestra di dialogo JDialog e l'applet JApplet (che non è una finestra, ma ha anche lo scopo di visualizzare un'interfaccia nel browser che esegue questa applet). I container Swing di livello superiore sono componenti pesanti e rappresentano un'eccezione alla regola generale. Tutti gli altri componenti Swing sono leggeri.

Semplice Oscillazione esempio di interfaccia della finestra jFrame.

Importa java.awt.Dimension; importare javax.swing.JFrame; importare javax.swing.JLabel; public class JFrameTest ( public static void createGUI() ( JFrame frame = new JFrame("Test frame"); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); JLabel label = new JLabel("Test label"); frame.getContentPane(). add(label); frame.setPreferredSize(new Dimension(200, 100)); frame.pack(); frame.setVisible(true); ) public static void main(String args) ( JFrame.setDefaultLookAndFeelDecorated(true); javax. swing.SwingUtilities.invokeLater(new Runnable() ( public void run() ( createGUI()(); ) )); ) )

Costruttore JFrame() senza parametri crea una finestra vuota. Costruttore JFrame(titolo stringa) crea una finestra vuota con il titolo del titolo. Creare il programma più semplice con una finestra vuota, devono essere utilizzati i seguenti metodi:

• setSize(int width, int height) - definendo la dimensione della finestra;
• setDefaultCloseOperation(int operation) - definizione dell'azione alla fine del programma;
• setVisible(booleano visibile) - rende visibile la finestra.

Se non si definisce la dimensione della finestra, avrà un'altezza zero indipendentemente da ciò che contiene. Le dimensioni della finestra comprendono non solo l'area "di lavoro", ma anche i bordi e la barra del titolo.

Il metodo setDefaultCloseOperation definisce l'azione da intraprendere quando "si esce dal programma". Per fare ciò, passa la costante EXIT_ON_CLOSE, descritta nella classe JFrame, come parametro dell'operazione.

Per impostazione predefinita, la finestra viene creata invisibile. Per visualizzare la finestra sullo schermo, viene chiamato il metodo setVisible con il parametro true. Se lo chiami con il parametro false, la finestra diventerà invisibile.

GUI java swing esempio di creazione di finestre jFrame mostrato nella figura seguente.

Per collegare la libreria Oscillazione l'applicazione deve importare la libreria javax.swing.

Ogni volta che viene creato un contenitore di primo livello, che si tratti di una normale finestra, finestra di dialogo o applet, il costruttore del contenitore crea Pannello radice di JRootPane. I contenitori Swing di primo livello assicurano che altri componenti non possano "scorrere per indicizzazione" al di fuori di JRootPane.

Radice pallida JRootPane aggiunge una proprietà "depth" ai contenitori, fornendo la possibilità non solo di posizionare i componenti uno sopra l'altro, ma anche, se necessario, di scambiarli, aumentare o diminuire la profondità dei componenti. Questa funzione è necessaria quando si crea un'applicazione multi-documento. Oscillazione, le cui finestre rappresentano componenti leggeri impilati l'uno sull'altro, nonché menu a discesa (contesto) e descrizioni comandi.

La figura seguente mostra chiaramente la struttura del pannello principale JRootPane.

Pannello principale JRootPaneè un contenitore che eredita dalla classe Swing JComponent di base. In questo contenitore, uno speciale layout manager, implementato nella classe interna RootPaneLayout, è responsabile del layout dei componenti. Questo gestore del layout è responsabile di garantire che tutte le parti componenti del pannello principale siano posizionate come dovrebbero: il pannello a strati occupa l'intero spazio della finestra; il suo FRAME_CONTENT_LAYER contiene la barra dei menu e il pannello dei contenuti, e soprattutto c'è un pannello trasparente.

Tutti i componenti del pannello principale JRootPane possono essere ottenuti o modificati. Ha una serie di metodi get/set per questo. Programmaticamente JRootPane può essere ottenuto usando il metodo getRootPane().

Oltre ai contenitori di primo livello, il pannello principale viene utilizzato nelle finestre interne di JInternalFrame create in applicazioni multi-documento e posizionate su JDesktopPane "desktop". Ciò consente di dimenticare che queste finestre sono normali componenti leggeri e di lavorare con esse come se fossero dei veri e propri contenitori di primo livello.

Pannello a strati JLayeredPane

Alla base del pannello principale (contenitore) si trova il cosiddetto pannello a strati JLayeredPane occupa tutto spazio disponibile contenitore. È in questo pannello che si trovano tutte le altre parti del pannello principale, inclusi tutti i componenti dell'interfaccia utente.

JLayeredPane utilizzato per aggiungere una proprietà di profondità al contenitore. Cioè, il pannello multistrato consente di organizzare una terza dimensione nel contenitore, lungo la quale si trovano i livelli (strati) del componente. In un normale contenitore, la posizione di un componente è determinata da un rettangolo che mostra la quantità di contenitore occupata dal componente. Quando si aggiunge un componente a un pannello multistrato, è necessario specificare non solo il rettangolo occupato dal componente, ma anche il livello in cui verrà posizionato. Uno strato in un pannello a strati è definito da un numero intero. Maggiore è il numero che definisce il livello, più alto è il livello.

Il primo componente aggiunto al contenitore è superiore ai componenti aggiunti in seguito. Molto spesso, lo sviluppatore non si occupa delle posizioni dei componenti. Quando si aggiungono componenti, la loro posizione cambia automaticamente. Tuttavia, il pannello a strati consente di modificare la posizione dei componenti in modo dinamico, dopo che sono stati aggiunti al contenitore.

Le funzionalità del pannello a più livelli sono ampiamente utilizzate da alcuni componenti Oscillazione. Sono particolarmente importanti per applicazioni multi-documento, descrizioni comandi e menu. Multidocumento Oscillazione le applicazioni utilizzano un contenitore speciale JDesktopPane("desktop") ereditato da JLayeredPane A che contiene finestre interne a battente. Le funzioni più importanti di un'applicazione multi-documento - posizionare la finestra "attiva" sopra le altre, ridurre a icona le finestre, trascinarle - sono fornite dai meccanismi del pannello a strati. Il vantaggio principale dell'utilizzo di un pannello a più livelli per descrizioni comandi e menu è la loro velocità. Invece di creare una nuova finestra pesante per ogni descrizione comando o menu, situata sopra il componente in cui è stata richiesta la descrizione comando o il menu, Oscillazione crea un componente veloce e leggero. Questo componente viene posizionato in uno strato sufficientemente alto del pannello a strati sopra nella pila di tutti gli altri componenti e viene utilizzato per visualizzare una descrizione comando o un menu.

Il pannello multistrato consente di organizzare un numero illimitato di strati. Struttura JLayeredPane include diversi livelli standard utilizzati da tutti i componenti Swing, che consente di fornire lavoro corretto tutti i meccanismi del pannello multistrato. I livelli standard di JLayeredPane sono mostrati nella figura seguente.

Il livello Default viene utilizzato per ospitare tutto componenti convenzionali, che vengono aggiunti al contenitore. Questo livello contiene le finestre interne delle applicazioni multi-documento.

Il livello della tavolozza è progettato per ospitare finestre con una serie di strumenti, che di solito si sovrappongono al resto dell'interfaccia. Il pannello JDesktopPane ti consente di creare tali finestre, che le posizionano su questo livello.

Il livello modale doveva ospitare finestre di dialogo modali leggere. Tuttavia, tali finestre di dialogo non sono ancora implementate, quindi questo livello non è attualmente utilizzato in Swing.

Il livello più comunemente utilizzato per i menu a comparsa e le descrizioni comandi.

Lo strato più in alto. Destinato alle operazioni di trascinamento della selezione ( trascinare e rilasciare drop), che dovrebbe essere chiaramente visibile nell'interfaccia del programma.

Un piccolo esempio di JLayeredPane con un pannello a strati mostra come aggiungere componenti a livelli diversi e come i livelli si impilano uno sopra l'altro:

Importa javax.swing.*; importa java.awt.*; // classe per disegnare due tipi di figure con la classe testo Figure estende JComponent ( private static final long serialVersionUID = 1L; private Colore colore; tipo int privato; testo stringa privato; // parametri: colore e tipo di figura Figure(Color color, int type, String text) ( this.color = color; this.type = type; this.text = text; setOpaque(false); ) public void paintComponent(Graphics g ) ( // disegna la forma g.setColor(color); switch (type) ( case 0: g.fillOval(0, 0, 90, 90); break; case 1: g.fillRect(0, 0, 130, 80 ); break; ) g.setColor(Color.yellow); g.drawString(text, 10, 35); ) ) public class JLayeredPaneTest estende JFrame ( private static final long serialVersionUID = 1L; public JLayeredPaneTest() ( // create a window super("Example LayeredTest"); // Esci quando la finestra è chiusa setDefaultCloseOperation(EXIT_ON_CLOSE); // Definisci un pannello JLayeredPane a strati lp = getLayeredPane(); // Crea tre forme Figure figure1 = new Figure(Color.red , 0, "Figura popup"); Figure figure2 = new Figure(Color.blue, 0, "Figure 1"); Figure figure3 = new Figure(Color.cyan, 1, "Figure 2"); // individua le forme nella finestra figure1.setBounds (10, 40, 12 0,120); figure2.setBounds(60, 120, 160, 180); figure3.setBounds(90, 55, 250, 180); // aggiunta di forme a livelli diversi lp.add(figure1, JLayeredPane.POPUP_LAYER); lp.add(figura2, JLayeredPane.PALETTE_LAYER); lp.add(figura3, JLayeredPane.PALETTE_LAYER); // cambia la posizione di una delle figure lp.setPosition(figure3, 0); // determinare la dimensione e aprire la finestra setSize(280, 250); setVisible(true); ) public static void main(String args) ( JFrame.setDefaultLookAndFeelDecorated(true); new JLayeredPaneTest(); ) )

L'esempio crea una piccola finestra jFrame e più componenti Figure vengono aggiunti al pannello a strati. Per ottenere un pannello a più livelli in qualsiasi contenitore Swing di livello superiore, chiama semplicemente il metodo getLayeredPane().

La classe Figure helper eredita le proprietà della classe base JComponent e consente di disegnare due tipi di forme (cerchi e rettangoli) con colori diversi. I parametri per disegnare le forme sono impostati nel costruttore di classi.

Quando si definisce un'interfaccia, vengono create tre forme di colori diversi (due cerchi e un rettangolo). Il cerchio viene posizionato nel livello POPUP_LAYER e i rettangoli nel livello PALETTE_LAYER. Quando si posizionano i componenti, vengono specificate le loro coordinate assolute dello schermo, poiché i soliti gestori di posizione non funzionano in un pannello a strati.

Alla fine, la posizione di uno dei rettangoli viene modificata in modo che sia il primo nel livello, sebbene originariamente fosse stato aggiunto il secondo. Quando esegui l'applicazione, vedrai che il pannello a strati funziona e dispone ordinatamente i componenti in base ai loro livelli e posizioni.

A applicazioni comuni il pannello multistrato viene utilizzato raramente direttamente, in essi svolge le sue funzioni in modo impercettibile. Tuttavia, a volte aiuta a creare effetti sorprendenti e interfacce insolite, ad esempio, consentendoti di posizionare animazioni o video sopra componenti ordinari senza richiedere sforzi e trucchi sovrumani da parte dello sviluppatore.

Riquadro contenuto

Il ContentPane è la parte successiva del riquadro principale e viene utilizzato per ospitare i componenti dell'interfaccia utente del programma. Riquadro contenuto occupa la maggior parte dello spazio del pannello a strati (tranne lo spazio occupato dalla barra dei menu). Per evitare che il pannello del contenuto copra i componenti aggiunti successivamente alla finestra, il pannello a strati lo posiziona su uno speciale livello molto basso chiamato FRAME_CONTENT_LAYER, numerato -30000.

È possibile accedere al pannello dei contenuti utilizzando getContentPane() Classe JFrame. Usando il metodo add(Component component), puoi aggiungere qualsiasi controllo ad esso. Sostituire Riquadro contenuto qualsiasi altro pannello di tipo JPanel, puoi usare il metodo setContentPane()

Un esempio di aggiunta di un pulsante al pannello dei contenuti:

JButton newButton = nuovo JButton(); getContentPane().add(newButton);

Di conseguenza, otteniamo una finestra con un pulsante. Il pulsante occupa l'intera area disponibile della finestra. Questo effetto non è utile in tutti i programmi, quindi è necessario utilizzare modi diversi per disporre gli elementi sul pannello.

Il pannello dei contenuti può essere completamente sostituito. Considera quanto segue Oscillazione esempio di pannello dei contenuti Riquadro contenuto.

Importa javax.swing.*; public class ContentPaneReplace estende JFrame ( private static final long serialVersionUID = 1L; public ContentPaneReplace() ( super("Test ContentPane"); setDefaultCloseOperation(EXIT_ON_CLOSE); // Crea un pannello con due pulsanti JPanel content = new JPanel(); content. add (new JButton("Family"));content.add(new JButton("School")); // Sostituzione del riquadro del contenuto setContentPane(contents); // Determinazione della dimensione della finestra setSize(200, 100); // Apertura della finestra setVisible (true); ) public static void main(String args) ( JFrame.setDefaultLookAndFeelDecorated(true); new ContentPaneAdd(); ) )

L'esempio crea una piccola finestra e un pannello con due pulsanti, che è poi setContentPane() sostituisce il riquadro del contenuto della finestra. Pertanto, è stata utilizzata una sostituzione invece di un'aggiunta più semplice, chiamando il metodo add(). L'interfaccia della finestra è mostrata nella schermata seguente.

Pannello dei contenuti Riquadro contenuto di per sé non è niente di speciale. Devi solo ricordare che i componenti vengono aggiunti ad esso.

JOptionPane trasparente

Pannello trasparente JOptionPane posizionato come pannello principale sopra tutti gli elementi del pannello a strati. Il posizionamento di JOptionPane è gestito dal riquadro principale, che posiziona il riquadro trasparente sopra il riquadro a strati in modo che copra completamente l'intera area della finestra, inclusa l'area occupata dalla barra dei menu.

JOptionPaneè usato raramente nelle applicazioni, quindi per impostazione predefinita il pannello principale lo rende invisibile, riducendo il carico sul sistema di disegno. Tieni presente che se rendi visibile un pannello trasparente, devi assicurarti che sia trasparente (la sua proprietà opaca è falsa), perché altrimenti coprirà tutti gli altri elementi del pannello principale e il resto dell'interfaccia sarà invisibile.

In quali casi si può utilizzare un pannello trasparente? JOptionPane? Può essere utilizzato per definire le funzionalità dell'applicazione che richiederebbero uno sforzo significativo per essere implementate da zero. Il pannello trasparente può essere adattato per il test automatizzato dell'interfaccia utente. Gli eventi in esso sintetizzati consentono di tenere traccia dei risultati di debug intermedi. A volte questo approccio è molto più efficace del test manuale.

Pannello trasparente JOptionPane può essere utilizzato per creare animazioni fantasiose che "fluttuano" su tutti i componenti, inclusa la barra dei menu, o per catturare eventi se alcuni di essi devono essere gestiti prima di essere inviati all'interfaccia utente principale.

Un esempio di utilizzo di uno Swing JOptionPane trasparente:

// Utilizzando un JOptionPane trasparente import java.awt.Dimension; importare java.awt.Font; import java.awt.event.WindowEvent; import java.awt.event.WindowListener; importare javax.swing.JDialog; importare javax.swing.JFrame; importare javax.swing.JLabel; importa javax.swing.JOptionPane; importare javax.swing.UIManager; public class JOptionPaneTest estende JFrame ( private static final long serialVersionUID = 1L; public static final Font FONT = new Font("Verdana", Font.PLAIN, 11); public static void createGUI() ( JFrame frame = new JFrame("Test JOptionPane "); frame.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE); frame.addWindowListener(new WindowListener() ( public void windowActivated(WindowEvent event) () public void windowClosed(WindowEvent event) () public void windowDeactivated(WindowEvent event) () public void windowDeiconified(WindowEvent event) () public void windowIconified(WindowEvent event) () public void windowOpened(WindowEvent event) () public void windowClosing(WindowEvent event) ( Opzioni oggetto = ( "Sì", "No!" ); int rc = JOptionPane.showOptionDialog(event.getWindow(), "Chiudi finestra?", "Conferma", JOptionPane.YES_NO_OPTION, JOptionPane.QUESTION_MESSAGE, null, options, options); (false);System.exit(0); ) ) )); JLabel label = new JLabel("Usa pannello trasparente alla chiusura della finestra"); frame.getContentPane().add(etichetta); frame.setPreferredSize(nuova dimensione(350, 80)); frame.pack(); frame.setLocationRelativeTo(null); frame.setVisible(true); ) public static void main(String args) ( javax.swing.SwingUtilities.invokeLater(new Runnable() ( public void run() ( UIManager.put("Button.font", FONT); UIManager.put("Label.font" ", FONT); JFrame.setDefaultLookAndFeelDecorated(true); JDialog.setDefaultLookAndFeelDecorated(true); createGUI(); ) )); ) )

Se al metodo setDefaultCloseOperation viene passata una costante JFrame.EXIT_ON_CLOSE, quindi quando la finestra viene chiusa, l'applicazione smetterà di funzionare. Nell'esempio, una costante viene passata a questo metodo JFrame.DO_NOTHING_ON_CLOSE in modo che non succeda nulla quando la finestra è chiusa. L'uscita dall'applicazione nell'esempio viene eseguita dal listener di JFrame WindowListener nel metodo finestraChiusura. Quando la finestra viene chiusa, il metodo windowClosing viene chiamato con un parametro di evento WindowEvent, che in uno Swing JOptionPane trasparente apre una finestra di dialogo di conferma.

La schermata seguente mostra due finestre dell'applicazione. Finestra principale in alto. Chiudendo questa finestra si apre la finestra di dialogo di conferma dell'intento inferiore.

JMenuBar Barra dei menu

Una delle caratteristiche importanti dell'utilizzo del pannello principale di JRootPane in Swing è la necessità di posizionare una barra dei menu nella finestra. JMenuBar. Non è possibile creare un'applicazione seria senza una sorta di menu per accedere alle funzioni del programma. La libreria Swing offre strutture eccellenti per la creazione di comode JMenuBar che sono anche componenti leggeri.

Barra dei menu JMenuBar posizionato in un pannello stratificato in uno strato speciale FRAME_CONTENT_LAYER e occupa un piccolo spazio nella parte superiore della finestra. La lunghezza della barra dei menu è uguale alla dimensione della finestra. La larghezza della barra dei menu dipende dai componenti che contiene.

Il pannello principale assicura che il pannello del contenuto e la barra dei menu JMenuBar non si sovrapponeva. Se la barra dei menu non è richiesta, il pannello principale utilizza tutto lo spazio per ospitare il pannello del contenuto.

Esempi di altalena

I codici sorgente degli esempi discussi nel testo della pagina possono essere scaricati.

Immaginiamo di averti stancato parlando continuamente di programmi di inferenza. messaggi di testo alla console. In questa lezione, questa "triste" serie di esempi verrà finalmente interrotta: ti mostreremo come si creano le finestre in Java e vedrai che questo è un compito facile. Ecco il nostro codice (cominceremo a discuterne nella prossima lezione, perché ha molte, molte caratteristiche che devi davvero conoscere):

importa java.awt.*;

importa javax.swing.*;

public class MoneyForNothing estende JFrame(

// Costruttore

public MoneyForNothing()(

setTitle("Benvenuto in Money for Nothing");

setSize(nuova dimensione(600, 400));

setDefaultCloseOperation(EXIT_ON_CLOSE);

setVisible(true);

public static void main(String args)(

MoneyForNothing mfn = nuovo MoneyForNothing();

Ed ecco lo stesso codice nella finestra di modifica FAR:

A proposito, ti consigliamo di digitare immediatamente i codici sorgente dei programmi nella codifica CP1251 (o nel linguaggio comune, nella codifica di Windows): il cambio delle codifiche avviene premendo F8 e la codifica corrente viene visualizzata nella barra di stato sopra l'area di modifica.

Il punto di ingresso è rimasto invariato, ma il resto del codice è cambiato nell'ordine (ma non andremo avanti). Dopo la compilazione e l'esecuzione, dovresti vedere quanto segue:

Congratulazioni, in poche righe hai creato una vera e propria finestra grafica! Può essere trascinato, ridimensionato, compresso, espanso e chiuso. È vero, la nostra finestra si è rivelata in qualche modo sbiadita, per dirla senza mezzi termini: "brutta". Inoltre, la finestra viene visualizzata nell'angolo in alto a sinistra dello schermo, ma mi piacerebbe che fosse al centro: è più comodo usarla lì e un tale output sembra più bello. Allora facciamo un po' di "lucidatura".

Innanzitutto, risolviamo il secondo problema: il centraggio della finestra. Qui ti consigliamo di fermarti e pensare: come lo faresti?

Diciamo che la libreria grafica Java ha un metodo setLocation, che riceve come parametri le coordinate dell'angolo in alto a sinistra della finestra (è da questo angolo che altri elementi grafici vengono posizionati all'interno della finestra). Ma se imposti questi parametri "sulla fronte", quasi sicuramente non ne verrà fuori nulla di buono. su un altro monitor con una risoluzione diversa, la finestra non sarà dove ti aspettavi. Pertanto, le coordinate devono essere impostate in modo più intelligente.

Tutto ciò che serve per centrare la finestra è conoscere la dimensione della finestra stessa (a proposito, sono impostate nel costruttore e formano un rettangolo di 600 per 400 pixel) e la risoluzione dello schermo, quindi, usando semplici calcoli aritmetici , calcola le coordinate necessarie dell'angolo in alto a sinistra. Ciò si ottiene inserendo il codice seguente

Dimensione sSize = Toolkit.getDefaultToolkit().getScreenSize(),

fSize = getSize();

if (fSize.height > sSize.height) (fSize.height = sSize.height;)

if (fSize.width > sSize.width) (fSize.width = sSize.width;)

setLocation((sSize.width - fSize.width)/2,

(sSize.height - fSize.height)/2);

subito dopo la riga setSize (new Dimension (600, 400)); nel costruttore. Apportare le modifiche necessarie al codice sorgente, compilare il programma ed eseguirlo per l'esecuzione; La finestra dovrebbe apparire al centro dello schermo monitor.

Ora qualche parola sull'aspetto della finestra. Il suo aspetto strano è spiegato dal fatto che gli sviluppatori Java hanno cercato di garantire che, indipendentemente dalla piattaforma hardware e dal "ripieno" del software, tutti gli elementi grafici (finestre, pulsanti, elenchi, ecc.) Avevano un unico rendering e un'unica combinazione di colori. Per fare questo, hanno sviluppato uno stile speciale, che hanno chiamato "METAL". Se lo sviluppatore non accetta sforzi speciali, quindi gli elementi dell'interfaccia grafica nei suoi programmi appariranno esattamente in questo stile, senza tener conto delle caratteristiche di computer specifici e dei loro Software. In alcuni casi, questo ha senso, ma devi comunque essere d'accordo sul fatto che è molto meglio se un programma in esecuzione su Windows sembra un programma Windows e in esecuzione su LINUX sembra un programma Linux. Questo è facile da ottenere. Tutto ciò che serve è includere il seguente codice nel punto di ingresso, prima di creare un'istanza della classe:

try(UIManager.setLookAndFeel

(UIManager.getSystemLookAndFeelClassName());

cattura(Eccezione)()

Ecco come lo faremo. Ora, dopo aver compilato la versione aggiornata del nostro programma e averlo eseguito per l'esecuzione, la finestra grafica apparirà molto "decente":

A seconda dell'impostazione delle proprietà di visualizzazione del monitor, la visualizzazione della finestra sarà diversa; usiamo il classico Tema di Windows xp. La tua finestra potrebbe assomigliare a questa:

Assicurati che tutto funzioni come previsto: la finestra viene visualizzata al centro dello schermo e il suo aspetto è come previsto.

Questo conclude la nostra prima lezione sulle GUI. In esso abbiamo mostrato la "facciata", ma abbiamo completamente lasciato "fuori bordo" molte questioni che sono estremamente importanti e senza le quali la programmazione in Java in generale e le interfacce grafiche in particolare è impossibile. Inizieremo ad affrontare questi problemi nella prossima lezione, ma per ora, gioca con il codice sorgente che hai.

Come esercizio, calcola, ad esempio, le coordinate dell'output della nostra finestra nell'angolo in basso a destra dello schermo e verifica il risultato.

Un altro esercizio è più semplice, ma dovrai usare la documentazione (da qualche parte devi proprio cominciare): fallo in modo da non poter ridimensionare la finestra, ad es. alla zona pulsanti di sistema sembrava la foto

(suggerimento: cercare informazioni su parole chiave javax e JFrame). Quindi rimboccati le maniche e buona fortuna!

Commento

Può capitare che la finestra generata sia completamente o parzialmente invisibile (a causa del fatto che hai calcolato in modo errato le coordinate della sua visualizzazione sullo schermo). Anche i pulsanti di controllo della finestra potrebbero non essere disponibili. Come interrompere l'applicazione senza rimuovere l'attività in "Gestione attività" o riavviare il computer?

Poiché avviamo programmi per l'esecuzione da FAR, l'interruzione dell'esecuzione di un programma Java si ottiene premendo la combinazione di tasti Control-C (qui "C" è una lettera latina, non confonderla con una lettera cirillica simile).