Perpustakaan grafis java. Tinjauan Singkat Kerangka Kerja Java GUI dan Aplikasi GUI Swing Sederhana Pertama Saya

Jadi, logika Game of Life diimplementasikan. Saya ingin menikmati proses merenungkan keragaman bentuk "Kehidupan" di layar monitor saya. Apa yang dibutuhkan untuk ini?

Jendela itu sendiri dengan menu dan tombol, serta perilakunya akan dibuat menggunakan pustaka Mengayun. Menggambar proses evolusi "Hidup" kita - melalui perpustakaan A.W.T.(lebih tepatnya, Java 2D). Ini adalah dua paket utama untuk membuat GUI di Java.

Karya AWT awalnya didasarkan pada apa yang disebut antarmuka peer. Intinya adalah jika perlu menampilkan objek Java di layar, sistem operasi membuat objek grafis berpasangan untuknya, yang sebenarnya ditampilkan. Kedua objek ini berinteraksi satu sama lain saat program sedang berjalan. Implementasi ini mengarah pada fakta bahwa setiap platform harus merilis JDK-nya sendiri.

Belakangan, AWT membuat komponen yang tidak menggunakan antarmuka peer - komponen "ringan" (ringan). Perpustakaan komponen ini diberi nama Swing. Artinya, Swing sebenarnya adalah perpanjangan dari AWT.

AWT sendiri dilengkapi dengan alat gambar dan tampilan gambar baru yang disebut Jawa 2D.

Saya akan membuat daftar dengan deskripsi singkat tentang elemen utama Swing.

Blok bangunan dasar dari seluruh pustaka komponen visual Swing adalah JComponent. Ini adalah superclass dari setiap komponen. Ini adalah kelas abstrak, jadi Anda tidak dapat benar-benar membuat JComponent, tetapi ini berisi ratusan fungsi yang dapat digunakan oleh setiap komponen Swing sebagai hasil dari hierarki kelas.

jFrame(jendela aplikasi) - wadah utama yang memungkinkan Anda menambahkan komponen lain ke diri Anda sendiri untuk mengaturnya dan memberikannya kepada pengguna. JFrame bertindak sebagai jembatan antara bagian Swing yang tidak bergantung pada OS dan OS aktual tempat mereka menjalankannya. JFrame terdaftar sebagai jendela dengan OS dan karenanya mendapatkan banyak properti jendela yang sudah dikenal sistem operasi.

JMenu/JMenuItem/JMenuBar- dirancang untuk mengembangkan sistem menu dalam JFrame. Tulang punggung dari setiap sistem menu adalah JMenuBar, setiap JMenu dan JMenuItem dibuat dengannya. JMenu adalah subkelas dari JMenuItem. Namun, tampilannya berbeda: JMenu digunakan untuk memuat JMenuItem dan JMenu lainnya; JMenuItem mengaktifkan tindakan saat dipilih.

JLabel(label) - digunakan untuk mendeskripsikan (teks atau grafik) elemen lain.

jButton(tombol) - komponen aktif utama yang memungkinkan Anda melakukan beberapa tindakan saat ditekan. Selain metode standar yang mengontrol tampilan komponen, ini berisi sekelompok metode untuk mengelola statusnya (aktif / tidak aktif, dipilih / tidak dipilih, mouse ke atas / tanpa mouse, ditekan / dilepaskan).

JTextField(bidang teks) - memungkinkan pengguna untuk memasukkan data teks yang dapat diproses dalam program.

JTextArea memperluas JTextField untuk memungkinkan banyak baris dimasukkan.

JPasswordField(bidang kata sandi) - jenis JTextField yang memungkinkan Anda menyembunyikan karakter yang Anda masukkan.

JComboBox(daftar kombo) - Memungkinkan pengguna untuk memilih item dari daftar yang ada (atau menambahkan item baru ke daftar).

JCheckBox(kotak centang) dan JRadioButton(tombol radio) - Menyediakan opsi untuk dipilih pengguna. JRadioButtons biasanya dikelompokkan bersama untuk memberi pengguna pertanyaan jawaban yang dipaksakan (jawabannya saling eksklusif - hanya ada satu jawaban per pertanyaan). Setelah Anda memilih JRadioButton, Anda tidak dapat menghapus centangnya sampai Anda memilih opsi lain dari grup. JCheckBox bekerja secara berbeda. Ini memungkinkan Anda untuk mencentang/menghapus centang opsi kapan saja dan memilih beberapa jawaban per pertanyaan. Kelas yang memungkinkan komponen JCheckBox atau JRadioButton dikelompokkan bersama adalah kelas Grup Tombol.

JSlider— elemen untuk memilih nilai numerik dari rentang yang direpresentasikan secara grafis.

JSpinner- adalah untuk memilih dari sekelompok nilai. Dalam hal ini mirip dengan JComboBox, meskipun penggunaannya tidak boleh dipertukarkan. Anda sebaiknya hanya menggunakan JSpinner untuk pilihan yang berurutan secara logis - angka dan tanggal sangat cocok untuk ini. JComboBox, di sisi lain, lebih dari itu pilihan yang bagus untuk mewakili opsi yang tampaknya acak yang tidak memiliki hubungan satu sama lain.

JToolBar bertindak sebagai wadah untuk komponen lain (JButtons, JComboBoxes, dll.) yang bersama-sama membentuk bilah alat yang ditemukan di sebagian besar aplikasi. Bilah alat memungkinkan program untuk menempatkan perintah yang sering digunakan di tempat yang nyaman dan mengelompokkannya. Biasanya, tombol bilah alat sesuai dengan perintah pada menu.

JToolTip- Ini adalah "gelembung" kecil yang muncul saat Anda mengarahkan dan menahan kursor mouse di atas sesuatu. Mereka bisa sangat berguna dalam aplikasi, menyediakan tooltips untuk elemen, merinci informasi, atau bahkan menampilkan teks lengkap dari suatu elemen dalam UI yang ringkas. Mereka diaktifkan di Swing dengan meninggalkan kursor mouse di atas komponen untuk jangka waktu tertentu; mereka biasanya muncul sekitar satu detik setelah mouse berhenti dan tetap terlihat selama kursor berada di atas komponen.

JOptionPane- kelas untuk menyediakan pengembang UI cara mengeluarkan pesan sederhana (kesalahan atau informasi lainnya) dan dengan cepat menerima data (misalnya, nama atau nomor).

jscrollpane- Swing komponen untuk menangani semua tindakan gulir.

jlist adalah komponen yang berguna untuk memberi pengguna banyak opsi untuk dipilih. Anda dapat menganggapnya sebagai ekstensi JComboBox. JList memberikan lebih banyak pilihan dan menambahkan kemampuan untuk memilih banyak pilihan. Pilihan antara JList dan JComboBox seringkali adalah salah satu dari berikut ini: Jika Anda memerlukan banyak pilihan atau memiliki lebih dari 15 pilihan (walaupun angka ini bukan aturan umum), Anda harus selalu memilih JList. Anda harus menggunakan JList bersamaan dengan JScrollPane karena dapat memberikan lebih banyak opsi daripada yang muat di area yang terlihat. JList juga memiliki model pilihan yang dapat Anda atur Berbagai jenis pilihan opsi. Jenis ini adalah: pilihan tunggal (Anda hanya dapat memilih satu opsi), rentang tunggal (Anda dapat memilih sejumlah opsi yang berdekatan), dan rentang berganda (Anda dapat memilih sejumlah opsi dalam kombinasi apa pun).

Antarmuka grafis di Jawa telah melalui jalur pengembangan dan pembentukan yang sangat sulit. Untuk waktu yang lama dia dituduh bekerja lambat, rakus akan sumber daya sistem, dan fungsionalitas terbatas.

Jawa AWT

Upaya pertama Sun di GUI untuk Java adalah perpustakaan A.W.T.(Toolkit Window Abstrak) - toolkit untuk bekerja dengan berbagai lingkungan jendela. Sun telah membuat lapisan Java yang memanggil metode dari perpustakaan yang ditulis dalam C. Metode perpustakaan AWT membuat dan menggunakan komponen grafis dari lingkungan operasi. Di satu sisi, ini bagus, karena program Java mirip dengan program lain dalam OS yang sama. Namun saat menjalankannya di platform yang berbeda, mungkin ada perbedaan ukuran komponen dan font yang akan merusak penampilan program.

Untuk memastikan multi-platform A.W.T. antarmuka panggilan komponen telah disatukan, menghasilkan fungsionalitas yang sedikit berkurang. Dan rangkaian komponennya ternyata cukup kecil. Misalnya, tidak ada tabel di AWT, dan ikon tidak didukung di tombol. Namun, paketnya java.awt disertakan dengan Java sejak rilis pertama dan dapat digunakan untuk membuat GUI.

Jadi komponennya A.W.T. tidak melakukan "pekerjaan". Itu hanya "pembungkus Java" untuk kontrol dari sistem operasi yang mereka jalankan. Semua permintaan ke komponen ini dialihkan ke sistem operasi, yang melakukan semua pekerjaan.

Sumber daya yang digunakan A.W.T. mencoba untuk melepaskan secara otomatis. Ini sedikit memperumit arsitektur dan memengaruhi kinerja. Menulis sesuatu yang serius menggunakan AWT akan agak sulit. Sekarang hanya digunakan untuk applet.

Konsep Dasar SWING

Setelah A.W.T. Sun telah mengembangkan perpustakaan komponen grafis Mengayun, seluruhnya ditulis dalam bahasa Jawa. 2D digunakan untuk rendering, yang membawa beberapa keuntungan sekaligus. Kumpulan komponen standar jauh melebihi AWT dalam hal variasi dan fungsionalitas. Swing memudahkan pembuatan komponen baru dengan mewarisi komponen yang sudah ada, dan mendukung berbagai gaya dan skin.

Pembuat perpustakaan UI baru Mengayun tidak "menemukan kembali roda" dan memilih AWT sebagai dasar perpustakaan mereka. Tentu saja, kami tidak berbicara tentang penggunaan komponen AWT kelas berat tertentu (diwakili oleh kelas Button, Label, dan sejenisnya). Hanya komponen ringan yang memberikan tingkat fleksibilitas dan kemampuan kontrol yang diperlukan. Diagram pewarisan menunjukkan hubungan antara AWT dan Swing.

Perbedaan yang paling penting Mengayun dari AWT adalah bahwa komponen Swing sama sekali tidak terhubung ke sistem operasi dan karenanya jauh lebih stabil dan lebih cepat. Komponen semacam itu disebut ringan di Java, dan memahami prinsip dasar cara kerjanya akan sangat membantu menjelaskan cara kerja Swing.

Ayunkan Kontainer Tingkat Atas

Untuk membuat GUI aplikasi perlu menggunakan komponen khusus dari pustaka Swing yang disebut container level tertinggi(kontainer tingkat atas). Mereka adalah jendela sistem operasi yang menampung komponen antarmuka pengguna. Kontainer tingkat atas mencakup jendela JFrame dan JWindow, kotak dialog JDialog, dan applet JApplet (yang bukan merupakan jendela, tetapi juga dimaksudkan untuk menampilkan antarmuka di browser yang menjalankan applet ini). Kontainer Swing tingkat atas adalah komponen kelas berat dan merupakan pengecualian dari aturan umum. Semua komponen Swing lainnya ringan.

Sederhana Mengayun contoh antarmuka jendela jFrame.

Impor java.awt.Dimensi; impor javax.swing.JFrame; import javax.swing.JLabel; kelas publik 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(); ) )); ) )

Konstruktor JFrame() tanpa parameter membuat jendela kosong. Konstruktor JFrame (Judul string) membuat jendela kosong dengan judul judul. Untuk membuat program yang paling sederhana dengan jendela kosong, metode berikut harus digunakan:

  • setSize(int width, int height) - menentukan ukuran jendela;
  • setDefaultCloseOperation(int operation) - definisi tindakan pada penghentian program;
  • setVisible(boolean terlihat) - membuat jendela terlihat.

Jika Anda tidak menentukan ukuran jendela, maka ketinggiannya akan nol terlepas dari apa yang ada di dalamnya. Dimensi jendela tidak hanya mencakup area "kerja", tetapi juga batas dan bilah judul.

Metode setDefaultCloseOperation menentukan tindakan yang akan diambil saat "keluar dari program". Untuk melakukannya, berikan konstanta EXIT_ON_CLOSE, yang dijelaskan di kelas JFrame, sebagai parameter operasi.

Secara default, jendela dibuat tidak terlihat. Untuk menampilkan jendela di layar, metode setVisible dipanggil dengan parameter true. Jika Anda memanggilnya dengan parameter false, jendela akan menjadi tidak terlihat.

GUI ayunan jawa contoh pembuatan jendela jFrame ditunjukkan pada gambar berikut.

Untuk menghubungkan perpustakaan Mengayun aplikasi perlu mengimpor perpustakaan javax.swing.

Setiap kali wadah tingkat atas dibuat, baik itu jendela normal, kotak dialog, atau applet, konstruktor wadah membuat Panel akar JRootPane. Kontainer Swing tingkat atas memastikan bahwa komponen lain tidak dapat "merangkak" di luar JRootPane.

Akar Pucat JRootPane menambahkan properti "kedalaman" ke wadah, memberikan kemampuan tidak hanya untuk menempatkan komponen satu di atas yang lain, tetapi juga, jika perlu, menukarnya, menambah atau mengurangi kedalaman komponen. Fitur ini diperlukan saat membuat aplikasi multi-dokumen. Mengayun, yang jendelanya mewakili komponen ringan yang ditumpuk satu sama lain, serta menu drop-down (konteks) dan tooltips.

Gambar berikut dengan jelas menunjukkan struktur panel akar JRootPane.

Panel akar JRootPane adalah wadah yang mewarisi dari kelas dasar Swing JComponent. Dalam penampung ini, pengelola tata letak khusus, yang diterapkan di kelas RootPaneLayout internal, bertanggung jawab atas tata letak komponen. Manajer tata letak ini bertanggung jawab untuk memastikan bahwa semua bagian komponen panel akar ditempatkan sebagaimana mestinya: panel berlapis menempati seluruh ruang jendela; FRAME_CONTENT_LAYER berisi bilah menu dan panel konten, dan yang terpenting adalah panel transparan.

Semua komponen panel root JRootPane dapat diperoleh atau diubah. Ini memiliki satu set metode get/set untuk ini. Secara terprogram JRootPane dapat diperoleh dengan menggunakan metode getRootPane().

Selain wadah tingkat atas, panel root digunakan di jendela JInternalFrame internal yang dibuat dalam aplikasi multi-dokumen dan terletak di JDesktopPane "desktop". Ini memungkinkan Anda untuk melupakan bahwa jendela ini adalah komponen ringan biasa, dan bekerja dengannya seolah-olah itu adalah wadah tingkat atas yang sebenarnya.

Panel Berlapis JLayeredPane

Di dasar panel akar (wadah) terdapat apa yang disebut panel berlapis JLayeredPane Sebuah yang mengambil semua ruang yang tersedia dalam wadah. Di panel inilah semua bagian lain dari panel root berada, termasuk semua komponen antarmuka pengguna.

JLayeredPane digunakan untuk menambahkan properti kedalaman ke wadah. Artinya, panel multilayer memungkinkan Anda mengatur dimensi ketiga dalam wadah, di mana lapisan (lapisan) komponen berada. Dalam wadah normal, lokasi komponen ditentukan oleh persegi panjang yang menunjukkan berapa banyak wadah yang ditempati komponen tersebut. Saat menambahkan komponen ke panel multilayer, Anda harus menentukan tidak hanya persegi panjang yang ditempati oleh komponen, tetapi juga lapisan tempatnya. Lapisan dalam panel berlapis ditentukan oleh bilangan bulat. Semakin besar angka yang menentukan lapisan, semakin tinggi lapisannya.

Komponen pertama yang ditambahkan ke wadah lebih tinggi daripada komponen yang ditambahkan kemudian. Paling sering, pengembang tidak berurusan dengan posisi komponen. Saat Anda menambahkan komponen, posisinya berubah secara otomatis. Namun, panel berlapis memungkinkan Anda mengubah posisi komponen secara dinamis, setelah ditambahkan ke wadah.

Kemampuan panel berlapis banyak digunakan oleh beberapa komponen Mengayun. Mereka sangat penting untuk aplikasi multi-dokumen, tooltips dan menu. Multidokumen Mengayun aplikasi menggunakan wadah khusus JDesktopPane("desktop") diwarisi dari JLayeredPane A yang menahan jendela Swing bagian dalam. Paling fitur penting aplikasi multi-dokumen - lokasi jendela "aktif" di atas yang lain, meminimalkan jendela, menyeretnya - disediakan oleh mekanisme panel multilayer. Keuntungan utama menggunakan panel berlapis untuk tooltips dan menu adalah kecepatannya. Alih-alih membuat jendela kelas berat baru untuk setiap tooltip atau menu, terletak di atas komponen di mana tooltip atau menu diminta, Mengayun menciptakan komponen ringan yang cepat. Komponen ini ditempatkan di lapisan yang cukup tinggi dari panel berlapis di atas tumpukan semua komponen lainnya dan digunakan untuk menampilkan tooltip atau menu.

Panel multi-lapisan memungkinkan Anda mengatur lapisan dalam jumlah tak terbatas. Struktur JLayeredPane mencakup beberapa lapisan standar, yang digunakan oleh semua komponen Swing, yang memastikan bahwa semua mekanisme panel berlapis bekerja dengan benar. Lapisan JLayeredPane standar ditunjukkan pada gambar berikut.

Lapisan Default digunakan untuk menampung semua komponen normal yang ditambahkan ke wadah. Lapisan ini berisi jendela internal aplikasi multi-dokumen.

Lapisan Palette dirancang untuk menghosting jendela dengan seperangkat alat, yang biasanya tumpang tindih dengan antarmuka lainnya. Panel JDesktopPane memungkinkan Anda membuat jendela seperti itu, yang menempatkannya di lapisan ini.

Lapisan Modal dimaksudkan untuk menampung kotak dialog modal yang ringan. Namun, kotak dialog seperti itu belum diimplementasikan, jadi lapisan ini saat ini tidak digunakan di Swing.

Lapisan yang paling umum digunakan untuk menu popup dan tooltips.

Lapisan paling atas. Dirancang untuk operasi seret dan lepas, yang harus terlihat jelas di antarmuka program.

Contoh kecil JLayeredPane dengan panel berlapis menunjukkan cara menambahkan komponen ke lapisan yang berbeda dan bagaimana lapisan menumpuk di atas satu sama lain:

Impor javax.swing.*; import java.awt.*; // kelas untuk menggambar dua jenis gambar dengan teks kelas Gambar meluas JComponent ( private static final long serialVersionUID = 1L; warna warna pribadi; jenis int pribadi; teks String pribadi; // parameter: warna dan tipe gambar Gambar(Warna warna, int ketik, Teks string) ( this.color = warna; this.type = type; this.text = teks; setOpaque(false); ) public void paintComponent(Graphics g) ( // menggambar gambar g.setColor(color); beralih (ketik ) ( 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 memperluas JFrame ( private static final long serialVersionUID = 1L; public JLayeredPaneTest() ( // membuat jendela super("Contoh LayeredTest"); // keluar saat jendela ditutup setDefaultCloseOperation( EXIT_ON_CLOSE); // tentukan panel berlapis JLayeredPane lp = getLayeredPane(); // buat tiga bentuk Gambar gambar1 = Gambar baru(Warna.merah , 0, "Gambar po anak anjing"); Gambar gambar2 = Gambar baru(Warna.biru, 0, "Gambar 1"); Gambar gambar3 = Gambar baru(Warna.cyan, 1, "Gambar 2"); // tentukan lokasi angka di jendela figure1.setBounds(10, 40, 120, 120); angka2.setBounds(60, 120, 160, 180); angka3.setBounds(90, 55, 250, 180); // menambahkan bentuk ke layer yang berbeda lp.add(figure1, JLayeredPane.POPUP_LAYER); lp.add(figure2, JLayeredPane.PALETTE_LAYER); lp.add(figure3, JLayeredPane.PALETTE_LAYER); // ubah posisi salah satu angka lp.setPosition(gambar3, 0); // menentukan ukuran dan membuka jendela setSize(280, 250); setVisible(benar); ) public static void main(String args) ( JFrame.setDefaultLookAndFeelDecorated(true); new JLayeredPaneTest(); ) )

Contoh membuat jendela kecil jFrame dan beberapa komponen Gambar ditambahkan ke panel berlapis. Untuk mendapatkan panel berlapis di wadah Swing tingkat atas mana pun, panggil saja metodenya getLayeredPane().

Kelas pembantu Gambar mewarisi properti kelas dasar JComponent dan memungkinkan Anda menggambar dua jenis bentuk (lingkaran dan persegi panjang) dengan warna berbeda. Parameter untuk menggambar bentuk diatur dalam konstruktor kelas.

Saat mendefinisikan antarmuka, tiga bentuk warna berbeda (dua lingkaran dan persegi panjang) dibuat. Lingkaran ditempatkan di lapisan POPUP_LAYER, dan persegi panjang ditempatkan di lapisan PALETTE_LAYER. Saat menempatkan komponen, koordinat layar absolutnya ditentukan, karena pengelola lokasi biasa tidak bekerja di panel berlapis.

Pada akhirnya, posisi salah satu persegi panjang diubah menjadi yang pertama di lapisan, meskipun awalnya ditambahkan yang kedua. Saat Anda menjalankan aplikasi, Anda akan melihat bahwa panel berlapis berfungsi dan mengatur komponen dengan rapi sesuai dengan lapisan dan posisinya.

Dalam aplikasi konvensional, panel berlapis jarang digunakan secara langsung, di mana ia menjalankan fungsinya tanpa terlihat. Namun, terkadang membuat efek luar biasa dan antarmuka yang tidak biasa membantu, misalnya, memungkinkan Anda menempatkan animasi atau video di atas komponen biasa tanpa memerlukan upaya dan trik manusia super dari pengembang.

ContentPane

ContentPane adalah bagian selanjutnya dari panel akar dan digunakan untuk menampung komponen antarmuka pengguna program. ContentPane menempati sebagian besar ruang panel berlapis (kecuali ruang yang ditempati oleh bilah menu). Untuk mencegah panel konten menutupi komponen yang nantinya ditambahkan ke jendela, panel berlapis menempatkannya pada lapisan khusus sangat rendah yang disebut FRAME_CONTENT_LAYER, bernomor -30000.

Anda dapat mengakses panel konten menggunakan getContentPane() kelas JFrame. Menggunakan metode add(Component component), Anda dapat menambahkan kontrol apa pun ke dalamnya. Mengganti ContentPane panel jenis JPanel lainnya, Anda dapat menggunakan metode ini setContentPane()

Contoh menambahkan tombol ke panel konten:

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

Hasilnya, kami mendapatkan jendela dengan tombol. Tombol tersebut menempati seluruh area jendela yang tersedia. Efek ini tidak berguna di semua program, jadi Anda perlu menggunakan cara berbeda untuk mengatur elemen di panel.

Panel konten dapat diganti sepenuhnya. Pertimbangkan yang berikut ini Mengayun contoh panel konten ContentPane.

Impor javax.swing.*; kelas publik ContentPaneReplace memperluas JFrame ( private static final long serialVersionUID = 1L; public ContentPaneReplace() ( super("Test ContentPane"); setDefaultCloseOperation(EXIT_ON_CLOSE); // Membuat panel dengan dua tombol JPanel isi = new JPanel(); isi. add (new JButton("Family")); contents.add(new JButton("School")); // Mengganti panel konten setContentPane(contents); // Menentukan ukuran jendela setSize(200, 100); // Membuka jendela setVisible (true); ) public static void main(String args) ( JFrame.setDefaultLookAndFeelDecorated(true); new ContentPaneAdd(); ) )

Contohnya membuat jendela kecil dan panel dengan dua tombol, yaitu setContentPane() menggantikan panel konten jendela. Jadi, pengganti digunakan sebagai pengganti tambahan yang lebih sederhana - memanggil metode add (). Antarmuka jendela ditampilkan di tangkapan layar berikut.

Panel konten ContentPane sendiri tidak ada yang istimewa. Anda hanya perlu mengingat bahwa komponen ditambahkan ke dalamnya.

JOptionPane transparan

Panel transparan JOptionPane ditempatkan sebagai panel akar di atas semua elemen panel berlapis. Penempatan JOptionPane ditangani oleh root pane, yang menempatkan panel transparan di atas panel berlapis sehingga benar-benar menutupi seluruh area jendela, termasuk area yang ditempati oleh menu bar.

JOptionPane jarang digunakan dalam aplikasi, jadi secara default panel root membuatnya tidak terlihat, yang mengurangi beban pada sistem gambar. Perlu diingat bahwa jika Anda membuat panel transparan terlihat, Anda perlu memastikan bahwa itu transparan (properti buramnya salah), karena jika tidak maka akan menutupi semua elemen lain dari panel root, dan antarmuka lainnya akan menjadi tak terlihat.

Dalam kasus apa panel transparan dapat digunakan? JOptionPane? Ini dapat digunakan untuk menentukan fitur aplikasi yang memerlukan upaya signifikan untuk diterapkan dari awal. Panel transparan dapat diadaptasi untuk pengujian antarmuka pengguna otomatis. Peristiwa yang disintesis di dalamnya memungkinkan Anda melacak hasil debugging menengah. Terkadang pendekatan ini jauh lebih efektif daripada pengujian manual.

Panel transparan JOptionPane dapat digunakan untuk membuat animasi mewah yang "melayang" di atas semua komponen, termasuk bilah menu, atau untuk menangkap peristiwa jika beberapa di antaranya perlu ditangani sebelum dikirim ke UI utama.

Contoh penggunaan Swing JOptionPane transparan:

// Menggunakan JOptionPane transparan import java.awt.Dimension; impor java.awt.Font; import java.awt.event.WindowEvent; import java.awt.event.WindowListener; impor javax.swing.JDialog; impor javax.swing.JFrame; import javax.swing.JLabel; import javax.swing.JOptionPane; impor javax.swing.UIManager; kelas publik JOptionPaneTest memperluas JFrame( private static final long serialVersionUID = 1L; public static final 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( Acara WindowEvent) () jendela void publikDinonaktifkan(Acara WindowEvent) () jendela void publikDeiconified(Acara WindowEvent) () jendela void publikIconified(Acara WindowEvent) () jendela void publikDibuka(Acara WindowEvent) () jendela void publikPenutupan(Acara WindowEvent) ( Objek pilihan = ( "Ya", "Tidak!" ); int rc = JOptionPane.showOptionDialog(event.getWindow(), "Tutup jendela?", "Konfirmasi", JOptionPane.YES_NO_OPTION, JOptionPane.QUESTION_MESSAGE, null, opsi, opsi) ; if (rc == 0) ( event.getWindow().setVisible(false); System.exit(0); ) ) )); JLabel label = new JLabel("Gunakan panel transparan saat menutup jendela"); bingkai. getContentPane().add(label);frame.setPreferredSize(Dimensi baru(350, 8 0)); bingkai.kemasan(); frame.setLocationRelativeTo(null); bingkai.setVisible(benar); ) 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(); ) )); ) )

Jika metode setDefaultCloseOperation dilewatkan sebuah konstanta JFrame.EXIT_ON_CLOSE, maka saat jendela ditutup, aplikasi akan berhenti bekerja. Dalam contoh, sebuah konstanta diteruskan ke metode ini JFrame.DO_NOTHING_ON_CLOSE sehingga tidak terjadi apa-apa saat jendela ditutup. Keluar dari aplikasi dalam contoh dilakukan dari pendengar JFrame WindowListener dalam metode jendelaMenutup. Saat jendela ditutup, metode windowClosing dipanggil dengan parameter kejadian WindowEvent, yang dalam Swing JOptionPane transparan membuka dialog konfirmasi.

Tangkapan layar berikut menunjukkan dua jendela aplikasi. Jendela utama atas. Menutup jendela ini akan membuka kotak dialog konfirmasi maksud yang lebih rendah.

Bilah Menu JMenuBar

Satu dari fitur penting penggunaan panel root JRootPane di Swing adalah kebutuhan untuk menempatkan bilah menu di jendela JMenuBar. Aplikasi yang serius tidak dapat dibangun tanpa semacam menu untuk mengakses fungsi program. Perpustakaan Swing menyediakan peluang bagus untuk membuat menu JMenuBar yang nyaman yang juga merupakan komponen ringan.

Bilah menu JMenuBar ditempatkan di panel berlapis di lapisan khusus FRAME_CONTENT_LAYER dan menempati ruang kecil di bagian atas jendela. Panjang bilah menu sama dengan ukuran jendela. Lebar bilah menu tergantung pada komponen yang dikandungnya.

Panel root memastikan panel konten dan bilah menu JMenuBar tidak tumpang tindih. Jika bilah menu tidak diperlukan, maka panel akar menggunakan semua ruang untuk menampung panel konten.

Contoh Ayunan

Kode sumber dari contoh yang dibahas dalam teks halaman dapat diunduh.

Peringatan

Berbeda dengan sesi sebelumnya, di mana kami pada dasarnya bertindak berdasarkan prinsip "lakukan seperti yang saya lakukan" dan berbicara tentang konsep dan detail teknis dalam apa yang disebut "dengan jari", gaya presentasi, mulai dari pelajaran ini, akan sedikit berubah dan menjadi lebih teknis.

Ini, sayangnya, tidak dapat dihindari, karena. cepat atau lambat kita harus sampai pada suatu titik, setelah itu pendekatan "dengan jari" menjadi tidak dapat dipertahankan. Sekarang saat itu akan datang. Jadi mari kumpulkan keberanian kita, singsingkan lengan baju kita dan mulai.

Pada pelajaran sebelumnya () kami membentuk dan menampilkan jendela grafik pada layar monitor dan di sepanjang jalan memecahkan beberapa masalah terkait tampilan dan lokasinya. Sekarang kita akan membahas apa yang tertinggal di balik layar.

Anda mungkin memperhatikan bahwa di awal kode sumber ada dua baris berikut:

import java.awt.*;

impor javax.swing.*;

Di sini kita perlu sedikit berlama-lama. Ingat bahwa kami sebutkan sebelumnya bahwa lingkungan pemrograman Java termasuk banyak perpustakaan yang dirancang untuk mendukung jaringan, grafik, operasi basis data, perpesanan, dll. Perpustakaan adalah apa yang memberi Java semua kekuatan dan keserbagunaan.

Di Jawa, alih-alih istilah "perpustakaan", konsep "paket" digunakan. Baris di atas hanya menghubungkan paket-paket yang diperlukan untuk membentuk antarmuka grafis. Nanti Anda akan melihat bahwa kami akan menggunakan paket lain, tetapi untuk saat ini, keduanya sudah cukup bagi kami.

Paket termasuk kelas dan antarmuka yang diperlukan (kami akan berbicara tentang antarmuka pada waktunya) yang menyediakan satu atau beberapa fungsionalitas dari aplikasi masa depan. Kehadiran tanda bintang ("*") menunjukkan bahwa pemrogram mengimpor seluruh isi paket, tanpa indikasi yang tepat kelas atau antarmuka yang dikandungnya. Tampaknya dalam kasus paket besar, kode objek yang dihasilkan mungkin terlalu besar, tetapi jangan khawatir: kompiler Java cukup "pintar" untuk hanya menggunakan apa yang benar-benar dibutuhkan oleh program Anda; semua yang tidak dibutuhkan program, kompiler tidak akan memasukkannya ke dalam kode objek. Jika Anda suka, Anda dapat menggunakan bentuk paket yang sedikit berbeda, misalnya,

import java.awt.window;

impor javax.swing.JFrame;

tetapi ini mengasumsikan bahwa pemrogram sudah memiliki pengetahuan yang baik tentang struktur dan kapabilitas paket-paket ini. Kami akan menggunakan bentuk paket penghubung yang lebih sederhana yang ditunjukkan sebelumnya.

Mengimpor (menghubungkan) paket ke program yang sedang dikembangkan dilakukan dengan kata kunci impor, setelah itu nama pergi kemasan. Setiap paket harus diimpor secara terpisah (yaitu Anda tidak dapat menulis import java.awt.*, javax.swing.*;). Tentu saja, volume kode sumber agak meningkat, tetapi sangat kecil. Semua kelas dan antarmuka yang membentuk program Anda harus ditempatkan tepat setelah konstruksi impor, jika tidak, kompiler akan menghasilkan pesan kesalahan kompilasi.

Paket pertama (dimulai dengan java.awt) terutama menyediakan interaksi program Java dengan subsistem grafis dari sistem operasi. Ingatlah bahwa Java adalah bahasa pemrograman lintas platform dan menghasilkan kode objek tunggal terlepas dari sistem operasi tempat kode ini akan dieksekusi. Oleh karena itu, Java “dipaksa” untuk mengakses sumber daya yang disediakan oleh sistem operasi yang terpasang di komputer pengguna. Salah satu sumber daya tersebut adalah grafik (selain grafik, Java memanggil "layanan" sistem operasi untuk mengakses berkas sistem dan sumber daya lainnya). Jadi, paket java.awt.* memungkinkan antarmuka grafis yang ditulis di Java untuk menggunakan kemampuan grafis dari sistem operasi dan ditampilkan ke objek grafis yang dibuat di Java. program-program Jawa, pada layar monitor. Di sini kita akan berlama-lama sedikit.

Semua komponen grafis di Java dibagi menjadi dua kategori: ringan (lightweight) dan heavyweight (kelas berat). Sebagian besar komponen grafis (tombol, daftar, pohon, label, tabel, dll.) Ringan. Ini berarti bahwa sistem operasi sama sekali tidak tahu apa-apa tentang mereka dan bahkan tidak "mencurigai" keberadaan mereka. Komponen ringan milik jendela (seperti yang kami tunjukkan di pelajaran sebelumnya) dan ditampilkan di jendela itu.

Jika kita ingin menampilkan tombol di jendela, kita hanya perlu mendefinisikannya dengan kode seperti berikut

JButton buttonPressMe = new JButton("Tekan saya");

dan letakkan di lokasi yang ditentukan di jendela (detail yang relevan akan dijelaskan nanti). Tombol adalah objek yang ringan dan sistem operasi tidak mengetahui tombol tersebut (tombol tidak ada untuk sistem operasi). Hanya jendela tempatnya berada yang "tahu" tentang tombol tersebut. Jendela menggambar tombol, mencegat peristiwa yang terjadi dengan tombol, menggambar ulang tombol jika dikaburkan oleh sesuatu, dll. Tetapi jendela itu sendiri - sistem operasi menyadarinya, dan justru karena jendela adalah komponen yang berat. Hanya jendela yang memiliki akses ke sumber daya sistem operasi (khususnya, sumber daya grafis).

Lihatlah kode sumbernya. Saat kami menghitung koordinat sudut kiri atas jendela sebelum menampilkannya di layar, kami perlu mengetahui resolusi layar

Ukuran Dimensi = Toolkit.getDefaultToolkit().getScreenSize()

Apa yang bisa memberikan informasi seperti itu? Sistem operasi dan hanya itu! Selanjutnya, kami menggunakan kode

coba(UIManager.setLookAndFeel

(UIManager.getSystemLookAndFeelClassName());

catch(Exceptionlfe)()

sehingga tampilan jendela sesuai dengan standar yang dianut di sistem operasi tertentu. Apa yang bisa memberikan informasi seperti itu? Sekali lagi - sistem operasi! Jadi, untuk membuat antarmuka grafis, kita tidak dapat melakukannya tanpa paket java.awt.*.

Saat jendela ditampilkan di layar, sistem operasi mengalokasikan sumber daya yang diperlukan ke jendela (terutama memori) dan jendela menjadi terlihat. Selanjutnya, komponen ringan ikut bermain dan keseluruhan pekerjaan selanjutnya dilakukan hampir secara eksklusif dengan mereka.

Paket impor kedua (dimulai dengan javax.swing) bertanggung jawab untuk membangun antarmuka grafis yang ringan (ada paket lain, tetapi yang ini paling penting dan hampir selalu digunakan). Kami akan mempelajari dan menguasai paket ini secara bertahap, karena. cukup besar dan cukup kompleks. Kita akan mulai melakukannya di pelajaran selanjutnya, tapi untuk saat ini, mari kita lihat baris kode sumber berikut:

kelas publik MoneyForNothing memperluas JFrame(

Dua elemen baru di sini: kata kunci extends dan kata JFrame.

Kata kunci meluas (diterjemahkan sebagai "memperluas", tetapi dekat artinya dengan kata "mewarisi" atau frasa "meminjam properti dan perilaku") mengungkapkan konsep dasar pemrograman berorientasi objek (atau, lebih sederhananya, pemrograman berbasis kelas) . Konsep ini disebut "warisan". Ini perlu disikapi dengan baik.

Ingat, di salah satu pelajaran pertama () kita membahas konsep kelas dan menggunakan mesin mobil sebagai contoh. Dengan segala variasi mesin dan desainnya (tentu saja, kita berbicara tentang mesin pembakaran internal), hampir semua mesin ini mirip satu sama lain: masing-masing memiliki silinder, piston, poros engkol, katup, dll.

Tentu saja, mesin diesel besar untuk kapal tanker tidak dapat dibandingkan dengan mesin alkohol kecil untuk model pesawat, tetapi mereka (jika boleh saya katakan) - meskipun jauh, tetapi kerabat. Mereka memiliki nenek moyang yang sama - semacam mesin abstrak, dan mesin itu sendiri adalah keturunannya (bahkan jika mereka sangat, sangat jauh).

Dalam pemrograman, leluhur seperti itu biasanya disebut "induk" atau "kelas super", mis. kelas dari mana kelas-kelas lain diturunkan. Nama superclass muncul langsung setelah extends. Jadi, diterjemahkan ke dalam bahasa biasa, potongan kode di atas dapat dibaca sebagai: "class... extends the JFrame class", "class... inherits the JFrame class", atau "class... borrow the properties and behavior of kelas JFrame". Kelas JFrame mendefinisikan properti dasar dan perilaku jendela grafik "standar". Kelas JFrame sendiri ada di paket javax.swing.*, dan itulah yang kami impor di awal program.

JFrame adalah induk (dalam terminologi Java, superclass) dari jendela grafik (ada jendela lain, seperti dialog, tetapi kita akan membicarakannya nanti). Jika Anda beralih ke dokumentasi Java, Anda akan menemukan bahwa kelas JFrame memiliki beberapa konstruktor, bidang, dan sekitar dua lusin metode yang menentukan perilaku beberapa jendela "standar". Jadi, kelas kami bernama MoneyForNothing adalah pewaris kelas JFrame (biasanya mereka tidak berbicara tentang ahli waris, tetapi tentang kelas keturunan atau anak).

Harap dicatat bahwa kelas JFrame sendiri adalah keturunan dari beberapa kelas (sebagian besar milik paket java.awt.* yang sudah dikenal):

Agar tidak kembali ke pertanyaan ini, kami menarik perhatian Anda pada fakta bahwa di bagian atas hierarki pewarisan Java terdapat kelas-kelas dari paket java.lang.*. Ini adalah satu-satunya paket dari JDK yang tidak perlu diimpor secara eksplisit - selalu diimpor secara otomatis. Dilihat dari "tangga" ini, kelas JFrame adalah cicit dari java.lang.Object (gambar di atas secara ilmiah disebut hierarki kelas).

Semua komponen antarmuka pengguna grafis (disingkat GUI, dari Antarmuka Pengguna Grafis), yang, ingat, adalah elemen ringan, harus ditempatkan di dalam jendela utama - penerus JFrame. Saat ini kami tidak memiliki komponen apa pun, tetapi komponen tersebut akan segera muncul - kami berjanji.

Dan sekarang mari kita bahas yang terakhir Kode sumber, yang terlihat seperti ini:

// Konstruktor

UangForNothing publik()(

setTitle("Selamat Datang di Uang untuk Ketiadaan");

setSize(Dimensi baru(600, 400));

Ukuran Dimensi = Toolkit.getDefaultToolkit().getScreenSize(),

fUkuran = getUkuran();

if (fUkuran.tinggi > sUkuran.tinggi) (fUkuran.tinggi = sUkuran.tinggi;)

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

setLocation((Ukuran.lebar - fUkuran.lebar)/2,

(sUkuran.tinggi - fUkuran.tinggi)/2);

setDefaultCloseOperation(EXIT_ON_CLOSE);

setVisible(benar);

Pertama-tama, kita mengatur judul jendela (metode setTitle(...)). Kemudian dimensi horizontal dan vertikal jendela diatur (metode setSize(...)). Setelah menentukan resolusi layar monitor, koordinat sudut kiri atas jendela kita dihitung dan jendela ditampilkan (metode setLocation (...)) di lokasi yang ditentukan di layar.

Setelah itu, kami menentukan apa yang harus dilakukan saat menutup jendela di menu sistem; dalam hal ini, jelas bahwa aplikasi harus menghentikan pekerjaannya (EXIT_ON_CLOSE). Di balik garis pendek dan sederhana ini sebenarnya ada dunia penanganan acara yang sangat menarik dan menggelitik. Katakanlah langsung: memahami mekanisme penanganan acara di Java adalah momen kunci dalam pengembangan aplikasi grafis, dan mulai dari pelajaran berikutnya, kita akan melakukan hal itu.

Terakhir, baris terakhir (method setVisible(true)) membuat jendela terlihat.

Tentu saja, kami tidak menghilangkan beberapa detail, tetapi tujuan kami bukan untuk menceritakan semuanya secara menyeluruh - ada dokumentasi, buku referensi, dan tutorial untuk ini. Tujuan kami adalah memberikan arahan umum, titik awal, mulai dari mana Anda (jika Anda mau dan dengan ketekunan yang cukup) akan dapat mengembangkan program Anda ke arah yang benar dan mengisinya dengan fungsionalitas yang diperlukan.

Ini menyimpulkan pelajaran kita. Hal terpenting yang harus Anda ambil darinya adalah konsep pewarisan (pinjaman). Ini memang konsep mendasar. Tanpanya, di Jawa tidak mungkin membuat kompleks dan program yang bermanfaat, jadi luangkan waktu Anda untuk melanjutkan, tetapi sekali lagi tinjau dan pertimbangkan dengan cermat semua yang telah kita pelajari sejauh ini.

Semoga berhasil dan sampai jumpa lagi!

Dalam artikel singkat ini saya ingin menjelaskan proses penciptaan program kecil mendukung GUI dalam bahasa Jawa. Diasumsikan bahwa pembaca sudah familiar dengan dasar-dasar bahasa. Jawa.

Jadi, alat apa yang kita butuhkan:

  • Mesin Virtual Java (OpenJDK atau Oracle JDK)
  • Intellij IDEA (atau IDE lain untuk Java)

Setelah instalasi perangkat lunak yang diperlukan, membuka IntelliJ IDEA dan buat proyek baru: File -> New Project…

Saya menamai proyek itu guiBase. Seperti yang Anda lihat di tangkapan layar, foldernya src tidak mengandung apa pun, jadi kami membuat di dalamnya kelas utama kami yang berisi fungsi utama.

Kelas publik Utama ( public static void main(String args) ( System.out.println("Hello, Govzalla!"); ) )

Lihat isi kelas utama di atas. Kami sekarang dapat membuat proyek ( membangun proyek ) dan jalankan ( Berlari ). Turun di terminal Anda IDE Anda akan melihat pesan Halo, Govzalla!. Tapi seperti yang Anda sendiri pahami - itu tidak mendukung GUI.

Pada tahap ini kami sudah memiliki program yang berfungsi, tetapi tanpa dukungan GUI. Dan sekarang di folder yang sama src membuat Formulir GUI: Baru -> Formulir GUI

Buka formulir GUI yang dibuat, klik jPanel dan atur pengenalnya di bidang nama bidang, Saya bertanya panel.

Kemudian seret dan lepas ke formulir di sisi kanan JTextField, JPasswordField Dan jButton:

Tetap menambahkan kode dan menautkan formulir kami ke sana. Saat kami menambahkan formulir jendela utama, kelas dibuat secara otomatis jendela utama, kelas ini adalah kelas dari bentuk yang dihasilkan, yaitu. kelas ini akan melayani semua acara dari formulir yang diberikan.

Meskipun kelas jendela kami berisi elemen yang diperlukan, tetapi bahkan sekarang ini tidak ada hubungannya dengan GUI, jadi mari kita perpanjang jFrame dan mewarisi semua fungsionalitas dasar dan perlu dari GUI .

DI DALAM saat ini kami memiliki formulir jendela utama dan kelas jendela utama diperpanjang dengan jFrame. Sekarang kita perlu mendefinisikan semua elemen GUI yang ditambahkan sebagai konten kelas jendela utama this.getContentPane().add(panel); Setelah itu, isi file MainWindow.java akan diubah seperti berikut:

Impor javax.swing.*; kelas publik MainWindow memperluas JFrame ( JTextField textField1 pribadi; JPasswordField pribadi passwordField1; tombol JButton pribadi1; panel JPanel pribadi; MainWindow publik() ( this.getContentPane().add(panel); ) )

Jika Anda mencoba menjalankan kode, Anda akan melihat pesan “Halo, Govzalla!” yang sama lagi. Masalahnya adalah kami membuat kelas dan formulir untuk itu, tetapi tidak membuat turunan dari kelas ini.

Saatnya mengubah file Main.java dan menambahkan kode untuk membuat GUI kita di sana:

Impor java.awt.*; public class Main ( public static void main(String args) ( // Buat instance dari MainWindow class MainWindow mainWindow = new MainWindow(); // Kemas semua elemen dari form mainWindow.pack(); // Ubah ukuran jendela mainWindow.setSize( new Dimension(200, 200)); // Menampilkan jendela yang dibuat mainWindow.setVisible(true); ) )

Menjalankan kode

Dengan mengklik Tombol Anda akan melihat bahwa program tidak bereaksi sama sekali. Masalahnya, kami belum menambahkan pendengar ( Pendengar) untuk acara ( Acara) dari Tombol.

pendengar acara ( pendengar acara) jButton harus menjadi implementasi adaptor ActionListener, jadi tambahkan kode berikut ke badan kelas jendela utama:

Kelas privat MyButtonListener mengimplementasikan ActionListener ( @Override public void actionPerformed(ActionEvent actionEvent) ( ) )

metode actionPerformed() akan menangani semua peristiwa tombol button1, tetapi pertama-tama Anda masih perlu memberi tahu button1 kelas apa yang akan ditanganinya, jadi tambahkan kode berikut ke konstruktor kelas MainWIndow: this.button1.addActionListener(new MyButtonListener()); Agar handler kita tidak ada artinya, tambahkan kode berikut ke dalam method actionPerformed():

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

Sekarang program akan merespons acara dengan benar, tentu saja tidak semua acara. Misalnya, jika Anda mencoba menonaktifkan program dengan mengklik tanda silang, jendela akan hilang, tetapi program akan tetap berfungsi, karena. penangan acara jendela utama tidak ditambahkan.

Kirim karya bagus Anda di basis pengetahuan itu sederhana. Gunakan formulir di bawah ini

Pelajar, mahasiswa pascasarjana, ilmuwan muda yang menggunakan basis pengetahuan dalam studi dan pekerjaan mereka akan sangat berterima kasih kepada Anda.

Diposting di http://www.allbest.ru/

PERKENALAN

Selama beberapa tahun terakhir, pengembang telah berupaya keras untuk mengintegrasikan grafik dan animasi ke dalam applet dan aplikasi Java mereka. Dengan menggunakan API java.awt dan javax.swing, pengembang dapat mengimplementasikan aplikasi grafis yang jauh lebih kompleks, termasuk game, screensaver, screensaver, dan grafik 3D. antarmuka pengguna.

Tujuan pekerjaan Perhitungan dan pekerjaan grafik dikhususkan untuk membangun aplikasi menggunakan antarmuka grafis dari pustaka java.awt dan javax.swing.

Relevansi Sampai saat ini, grafik tidak kalah pentingnya untuk bahasa pemrograman. Ini memungkinkan Anda memvisualisasikan program apa pun, yang memberikan kecerahan dan kenyamanan untuk menggunakan program tertentu. Memungkinkan Anda membuat halaman Web yang cerah dan menarik, nyaman saat mengembangkan basis data, menulis game seluler dan komputer.

1. PERUMUSAN MASALAH

Antarmuka pengguna grafis (GUI) adalah cara utama pengguna akhir berinteraksi dengan aplikasi java. Untuk pengembangan diterapkan perangkat lunak dalam bahasa Java, atau lebih tepatnya antarmuka grafis aplikasi, paket AWT dan Swing biasanya digunakan.

AWT (paket java.awt diunduh untuk akses) berisi sekumpulan kelas yang memungkinkan Anda melakukan operasi grafis dan membuat kontrol jendela, mirip dengan yang dilakukan di VBA dan Delphi;

Swing (paket javax.swing dimuat untuk akses) berisi kelas-kelas baru, sebagian besar mirip dengan AWT. J ditambahkan ke nama kelas (JButton, JLabel, dll.).

Saat ini, kelas utama untuk membangun antarmuka visual terdapat dalam paket Swing. Dari paket AWT, kelas digunakan untuk memproses pesan. Protozoa aplikasi grafis di bawah.

impor javax. mengayun.*;

kelas akhir publik HelloWorld mengimplementasikan Runnable(

public static void main(String args) (

// Swing memiliki utas pengirimannya sendiri,

//yang berjalan secara paralel dengan yang utama (di mana main() dijalankan)

//sungai kecil. Jika utas utama selesai berjalan (metode utama berakhir),

//utas yang bertanggung jawab atas pengoperasian antarmuka Swing dapat melanjutkan pekerjaannya.

//Dan bahkan jika pengguna telah menutup semua jendela, program akan terus bekerja

//(selama thread ini masih hidup). Sejak Java 6 ketika semua

// komponen dihancurkan, aliran kontrol berhenti secara otomatis.

// Jalankan semua kode yang berjalan di utas kontrol, bahkan inisialisasi:

SwingUtilities.invokeLater(new HelloWorld());

menjalankan kekosongan publik () (

// Buat jendela dengan judul "Halo, Dunia!"

Bingkai f = new JFrame("Halo, Dunia!");

// Latihan sebelumnya adalah membuat pendengar dan mendaftar

// pada instance jendela utama yang merespons windowClosing()

// paksa berhenti mesin virtual dengan memanggil System.exit()

// Sekarang ada cara yang lebih "benar" untuk mengatur reaksi penutupan jendela.

// Metode ini menghancurkan jendela saat ini, tetapi tidak menghentikan aplikasi. Tem

// aplikasi itu sendiri akan berjalan sampai semua jendela ditutup.

f.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);

// namun, Anda juga dapat mengaturnya seperti ini:

// f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

// Tambahkan komponen yang tidak dapat diedit dengan teks ke panel jendela.

// f.getContentPane().add (new JLabel("Halo, Dunia!")); - gaya lama

f.add(new JLabel("Halo Dunia"));

// pack() "mengemas" jendela ke ukuran optimal

// semua komponen yang terletak di dalamnya.

// Tampilkan jendela

f.setVisible(benar);

Swing menyediakan mekanisme untuk mengontrol aspek presentasi berikut:

Keyboard (Swing menyediakan cara untuk mencegat input pengguna)

Warna (Swing menyediakan cara untuk mengubah warna yang Anda lihat di layar)

Bidang teks untuk masukan (Swing menyediakan komponen teks untuk menangani semua tugas sehari-hari).

JComponent

Kelas dasar dari seluruh pustaka komponen visual Swing adalah JComponent. Ini adalah superclass dari komponen visual lainnya. Ini adalah kelas abstrak, jadi Anda tidak bisa benar-benar membuat JComponent, tetapi berisi ratusan fungsi yang dapat digunakan oleh setiap komponen Swing sebagai hasil dari hierarki kelas. Kelas JComponent menyediakan infrastruktur pewarnaan untuk semua komponen, ia mengetahui cara menangani semua penekanan tombol pada keyboard, oleh karena itu subkelasnya hanya perlu mendengarkan tombol tertentu. Kelas JComponent juga berisi metode add() yang memungkinkan Anda untuk menambahkan objek lain dari kelas JComponent, sehingga Anda dapat menambahkan komponen Swing apa pun ke komponen lainnya untuk membuat komponen bersarang (misalnya, JPanel yang berisi JButton, atau bahkan kombinasi yang lebih bagus , seperti JMenu yang berisi JButton ).

JLabel

Komponen visual utama yang paling sederhana dan sekaligus di perpustakaan Swing adalah JLabel, atau "label". Metode kelas ini mencakup pengaturan teks, gambar, perataan, dan komponen lain yang dijelaskan oleh label:

get/setText() - dapatkan/set teks di label;

get/setIcon() - dapatkan/set ikon di label;

get/setHorizontalAlignment - dapatkan/set posisi horizontal teks;

get/setDisplayedMnemonic() - dapatkan/set mnemonik (karakter yang digarisbawahi) untuk label;

get/setLabelFor() - dapatkan/set komponen yang dilampirkan label ini; saat pengguna menekan kombinasi tombol Alt + mnemonik, fokus berpindah ke komponen yang ditentukan.

jButton

Komponen aktif utama di Swing adalah Jbutton.

Metode yang digunakan untuk mengubah properti JButton mirip dengan JLabel (Anda akan menemukan bahwa mereka sama untuk sebagian besar komponen Swing). Mereka mengontrol teks, gambar, dan orientasi:

get/setText() - dapatkan/atur teks di tombol;

get/setIcon() - dapatkan/atur gambar di tombol;

get/setHorizontalAlignment() - dapatkan/set posisi horizontal teks;

get/setVerticalAlignment() - dapatkan/set posisi vertikal teks;

get/setDisplayedMnenomic() - dapatkan/set mnemonik (karakter yang digarisbawahi) yang, dikombinasikan dengan tombol Alt, menyebabkan tombol diklik.

jFrame

Kelas JFrame adalah wadah yang memungkinkan Anda menambahkan komponen lain ke dirinya sendiri untuk mengatur dan menyajikannya kepada pengguna.

JFrame bertindak sebagai jembatan antara bagian Swing yang tidak bergantung pada sistem operasi dan sistem operasi aktual yang dijalankannya. JFrame terdaftar sebagai jendela dan karenanya menerima banyak properti dari jendela sistem operasi: minimalisasi/maksimalisasi, pengubahan ukuran, dan pergerakan. Meskipun implementasinya Pekerjaan laboratorium cukup menganggap JFrame sebagai palet tempat Anda meletakkan komponen. Berikut adalah beberapa metode yang dapat Anda panggil pada JFrame untuk mengubah propertinya:

get/setTitle() - dapatkan/set judul frame;

get/setState() - dapatkan/set status bingkai (minimalkan, maksimalkan, dll.);

is/setVisible() - mendapatkan/mengatur visibilitas bingkai, dengan kata lain, tampilan di layar;

get/setLocation() - dapatkan/set lokasi di jendela tempat bingkai akan muncul;

get/setSize() - dapatkan/set ukuran bingkai;

add() - menambahkan komponen ke bingkai.

Skema, model, dan peristiwa

Saat membuat aplikasi visual di Java, Anda tidak bisa begitu saja menempatkannya di layar dan mengharapkannya segera bekerja. Komponen perlu ditempatkan di lokasi tertentu, bereaksi terhadap interaksi dengannya, memperbaruinya berdasarkan interaksi tersebut, dan mengisinya dengan data. Untuk kerja yang efektif dengan komponen visual, tiga komponen arsitektur Swing berikut harus dipasang.

Skema (tata letak). Swing berisi banyak skema, yaitu kelas yang mengontrol di mana komponen ditempatkan dalam aplikasi dan apa yang akan terjadi padanya saat ukuran jendela aplikasi diubah atau saat komponen dihapus atau ditambahkan.

Acara Program harus merespons penekanan tombol, klik mouse, dan semua hal lain yang dapat dilakukan pengguna.

Model (model). Untuk komponen yang lebih canggih (daftar, tabel, pohon) dan bahkan beberapa yang lebih sederhana seperti JComboBox, model adalah yang paling banyak metode efektif bekerja dengan data. Mereka menghapus banyak pekerjaan pemrosesan data dari komponen itu sendiri (pikirkan MVC) dan menyediakan pembungkus di sekitar kelas objek data umum (seperti Vector dan ArrayList).

Karena kebutuhan untuk menampilkan adegan dinamis pada komponen visual, perhatian khusus harus diberikan pada kelas Grafik 2D.

Tugas individu perhitungan dan pekerjaan grafik: Menggambar di jendela aplikasi segmen yang berputar di bidang bingkai di sekitar titik yang bergerak di sepanjang segmen.

komponen GUI java

2. IMPLEMENTASI MASALAH DALAM BAHASA TINGKAT TINGGIJAWA

import java.awt.*;

import java.awt.geom.*;

import java.awt.image.BufferedImage;

* Tugas 4. menggambarkan V jendela aplikasi (applet) segmen garis, berputar V

* pesawat bingkai sekitar poin bergerak Oleh segmen.

kelas publik LB4 memperluas java.applet.Applet mengimplementasikan Runnable(

private static final long serialVersionUID= 1L;

int pribadi w, h;

BufferedImage pribadi bi;

Graphics2D pribadi besar;

berhenti boolean pribadi = salah;

pengatur waktu Thread pribadi = null;

Warna pribadi fonColor = Warna. PUTIH;

segmen Warna pribadiWarna = Warna. ABU-ABU MUDA;

titik Warna pribadiWarna = Warna. HIJAU;

Segmen swasta;

// awal lokasi menggambar

segmen panjang ganda pribadi;

// arah bias kapak rotasi

movePoint ganda pribadi = -1;

shift ganda pribadi = 0;

speedPoint ganda pribadi = 1;

// kecepatan perubahan ketentuan V ruang angkasa

private int speedRepaint = 30;

// sudut pada yang sedang terjadi perubahan ketentuan segmen

lulusan int pribadi = 15;

/** Ini metode akan ditelepon setelah download applet */

public void init()(

// Kami membuat objek Dan Install awal nilai-nilai.

Dimensi redup = getSize();

// Kami membuat segmen, meminta panjang

lengthSegment = (ganda) Matematika. min(w, h) / 3;

segmen = Segmen baru(panjangSegmen, panjangSegmen / 2, grad,

segmentColor, pointColor, fonColor);

bi = (BufferedImage) buatGambar(w, h);

besar = bi.createGraphics();

big.setRenderingHint(RenderingHints. KEY_ANTIALIASING,

RenderingHints. VALUE_ANTIALIAS_ON);

// Kami membuat mengalir, yang akan secara berkala panggilan metode memperbarui.

timer = Utas baru (ini);

) tangkap (Pengecualian e) (

Sistem. keluar.println(e);

) // akhir init

// Ini metode melakukan menggambar ulang jendela applet

pembaruan kekosongan publik (Grafik g) (

// Kita mendapatkan penunjuk pada Sebuah Objek Graphics2D

Grafik2D g2 = (Grafik2D) g;

// Kami menggambar selesai gambar pada layar

g2.drawImage(bi, 0, 0, ini);

) tangkap (Kesalahan pengecualian) (

Sistem. keluar.println(error.getMessage());

grawSegment kekosongan pribadi() (

* //Pembersihan menggambar big.setBackground(Warna.BIRU); big.clearRect(0, 0,

// Kami menggambar segmen garis

shift += titik pindah * titik kecepatan;

jika (geser< -lengthSegment / 2) {

titik pindah *= -1;

shift = -panjangSegmen / 2;

) lain jika (shift > lengthSegment / 2) (

titik pindah *= -1;

shift = panjangSegmen / 2;

segmen.setPos(shift, speedPoint);

segmen.putar();

big.drawImage(segment.getSegment(), null, 0, 0);

// Ini metode dilakukan V memisahkan mengalir(pewaktu).

// Dia penyebab menggambar ulang jendela applet setiap beri aku waktu sebentar.

menjalankan kekosongan publik () (

benang. Utas saat ini();

benang. tidur(mengecat ulang);

) menangkap (Kesalahan pengecualian) (

// Ini metode dilakukan Jika pengguna kiri halaman

// Dengan applet. Dia berhenti mengalir(pewaktu) dan, masing-masing,

// menggambar ulang jendela applet.

penghentian kekosongan publik () (

// Metode ini dijalankan saat pengguna membuka halaman

// dengan applet. Ini memulai utas paralel (timer).

awal kekosongan publik () (

jika (pewaktu == null) (

timer = Utas baru (ini);

// Metode ini dijalankan ketika halaman yang berisi applet ditutup.

penghancuran kekosongan publik () (

super.hancurkan();

benang. Utas saat ini();

// Tunggu utas paralel (timer) selesai.

benang. menghasilkan();

) // akhiri kehancuran

) // akhiri RotatingSegment kelas publik

// buat segmen

ganda statis pribadi X = 0;

RAD ganda akhir = 10;

panjang ganda pribadi;

segmen BufferedImage pribadi;

Warna segmen warna pribadi;

titik Warna pribadiWarna;

warna latar belakang warna pribadi;

Rectangle2D pribadi.Double r;

pribadi Ellipse2D.Double p;

sumbu rotasi ganda pribadi;

pusat Point2D.Double pribadi;

shift ganda pribadi;

// sudut dimana posisi segmen berubah

intgrad pribadi;

Segmen (panjang ganda, ganda posPointRotating, int grad,

Segmen warnaWarna, Warna TitikWarna, Warna Latar BelakangWarna)

throwsException(

// periksa parameter

jika (panjang<= 0 || posPointRotating < 0 || length < posPointRotating)

lempar Pengecualian baru (

"Kesalahan: parameter tidak valid di Segmen kelas");

this.grad = grad;

this.segmentColor = segmentColor;

this.titikWarna = titikWarna;

this.backGroundColor = backGroundColor;

this.panjang = panjang;

// membuat gambar

segmen = new BufferedImage((int) panjang * 3, (int) panjang * 3,

BufferedImage. TYPE_INT_ARGB);

pusat = Point2D.Double baru (panjang, 3 * panjang / 2);

// buat segmen

rotasiAxis = center.x + posPointRotating - RAD / 2;

p = new Ellipse2D.Double(rotasiAxis, center.y, RAD, RAD);

// atur warna segmen

g2.setColor(segmentColor);

// menggambar segmen

// setel warna titik

g2.setColor(pointColor);

// menggambar titik

// menggeser titik pivot

public void setPos(double shiftX, double shiftY) (

// buat segmen

this.shift = shiftX;

center.y = center.y + shiftY * Math. dosa(Matematika. toRadians(lulusan * X));

r = Rectangle2D.Double baru (pusat.x, pusat.y, panjang, RAD);

p = new Ellipse2D.Double(rotasiAxis + shift, center.y, RAD, RAD);

// memutar segmen

putar kekosongan publik () (

AffineTransform di = AffineTransform. getRotateInstance(

Matematika. toRadians(lulusan * (++ X)), sumbu rotasi + RAD / 2 + shift,

// dapatkan konteks grafik

Graphics2D g2 = segment.createGraphics();

// cat semuanya dengan warna yang diberikan

g2.setBackground(backGroundColor);

g2.clearRect(0, 0, (int) (3 * panjang), (int) (3 * panjang));

g2.setTransform(at);

g2.setColor(segmentColor);

// menggambar segmen

// setel warna titik

g2.setColor(pointColor);

// menggambar titik

// Mengembalikan gambar

publik BufferedImage getSegment() (

3. CONTOH OPERASI PROGRAM

Hasil dari eksekusi program:

Gambar 1. Hasil eksekusi program

Gambar 2. Hasil eksekusi program

Gambar 3. Hasil eksekusi program

KESIMPULAN

Ini menyimpulkan diskusi kita tentang grafis di Jawa. Dalam makalah ini, kami telah menyajikan gambaran singkat alat pemrograman grafis 2D di Jawa. Kami telah menyajikan aplikasi yang mendemonstrasikan penggunaan bentuk geometris, tekstur.

Kami telah membahas beberapa fitur grafis dari Java. Kami mulai dengan pengantar singkat tentang dasar-dasar grafik, seperti sistem koordinat dan konteks grafik. Kami kemudian membahas fasilitas Java 2D. Kami juga membahas secara singkat cara menggunakan efek grafis.

Paruh kedua pengantar kami untuk pemrograman grafis di Jawa. Menggunakan antarmuka grafis dari pustaka java.awt dan javax.swing, kami telah membuat editor grafis sederhana yang memutar objek dua dimensi di sekitar porosnya.

BIBLIOGRAFI

1. H.M. Deitel, P.J. Deitel, S.I. Suntry - Teknologi Pemrograman Java, Buku 1 (grafik, JAVABEANS, antarmuka pengguna)

2. Judy Bishop - Mengerjakan Java Secara Efisien

3. James Gosling, Bill Joy, Guy Steele, Gilad Bracha - Spesifikasi Bahasa Jawa, Edisi Kedua.

4. Tim Lindholm, Frank Yellin - Spesifikasi Java Virtual Machine, Edisi Kedua.

5. Gosling J., Arnold K. - bahasa pemrograman Java

6. Informasi dari www.ibm.com

7. Informasi dari situs www.mexmat.sgu.ru

8. Informasi dari situs www.uic.rsu.ru

Dihosting di Allbest.ru

...

Dokumen Serupa

    Struktur organisasi GUI, mendeklarasikan dan membuat pendengar acara menggunakan kelas anonim. Representasi data untuk tabel adalah kelas AbstractTableModel. Visualisasi sel tabel. Dua tipe utama aliran I/O di Java.

    kuliah, ditambahkan 05/01/2014

    Pengembangan editor grafis untuk menggambar grafik dua dimensi dan tiga dimensi menggunakan bahasa pemrograman Java dan antarmuka pemrograman aplikasi Java 2D dan Java 3D. Membuat editor grafis 3D Paint. Metode utama dari kelas Grafik.

    makalah, ditambahkan 11/19/2009

    Deskripsi Paket Aplikasi Net Beans 8.1. Pengembangan antarmuka pengguna applet. Pembuatan bingkai jendela berdasarkan bingkai pustaka java.swing. Mengubah warna data teks. Merancang dan membuat model infologis dari applet.

    pekerjaan kontrol, ditambahkan 07/11/2016

    Kemungkinan jaringan bahasa pemrograman. Manfaat menggunakan applet Java. Kelas termasuk dalam perpustakaan java.awt. Pembuatan antarmuka pengguna. Koneksi soket ke server. Grafik di Jawa. Nilai komponen warna.

    makalah, ditambahkan 11/10/2014

    Kelas Java Foundation, konsep dasar. Hirarki kelas Toolkit Jendela Abstrak asli. Perwakilan antarmuka pengguna. Penanganan acara di JavaBeans. Kontrol, bidang multiline JText. Daftar program TextEditor.

    makalah, ditambahkan 06/26/2013

    Eksekusi program Java. Satu set program dan kelas JDK. Pemrograman berorientasi objek di Java. Prinsip membangun antarmuka grafis. Komponen dan wadah sistem grafis. Applet adalah program yang berjalan di lingkungan browser.

    makalah, ditambahkan 02/08/2011

    Diagram aplikasi konsol tabulasi fungsi. Perbedaan antara aplikasi konsol dan aplikasi dan GUI. Diagram kelas untuk JFrame dan JPanel. Membuat bingkai sederhana di Jawa. Tata letak elemen antarmuka dalam bingkai. Putaran acara.

    kuliah, ditambahkan 05/01/2014

    Konsep dan karakteristik umum bahasa pemrograman PHP, prinsip dan tahapan kerjanya, sintaks, dan array terkait. Penanganan Pengecualian di Jawa. Bekerja dengan database menggunakan JDBC. Mempelajari cara mengembangkan antarmuka grafis.

    presentasi, ditambahkan 13/06/2014

    Pengembangan skema logis untuk database perusahaan manufaktur mobil. Pemodelan sistem infologi. Membuat antarmuka pengguna grafis untuk database menggunakan bahasa pemrograman Java. Pengujian perangkat lunak.

    makalah, ditambahkan 12/16/2013

    Pembuatan aplikasi konsol menggunakan antarmuka pengguna grafis. Isi palet komponen dari program C++ Builder. Menggunakan kemungkinan pemrograman berorientasi objek, fitur editor kode, dan formulir di C ++.



Memuat...
Atas