Una breve panoramica dei framework GUI per Java e la mia prima semplice applicazione GUI Swing. Creazione di un'interfaccia grafica in Java Librerie grafiche Esempi di programmi grafici in java
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. È stato a lungo accusato di essere avido di risorse di sistema, prestazioni lente 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à delle prime versioni di Swing era piuttosto lenta e gli errori nella scrittura di un programma potevano persino portare al 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 editor grafici Swing. 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.
Quindi, la logica di Game of Life viene implementata. Mi piacerebbe godermi il processo di contemplazione della diversità delle forme di "Vita" sullo schermo del mio monitor. Cosa sarà necessario per questo?
La finestra stessa con menu e pulsanti, così come il suo comportamento, verrà creata utilizzando la libreria Oscillazione. Disegnare il processo di evoluzione della nostra "Vita" - attraverso la biblioteca A.W.T.(più precisamente, Java 2D). Questi sono i due pacchetti principali per la creazione di GUI in Java.
Il lavoro di AWT si basa inizialmente sulle cosiddette interfacce peer. La linea di fondo è che se è necessario visualizzare un oggetto Java sullo schermo, il sistema operativo crea per esso un oggetto grafico accoppiato, che, di fatto, viene visualizzato. Questi due oggetti interagiscono tra loro mentre il programma è in esecuzione. Questa implementazione porta al fatto che ogni piattaforma deve rilasciare il proprio JDK.
Successivamente, AWT ha creato componenti che non utilizzano interfacce peer: componenti "leggeri" (leggeri). La libreria di questi componenti è stata denominata Swing. Cioè, Swing è, in effetti, un'estensione di AWT.
Lo stesso AWT è stato integrato con nuovi strumenti di disegno e visualizzazione delle immagini chiamati Java 2D.
Elencherò con una breve descrizione gli elementi principali di Swing.
L'elemento costitutivo di base dell'intera libreria dei componenti visivi di Swing è JComponent. Questa è la superclasse di ogni componente. È una classe astratta, quindi non puoi davvero creare un JComponent, ma contiene letteralmente centinaia di funzioni che ogni componente Swing può utilizzare come risultato della gerarchia delle classi.
jFrame(finestra dell'applicazione) - il contenitore principale che ti consente di aggiungere altri componenti a te stesso per organizzarli e fornirli all'utente. JFrame funge da ponte tra le parti Swing indipendenti dal sistema operativo e il sistema operativo effettivo su cui vengono eseguite. Il JFrame si registra come una finestra con il sistema operativo e quindi ottiene molte delle proprietà familiari di una finestra del sistema operativo.
JMenu/JMenuItem/JMenuBar- progettato per sviluppare un sistema di menu in un JFrame. La spina dorsale di qualsiasi sistema di menu è la JMenuBar, con essa viene creato ogni JMenu e JMenuItem. JMenu è una sottoclasse di JMenuItem. Tuttavia, differiscono nell'aspetto: JMenu è usato per contenere altri JMenuItem e JMenu; JMenuItem attiva un'azione quando selezionato.
JLabel(etichetta) - viene utilizzato per descrivere (testo o grafica) altri elementi.
jPulsante(pulsante) - il principale componente attivo che consente di eseguire alcune azioni quando viene premuto. Oltre ai metodi standard che controllano la visualizzazione del componente, contiene un gruppo di metodi per gestirne lo stato (attivo/non attivo, selezionato/non selezionato, mouse su/no mouse, premuto/rilasciato).
JTextField(campo di testo) - consente all'utente di inserire dati di testo che possono essere elaborati nel programma.
JTextArea estende JTextField per consentire l'immissione di più righe.
JPasswordField(campo password) - un tipo di JTextField che consente di nascondere i caratteri immessi.
JComboBox(elenco combinato) - Consente all'utente di selezionare un elemento da un elenco esistente (o aggiungere un nuovo elemento all'elenco).
JCheckBox(casella di controllo) e JRadioButton(pulsante di opzione) - Fornisce le opzioni tra cui l'utente può scegliere. I JRadioButton sono solitamente raggruppati insieme per fornire all'utente una domanda a risposta forzata (le risposte si escludono a vicenda - può esserci solo una risposta per domanda). Dopo aver selezionato un JRadioButton, non puoi deselezionarlo finché non selezioni un'altra opzione dal gruppo. JCheckBox funziona in modo diverso. Ti consente di selezionare/deselezionare un'opzione in qualsiasi momento e di selezionare più risposte per domanda. La classe che consente di raggruppare i componenti JCheckBox o JRadioButton è la classe ButtonGroup.
JSlider— un elemento per selezionare un valore numerico da un intervallo rappresentato graficamente.
JSpinner- serve per selezionare da un gruppo di valori. In questo è simile a JComboBox, anche se il loro utilizzo non dovrebbe essere intercambiabile. Dovresti usare JSpinner solo per scelte logicamente sequenziali: numeri e date sono perfetti per questo. JComboBox, d'altra parte, è una scelta migliore per presentare scelte apparentemente casuali che non hanno alcuna relazione tra loro.
JBarra degli strumenti funge da contenitore per altri componenti (JButtons, JComboBoxes, ecc.) che insieme formano le barre degli strumenti presenti nella maggior parte delle applicazioni. Le barre degli strumenti consentono al programma di posizionare i comandi utilizzati di frequente in una posizione comoda e raggrupparli. In genere, i pulsanti della barra degli strumenti corrispondono ai comandi di un menu.
J ToolTip- Queste sono piccole "bolle" che compaiono quando passi il mouse e tieni premuto il cursore del mouse su qualcosa. Possono essere molto utili nelle applicazioni, fornendo suggerimenti per elementi, informazioni dettagliate o persino mostrando il testo completo di un elemento in interfacce utente concise. Si attivano in Swing lasciando il cursore del mouse su un componente per un certo periodo di tempo; di solito compaiono circa un secondo dopo che il mouse si è fermato e rimangono visibili finché il cursore rimane sul componente.
JOptionPane- una classe per fornire agli sviluppatori dell'interfaccia utente un modo per inviare messaggi semplici (errore o altre informazioni) e ricevere rapidamente dati (ad esempio un nome o un numero).
jscrollpane- Componente oscillante per gestire tutte le azioni di scorrimento.
jlistè un componente utile per fornire all'utente molte opzioni tra cui scegliere. Puoi pensarla come un'estensione JComboBox. JList offre più scelte e aggiunge la possibilità di selezionare più scelte. La scelta tra JList e JComboBox è spesso una delle seguenti: Se hai bisogno di selezioni multiple o hai più di 15 scelte (sebbene questo numero non sia una regola generale), dovresti sempre scegliere JList. Dovresti usare JList insieme a JScrollPane perché può fornire più opzioni di quelle che rientreranno nell'area visibile. JList ha anche un modello selezionato che puoi impostare tipi diversi scelta delle opzioni. Questi tipi sono: scelta singola (puoi scegliere solo un'opzione), intervallo singolo (puoi scegliere un numero qualsiasi di opzioni adiacenti) e intervallo multiplo (puoi scegliere un numero qualsiasi di opzioni in qualsiasi combinazione).
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 esegui su una piattaforma diversa, potrebbero esserci differenze nelle dimensioni dei componenti e dei caratteri che rovineranno l'aspetto del programma.
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é diversi vantaggi contemporaneamente. L'insieme dei componenti standard supera di gran lunga 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 l'interfaccia grafica di un'applicazione, è necessario utilizzare componenti speciali della libreria Swing, chiamati contenitori di primo livello. 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 A che occupa tutto lo spazio disponibile nel 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 strati standard, utilizzati da tutti i componenti Swing, il che garantisce il corretto funzionamento di tutti i meccanismi del pannello stratificato. I livelli standard di JLayeredPane sono mostrati nella figura seguente.
Il livello Default viene utilizzato per ospitare tutti i componenti normali 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 text Figure estende JComponent ( private static final long serialVersionUID = 1L; private Color color; private int type; private String text; // parametri: color e figure type 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 figura 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 window super("Example LayeredTest"); // esce quando finestra è chiuso setDefaultCloseOperation( EXIT_ON_CLOSE); // definisce il pannello a strati JLayeredPane lp = getLayeredPane(); // crea tre forme Figure figure1 = new Figure(Color.red , 0, "Figure po cucciolo"); Figure figure2 = new Figure(Color.blue, 0, "Figure 1"); Figure figure3 = nuova figura(Color.cyan, 1, "Figure 2"); // determina la posizione delle figure nella finestra figure1.setBounds(10, 40, 120, 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.
Nelle applicazioni convenzionali, il pannello stratificato è raramente utilizzato direttamente, in cui svolge le sue funzioni in modo invisibile. Tuttavia, a volte aiuta a creare effetti sorprendenti e interfacce insolite, consentendo, ad esempio, di posizionare animazioni o video sopra componenti ordinari senza richiedere sforzi e trucchi disumani 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 che vengono successivamente aggiunti 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 un'animazione di fantasia che fluttua sopra 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:
// Utilizzo pannello trasparente JOptionPane 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.
Inviare il tuo buon lavoro nella knowledge base è semplice. Usa il modulo sottostante
Gli studenti, i dottorandi, i giovani scienziati che utilizzano la base di conoscenze nei loro studi e nel loro lavoro ti saranno molto grati.
postato su http://www.allbest.ru/
INTRODUZIONE
Negli ultimi anni, gli sviluppatori hanno fatto molti sforzi per integrare grafica e animazione nelle loro applet e applicazioni Java. Utilizzando le API java.awt e javax.swing, gli sviluppatori possono implementare applicazioni grafiche molto più complesse, inclusi giochi, screensaver, screensaver e GUI 3D.
Lo scopo del lavoro Il lavoro di calcolo e grafico è dedicato alla creazione di applicazioni utilizzando l'interfaccia grafica delle librerie java.awt e javax.swing.
Rilevanza Ad oggi, la grafica non ha poca importanza per i linguaggi di programmazione. Ti permette di visualizzare qualsiasi programma, che dà luminosità e comodità per l'utilizzo di determinati programmi. Ti consente di creare pagine Web luminose e interessanti, è conveniente durante lo sviluppo di database, la scrittura di giochi mobili e per computer.
1. FORMULAZIONE DEL PROBLEMA
L'interfaccia utente grafica (GUI) è il modo principale in cui gli utenti finali interagiscono con un'applicazione Java. Per lo sviluppo di applicato Software nel linguaggio Java, ovvero nell'interfaccia grafica delle applicazioni, vengono comunemente utilizzati i pacchetti AWT e Swing.
AWT (il pacchetto java.awt viene caricato per l'accesso) contiene un insieme di classi che consentono di eseguire operazioni grafiche e creare controlli di finestra, in modo simile a come avviene in VBA e Delphi;
Swing (il pacchetto javax.swing viene caricato per l'accesso) contiene nuove classi, per lo più simili ad AWT. J viene aggiunto ai nomi delle classi (JButton, JLabel, ecc.).
Al momento, le classi principali per la costruzione di interfacce visive sono contenute nel pacchetto Swing. Dal pacchetto AWT, le classi vengono utilizzate per elaborare i messaggi. Protozoi applicazione grafica sotto.
importa javax. oscillazione.*;
public final class HelloWorld implementa Runnable(
public static void main(String args) (
//Swing ha il suo thread di invio,
//che viene eseguito in parallelo con quello principale (in cui viene eseguito main())
//flusso. Se il thread principale termina l'esecuzione (il metodo principale termina),
//il thread responsabile del funzionamento dell'interfaccia Swing può continuare il suo lavoro.
//E anche se l'utente ha chiuso tutte le finestre, il programma continuerà il suo lavoro
//(finché è vivo dato filo). Da Java 6 quando tutto
//i componenti vengono distrutti, il flusso di controllo si interrompe automaticamente.
//Esegui tutto il codice in esecuzione sul thread di controllo, anche l'inizializzazione:
SwingUtilities.invokeLater(nuovo HelloWorld());
esecuzione vuota pubblica() (
// Crea una finestra con il titolo "Hello, World!"
Frame f = new JFrame("Hello, World!");
// La pratica precedente consisteva nel creare un listener e registrarsi
// nell'istanza della finestra principale che ha risposto a windowClosing()
// arresto forzato macchina virtuale chiamando System.exit()
// Ora c'è un modo più "corretto" per impostare la reazione alla chiusura della finestra.
// Questo metodo distrugge la finestra corrente, ma non arresta l'applicazione. Tem
// l'applicazione stessa verrà eseguita fino alla chiusura di tutte le finestre.
f.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
// tuttavia, puoi anche impostarlo in questo modo:
// f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
// Aggiunge un componente non modificabile con testo al pannello della finestra.
// f.getContentPane().add (new JLabel("Hello, World!")); - vecchio stile
f.add(new JLabel("Hello World"));
// pack() "comprime" la finestra alla dimensione ottimale
// tutti i componenti che si trovano al suo interno.
// Mostra finestra
f.setVisible(true);
Swing fornisce meccanismi per controllare i seguenti aspetti di una presentazione:
Tastiera (Swing fornisce un modo per intercettare l'input dell'utente)
Colori (Swing fornisce un modo per cambiare i colori che vedi sullo schermo)
Campo di testo per l'input (Swing fornisce componenti di testo per gestire tutte le attività quotidiane).
JComponent
La classe base dell'intera libreria dei componenti visivi Swing è JComponent. È una superclasse di altri componenti visivi. È una classe astratta, quindi non puoi davvero creare un JComponent, ma contiene centinaia di funzioni che ogni componente Swing può utilizzare come risultato della gerarchia delle classi. La classe JComponent fornisce l'infrastruttura di colorazione per tutti i componenti, sa come gestire tutti i tasti premuti sulla tastiera, le sue sottoclassi quindi devono solo ascoltare tasti specifici. La classe JComponent contiene anche un metodo add() che ti permette di aggiungere altri oggetti della classe JComponent, quindi puoi aggiungere qualsiasi componente Swing a qualsiasi altro per creare componenti nidificati (ad esempio, un JPanel contenente un JButton, o anche più fantasiosi combinazioni, come un JMenu contenente un JButton ).
JLabel
Il componente visivo più semplice e allo stesso tempo principale della libreria Swing è la JLabel, o "label". I metodi di questa classe includono l'impostazione del testo, dell'immagine, dell'allineamento e di altri componenti descritti dall'etichetta:
get/setText() - ottiene/imposta il testo nell'etichetta;
get/setIcon() - ottieni/imposta l'icona nell'etichetta;
get/setHorizontalAlignment - ottiene/imposta la posizione orizzontale del testo;
get/setDisplayedMnemonic() - ottiene/imposta il mnemonico (carattere sottolineato) per l'etichetta;
get/setLabelFor() - ottieni/imposta il componente a cui è collegata questa etichetta; quando l'utente preme la combinazione Tasti alt+ mnemonico, lo stato attivo si sposta sul componente specificato.
jPulsante
Il principale componente attivo in Swing è il Jbutton.
I metodi usati per cambiare le proprietà di un JButton sono simili a quelli di una JLabel (troverai che sono gli stessi per la maggior parte dei componenti Swing). Controllano testo, immagini e orientamento:
get/setText() - ottieni/imposta il testo nel pulsante;
get/setIcon() - ottieni/imposta l'immagine nel pulsante;
get/setHorizontalAlignment() - ottiene/imposta la posizione orizzontale del testo;
get/setVerticalAlignment() - ottiene/imposta la posizione verticale del testo;
get/setDisplayedMnenomic() - recupera/imposta il mnemonico (carattere sottolineato) che, in combinazione con il pulsante Alt, fa clic sul pulsante.
jFrame
La classe JFrame è un contenitore che permette di aggiungere altri componenti a se stessa per organizzarli e presentarli all'utente.
JFrame funge da ponte tra le parti Swing indipendenti dal sistema operativo e il sistema operativo effettivo su cui vengono eseguite. Il JFrame è registrato come finestra e quindi riceve molte delle proprietà della finestra del sistema operativo: minimizzazione/massimizzazione, ridimensionamento e spostamento. Mentre si fa il laboratorio, è sufficiente considerare JFrame come la tavolozza su cui si posizionano i componenti. Ecco alcuni dei metodi che puoi chiamare su un JFrame per cambiarne le proprietà:
get/setTitle() - ottiene/imposta il titolo del frame;
get/setState() - ottieni/imposta lo stato del frame (riduci a icona, massimizza, ecc.);
is/setVisible() - ottiene/imposta la visibilità del frame, ovvero la visualizzazione sullo schermo;
get/setLocation() - ottiene/imposta la posizione nella finestra in cui dovrebbe apparire il frame;
get/setSize() - ottieni/imposta la dimensione del frame;
add() - aggiunge componenti al frame.
Schemi, modelli ed eventi
Quando crei applicazioni visive in Java, non puoi semplicemente posizionarle casualmente sullo schermo e aspettarti che funzionino immediatamente. I componenti devono essere posizionati in posizioni specifiche, reagire alle interazioni con essi, aggiornarli in base a tale interazione e popolarli con i dati. Per lavorare in modo efficace con i componenti visivi, è necessario installare i seguenti tre componenti dell'architettura Swing.
Schemi (layout). Swing contiene molti schemi, che sono classi che controllano dove vengono posizionati i componenti in un'applicazione e cosa dovrebbe accadere quando la finestra dell'applicazione viene ridimensionata o quando i componenti vengono rimossi o aggiunti.
Eventi Il programma deve rispondere a sequenze di tasti, clic del mouse e qualsiasi altra cosa l'utente può fare.
Modelli (modello). Per i componenti più avanzati (elenchi, tabelle, alberi) e anche alcuni più semplici come JComboBox, i modelli sono i più metodo efficace lavorare con i dati. Rimuovono gran parte del lavoro di elaborazione dei dati dal componente stesso (si pensi a MVC) e forniscono un wrapper attorno alle classi di oggetti dati comuni (come Vector e ArrayList).
Particolare attenzione, data la necessità di visualizzare scene dinamiche su componenti visivi, dovrebbe essere data alla classe Graphics 2D.
Compito individuale di calcolo e lavoro grafico: Disegna nella finestra dell'applicazione un segmento che ruota nel piano della cornice attorno a un punto che si muove lungo il segmento.
Componente java della GUI
2. IMPLEMENTAZIONE DI UN PROBLEMA IN LINGUAGGIO DI ALTO LIVELLOGIAVA
importa java.awt.*;
importa java.awt.geom.*;
importa java.awt.image.BufferedImage;
* Un compito 4. ritrarre in finestra applicazioni (applet) segmento, rotante in
* aereo telaio intorno a punti in movimento Su segmento.
la classe pubblica LB4 estende java.applet.Applet implementa Runnable(
privato statico finale lungo serialVersionUID= 1 litro;
privato int w, h;
private BufferedImage bi;
privato Graphics2D grande;
stop booleano privato = falso;
timer thread privato = null;
private Color fonColor = Colore. BIANCA;
private Color segmentColor = Colore. GRIGIO CHIARO;
private Color pointColor = Colore. VERDE;
segmento privato;
// iniziale Posizione disegno
segmento privato a doppia lunghezza;
// direzione pregiudizio assi rotazione
punto di spostamento doppio privato = -1;
doppio turno privato = 0;
SpeedPoint doppio privato = 1;
// velocità i cambiamenti disposizioni in spazio
privato int speedRepaint = 30;
// angolo sul quale il in corso i cambiamenti disposizioni segmento
grado int privato = 15;
/** Questo metodo sarà chiamato dopo download applet */
public void init()(
// Noi creiamo oggetti e installare iniziale i valori.
Dimensione dim = getSize();
// Noi creiamo segmento, chiedendo lunghezza
lengthSegment = (doppio) Matematica. min(w, h) / 3;
segmento = new Segment(lengthSegment, lengthSegment / 2, grad,
segmentColor, pointColor, fonColor);
bi = (BufferedImage) createImage(w, h);
grande = bi.createGraphics();
big.setRenderingHint(RenderingHints. KEY_ANTIALIASING,
Suggerimenti per il rendering. VALUE_ANTIALIAS_ON);
// Noi creiamo fluire, quale il sarà periodicamente chiamata metodo aggiornare.
timer = nuovo Thread(questo);
) cattura (Eccezione e) (
Sistema. fuori.println(e);
) // fine dentro
// Questo metodo esegue ridisegno finestra applet
aggiornamento vuoto pubblico(Grafica g) (
// Noi abbiamo puntatore sul un oggetto Grafica2D
Grafica2D g2 = (Grafica2D) g;
// Disegniamo finito Immagine sul schermo
g2.drawImage(bi, 0, 0, questo);
) catch (Errore di eccezione) (
Sistema. fuori.println(errore.getMessage());
private void grawSegment() (
* //Pulizia immagine big.setBackground(Color.BLUE); big.clearRect(0, 0,
// Disegniamo segmento
spostamento += punto di spostamento * punto di velocità;
se (shift< -lengthSegment / 2) {
muoviPunto *= -1;
spostamento = -lunghezzaSegmento / 2;
) else if (shift > lengthSegment / 2) (
muoviPunto *= -1;
spostamento = lunghezzaSegmento / 2;
segment.setPos(shift, speedPoint);
segment.rotate();
big.drawImage(segment.getSegment(), null, 0, 0);
// Questo metodo eseguita in separato fluire(Timer).
// Lui cause ridisegno finestra applet ogni Dammi un secondo.
esecuzione vuota pubblica() (
filo. thread corrente();
filo. dormire(speedRepaint);
) catch (Eccezione err) (
// Questo metodo eseguita Se utente sinistra pagina
// Insieme a applet. Lui fermate fluire(timer) e, rispettivamente,
// ridisegno finestra applet.
arresto vuoto pubblico()(
// Questo metodo viene eseguito quando l'utente atterra sulla pagina
// con applet. Avvia un thread parallelo (timer).
inizio vuoto pubblico() (
if (timer == nullo) (
timer = nuovo Thread(questo);
// Questo metodo viene eseguito quando la pagina contenente l'applet viene chiusa.
public void destroy() (
super.distruggi();
filo. thread corrente();
// Attendi che il thread parallelo (timer) finisca.
filo. prodotto();
) // termina la distruzione
) // termina la classe pubblica RotatingSegment
// crea un segmento
doppio statico privato X = 0;
RAD doppio finale = 10;
doppia lunghezza privata;
segmento BufferedImage privato;
private ColorsegmentColor;
privato Colore puntoColore;
colore privato sfondoGroundColor;
privato Rectangle2D.Double r;
privato Ellipse2D.Doppia p;
doppia rotazione privataAsse;
privato Point2D.Doppio centro;
doppio turno privato;
// angolo di cui cambia la posizione del segmento
istituto privato;
Segmento(doppia lunghezza, doppia posPointRotating, int grad,
Segmento coloreColore, Punto coloreColore, Colore sfondoGroundColor)
throwsException(
// controlla i parametri
se (lunghezza<= 0 || posPointRotating < 0 || length < posPointRotating)
lancia una nuova eccezione(
"Errore: parametro non valido nella classe Segment");
this.grad = laureato;
this.segmentColor = segmentColor;
this.pointColor = pointColor;
this.backGroundColor = backGroundColor;
questa.lunghezza = lunghezza;
// crea il disegno
segmento = new BufferedImage((int) lunghezza * 3, (int) lunghezza * 3,
BufferedImage. TYPE_INT_ARGB);
center = new Point2D.Double(lunghezza, 3 * lunghezza / 2);
// crea un segmento
rotationAxis = center.x + posPointRotating - RAD / 2;
p = new Ellipse2D.Double(rotationAxis, center.y, RAD, RAD);
// imposta il colore del segmento
g2.setColor(segmentColor);
// disegna un segmento
// imposta il colore del punto
g2.setColor(pointColor);
// disegna un punto
// sposta il punto di rotazione
public void setPos(doppio shiftX, doppio shiftY) (
// crea un segmento
this.shift = shiftX;
center.y = center.y + shiftY * Math. peccato(Matematica. ai radianti(grado * X));
r = new Rectangle2D.Double(center.x, center.y, length, RAD);
p = new Ellipse2D.Double(rotationAxis + shift, center.y, RAD, RAD);
// ruota il segmento
vuoto pubblico ruota()(
AffineTransform a = AffineTransform. getRotateInstance(
Matematica. ai radianti(grado * (++ X)), rotazioneAsse + RAD / 2 + spostamento,
// ottieni il contesto grafico
Graphics2D g2 = segment.createGraphics();
// dipingi tutto con il colore dato
g2.setBackground(backGroundColor);
g2.clearRect(0, 0, (int) (3 * lunghezza), (int) (3 * lunghezza));
g2.setTransform(a);
g2.setColor(segmentColor);
// disegna un segmento
// imposta il colore del punto
g2.setColor(pointColor);
// disegna un punto
// Restituisce un'immagine
public BufferedImage getSegment() (
3. ESEMPIO DI FUNZIONAMENTO DEL PROGRAMMA
Il risultato dell'esecuzione del programma:
Figura 1. Il risultato dell'esecuzione del programma
Figura 2. Il risultato dell'esecuzione del programma
Figura 3. Il risultato dell'esecuzione del programma
CONCLUSIONE
Questo conclude la nostra discussione sulla grafica in Java. In questo articolo, abbiamo presentato una breve panoramica degli strumenti di programmazione grafica 2D in Java. Abbiamo presentato un'applicazione che dimostra l'uso di forme geometriche, trame.
Abbiamo discusso alcune delle caratteristiche grafiche di Java. Abbiamo iniziato con una breve introduzione ai fondamenti della grafica, come i sistemi di coordinate e i contesti grafici. Abbiamo quindi discusso le strutture Java 2D. Abbiamo anche spiegato brevemente come utilizzare gli effetti grafici.
La seconda metà della nostra introduzione alla programmazione grafica in Java. Utilizzando l'interfaccia grafica delle librerie java.awt e javax.swing, abbiamo creato un semplice editor grafico che ruota un oggetto bidimensionale attorno al proprio asse.
BIBLIOGRAFIA
1. H. M. Deitel, P.J. Deitel, SI Suntry - Tecnologie di programmazione Java, Libro 1 (grafica, JAVABEANS, interfaccia utente)
2. Judy Bishop - Lavorare Java in modo efficiente
3. James Gosling, Bill Joy, Guy Steele, Gilad Bracha - La specifica del linguaggio Java, seconda edizione.
4. Tim Lindholm, Frank Yellin - La specifica della macchina virtuale Java, seconda edizione.
5. Gosling J., Arnold K. - Linguaggio di programmazione Java
6. Informazioni da www.ibm.com
7. Informazioni dal sito www.mexmat.sgu.ru
8. Informazioni dal sito www.uic.rsu.ru
Ospitato su Allbest.ru
...Documenti simili
Struttura dell'organizzazione della GUI, dichiarazione e creazione di listener di eventi utilizzando classi anonime. La rappresentazione dei dati per la tabella è la classe AbstractTableModel. Visualizzazione delle celle della tabella. I due tipi principali di flussi di I/O in Java.
lezione, aggiunta il 05/01/2014
Sviluppo di un editor grafico per disegnare grafica bidimensionale e tridimensionale utilizzando il linguaggio di programmazione Java e le interfacce di programmazione applicativa Java 2D e Java 3D. Creazione di un editor grafico 3D Paint. I metodi principali della classe Graphics.
tesina, aggiunta il 19/11/2009
Descrizione del pacchetto di applicazioni Net Beans 8.1. Sviluppo dell'interfaccia utente dell'applet. Creazione di finestre frame basate sui frame della libreria java.swing. Cambia il colore dei dati di testo. Progettazione e creazione di un modello infologico di un'applet.
lavoro di controllo, aggiunto il 07/11/2016
Possibilità di rete dei linguaggi di programmazione. Vantaggi dell'utilizzo di applet Java. Classi incluse nella libreria java.awt. Creazione dell'interfaccia utente. Connessione socket al server. Grafica in Java. I valori delle componenti di colore.
tesina, aggiunta il 10/11/2014
Java Foundation Classes, concetti di base. La gerarchia di classi di Abstract Window Toolkit originale. Rappresentanti dell'interfaccia utente. Gestione degli eventi in JavaBeans. Controlli, campo multilinea JText. Elenco del programma TextEditor.
tesina, aggiunta il 26/06/2013
Esecuzione di un programma Java. Un insieme di programmi e classi JDK. Programmazione orientata agli oggetti in Java. Principi di costruzione di un'interfaccia grafica. Componente e contenitore del sistema grafico. Le applet sono programmi che vengono eseguiti in un ambiente browser.
tesina, aggiunta il 02/08/2011
Diagramma dell'applicazione della console di tabulazione delle funzioni. La differenza tra un'applicazione console e un'applicazione e una GUI. Diagramma di classe per JFrame e JPanel. Creazione di un semplice frame in Java. Il layout degli elementi dell'interfaccia all'interno di un frame. Ciclo di eventi.
lezione, aggiunta il 05/01/2014
Il concetto e le caratteristiche generali del linguaggio di programmazione PHP, i principi e le fasi del suo lavoro, la sintassi e gli array associati. Gestione delle eccezioni in Java. Lavorare con i database usando JDBC. Imparare a sviluppare un'interfaccia grafica.
presentazione, aggiunta il 13/06/2014
Sviluppo di uno schema logico per un database di un'impresa di produzione automobilistica. Modellazione del sistema infologico. Creazione di un'interfaccia utente grafica per il database utilizzando il linguaggio di programmazione Java. Test del software.
tesina, aggiunta il 16/12/2013
Creazione di applicazioni console utilizzando l'interfaccia utente grafica. Contenuto della tavolozza dei componenti del programma C++ Builder. Utilizzando le possibilità della programmazione orientata agli oggetti, le funzionalità dell'editor di codice e i moduli in C++.
