Dalam artikel singkat ini saya ingin menjelaskan proses pembuatan program kecil yang mendukung GUI dalam bahasa tersebut 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 menginstal perangkat lunak yang diperlukan, buka 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, bahkan sekarang 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.

Davydov Anton Valerevich
Mahasiswa TSU, Rusia, Tolyatti
Penasihat ilmiah: Erofeeva E.A.

Antarmuka pengguna di Jawa telah melalui jalur pembentukan dan pengembangan yang sangat sulit. Miliknya untuk waktu yang lama dituduh rakus akan sumber daya sistem, kerja lambat dan fungsi terbatas. Munculnya .NET dengan komponen grafis yang lebih cepat semakin mengguncang posisi Java. Tetapi persaingan seperti itu hanya mendorong pengembang Java untuk mengembangkan dan meningkatkan pustaka grafis. Dan dalam artikel ini kita akan melihat apa hasilnya.

Toolkit Jendela Abstrak

Toolkit Jendela Abstrak (disingkat AWT) pertama kali dirilis pada tahun 1995 oleh Sun Microsystems. Itu adalah upaya pertama untuk membuat GUI untuk Java. AWT bertindak sebagai lapisan yang memanggil metode dari perpustakaan yang ditulis dalam C. Dan metode ini, pada gilirannya, menggunakan komponen grafis sistem operasi. Di satu sisi, program yang dibuat dengan cara ini terlihat mirip dengan semua program lain di sistem operasi yang digunakan, tetapi di sisi lain, program yang sama dapat terlihat sangat berbeda di sistem operasi yang berbeda, yang mempersulit pengembangan. Selain itu, demi multiplatform, antarmuka panggilan komponen perlu disatukan, yang menyebabkan fungsionalitas agak terpotong. Kumpulan komponennya juga cukup sederhana. Misalnya, tidak ada tabel, dan ikon tidak dapat ditempatkan di tombol. AWT mencoba melepaskan sumber daya yang digunakan secara otomatis. Ini memengaruhi kinerja dan memperumit arsitektur. AWT mudah dipelajari, tetapi menulis sesuatu yang rumit itu sulit. Sekarang AWT terutama digunakan untuk applet. Oracle saat ini mendorong pengembang untuk beralih ke Swing karena lebih aman.

Gbr.1 - Contoh program yang ditulis menggunakan AWT di lingkungan Windows

Setelah AWT, pada tahun 1998, Sun merilis Swing. Itu ditulis seluruhnya dalam Java dan menggunakan 2D untuk rendering. Swing memiliki variasi komponen yang jauh lebih luas daripada AWT. Komponen itu sendiri menjadi lebih mudah dibuat dengan mewarisi dari yang sudah ada. Kemampuan untuk menggunakan gaya dan skin yang berbeda juga diperkenalkan. Namun, kecepatan kerjanya versi awal Swing cukup rendah, dan kesalahan dalam menulis program bahkan dapat menyebabkan pembekuan sistem operasi.

Namun, karena kemudahan belajar dan ketersediaan jumlah yang besar dokumentasi, Swing telah menjadi GUI paling populer di Jawa. Berdasarkan itu, banyak ekstensi telah muncul, seperti SwingX dan JGoodies, yang membuatnya lebih mudah untuk membuat aplikasi yang kompleks secara visual. Semua lingkungan pemrograman Java modern termasuk editor grafis Mengayun. Meskipun ada kerangka kerja yang lebih modern sekarang, Swing tetap yang paling populer.

Gambar 2 - Contoh program yang ditulis menggunakan Swing

Toolkit Widget Standar

SWT dirilis oleh IBM pada saat Swing masih lambat, dan terutama untuk mempromosikan lingkungan pemrograman Eclipse. Seperti AWT, SWT menggunakan komponen OS, tetapi antarmuka interoperabilitas yang berbeda digunakan untuk platform yang berbeda. Dengan demikian, perpustakaan JAR yang terpisah harus dikirimkan untuk setiap sistem operasi. Ini memungkinkan Anda untuk lebih menggunakan fungsi yang sesuai dengan sistem operasi yang berbeda. Dan komponen yang hilang diimplementasikan menggunakan 2D. Namun, SWT ternyata lebih sulit dikuasai daripada Swing. Selain itu, programmer sendiri harus mengimplementasikan pelepasan sumber daya oleh aplikasi.

Gbr.3 - Contoh program yang ditulis menggunakan Swing

JavaFX dirilis pada tahun 2008 oleh Oracle. Itu diposisikan sebagai platform untuk membuat aplikasi Internet yang kaya. Untuk rendering, pipa grafis digunakan, yang mempercepat aplikasi secara signifikan. Ada satu set besar komponen bawaan. Ada juga komponen terpisah untuk memplot grafik. Dukungan yang diterapkan untuk konten multimedia, animasi, dan bahkan multi-sentuh. Penampilan komponen dikonfigurasi menggunakan gaya CSS. Selain itu, kumpulan utilitas JavaFX menyertakan kemampuan untuk membuat penginstal asli untuk platform paling populer: exe atau msi untuk Windows, deb atau rpm untuk Linux, dmg untuk Mac. Situs web Oracle memiliki dokumentasi terperinci dan sejumlah besar contoh siap pakai.

Jadi, setelah menjelaskan fitur dan kerugian utama dari antarmuka pengguna grafis di atas, kami dapat memutuskan tugas mana yang paling cocok untuk mereka. Toolkit Jendela Abstrak lebih cocok untuk membuat applet. Seorang pemula dapat merekomendasikan Swing mengingat fakta bahwa Anda dapat menemukan banyak sekali dokumentasi untuknya di Internet, termasuk dalam bahasa Rusia. JavaFX sangat bagus untuk membangun aplikasi internet yang kaya.

Daftar sumber yang digunakan

Ryzhenko A.V. Pemrograman berorientasi objek: Kompleks pendidikan dan metodologi untuk disiplin khusus 010501 - "Matematika Terapan dan Informatika". – 2007.

Khabibullin I.Sh.Java 7 (edisi ke-4). - BHV-Petersburg, 2012.

Clarke J., Connors J., Bruno E.J. JavaFX: Mengembangkan Aplikasi Internet yang Kaya. – Pendidikan Pearson, 2009.

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

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. Kit komponen standar secara signifikan melampaui AWT dalam 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 antarmuka grafis untuk suatu aplikasi, Anda perlu menggunakan komponen khusus dari pustaka Swing, yang disebut wadah. 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 seperti pada wadah tingkat atas yang sebenarnya.

Panel Berlapis JLayeredPane

Di dasar panel akar (wadah) terdapat apa yang disebut panel berlapis JLayeredPane menempati semua ruang yang tersedia 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. Fungsi terpenting dari aplikasi multi-dokumen - memposisikan jendela "aktif" di atas yang lain, meminimalkan jendela, menyeretnya - disediakan oleh mekanisme panel berlapis. 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 memungkinkan Anda menyediakannya pekerjaan yang benar semua mekanisme panel multilayer. Lapisan JLayeredPane standar ditunjukkan pada gambar berikut.

Lapisan Default digunakan untuk menampung semua komponen konvensional, 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. Ditujukan untuk operasi seret dan lepas ( seret dan lepas drop), yang seharusnya 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; private Warna warna; tipe int pribadi; teks String pribadi; // parameter: warna dan tipe gambar Gambar(Warna warna, tipe int, Teks string) ( this.color = color; this.type = type; this.text = text; setOpaque(false); ) public void paintComponent(Graphics g ) ( // menggambar bentuk 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 memperluas JFrame ( private static final long serialVersionUID = 1L; public JLayeredPaneTest() ( // buat a window super("Example LayeredTest"); // keluar saat jendela ditutup setDefaultCloseOperation(EXIT_ON_CLOSE); // definisi panel berlapis JLayeredPane lp = getLayeredPane(); // membuat tiga bentuk Gambar gambar1 = Gambar baru(Warna.merah , 0, "Popup gambar"); Gambar gambar2 = Gambar baru(Warna.biru, 0, "Gambar 1"); Gambar gambar3 = Gambar baru(Warna.cyan, 1, "Gambar 2"); // temukan bentuk 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.

DI DALAM aplikasi umum panel multi-layer jarang digunakan secara langsung, di dalamnya ia menjalankan fungsinya tanpa disadari. Namun, kadang-kadang membantu membuat efek luar biasa dan antarmuka yang tidak biasa, 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 tidak akan 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 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) ( Object options = ( "Yes", "No!" ); int rc = JOptionPane.showOptionDialog(event.getWindow(), "Tutup jendela?", "Konfirmasi", JOptionPane.YES_NO_OPTION, JOptionPane.QUESTION_MESSAGE, null, opsi, opsi); (false);System.exit(0); ) ) )) ; JLabel label = new JLabel("Gunakan panel transparan saat menutup jendela"); frame.getContentPane().add(label); frame.setPreferredSize(Dimensi baru(350, 80)); 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

Salah satu fitur penting menggunakan 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. Pustaka Swing menyediakan fasilitas luar biasa untuk membuat JMenuBars 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.

Kami kira kami membuat Anda lelah dengan berbicara sepanjang waktu tentang program inferensi. pesan teks ke konsol. Dalam pelajaran ini, rangkaian contoh "suram" ini akhirnya akan disela: kami akan menunjukkan bagaimana windows dibuat di Java dan Anda akan melihat bahwa ini adalah tugas yang mudah. Ini kode kita (kita akan mulai membahasnya di pelajaran berikutnya, karena kode ini memiliki banyak sekali fitur yang benar-benar perlu Anda ketahui):

import java.awt.*;

impor javax.swing.*;

kelas publik MoneyForNothing memperluas JFrame(

// Konstruktor

UangForNothing publik()(

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

setSize(Dimensi baru(600, 400));

setDefaultCloseOperation(EXIT_ON_CLOSE);

setVisible(benar);

public static void main(String args)(

MoneyForNothing mfn = new MoneyForNothing();

Dan ini kode yang sama di jendela pengeditan FAR:

Omong-omong, kami menyarankan Anda segera mengetik kode sumber program dalam pengkodean CP1251 (atau dalam bahasa umum, dalam pengkodean Windows): pengalihan pengkodean dilakukan dengan menekan F8, dan pengkodean saat ini ditampilkan di bilah status di atas bidang penyuntingan.

Titik masuknya tetap tidak berubah, tetapi kode lainnya telah berubah secara berurutan (tetapi kami tidak akan terlalu terburu-buru). Setelah dikompilasi dan dijalankan, Anda akan melihat yang berikut:

Selamat - hanya dalam beberapa baris Anda telah membuat jendela grafik nyata! Itu dapat diseret, diubah ukurannya, diciutkan, diperluas dan ditutup. Benar, jendela kami ternyata entah bagaimana pudar, terus terang - "jelek". Selain itu, jendela ditampilkan di sudut kiri atas layar, tetapi saya ingin berada di tengah - lebih nyaman menggunakannya di sana, dan keluaran seperti itu terlihat lebih bagus. Jadi mari kita lakukan sedikit "pemolesan".

Pertama, mari selesaikan masalah kedua - pemusatan jendela. Di sini kami menyarankan untuk berhenti dan berpikir - bagaimana Anda melakukannya?

Katakanlah pustaka grafik Java memiliki metode setLocation, yang menerima koordinat sudut kiri atas jendela sebagai parameter (dari sudut inilah elemen grafik lain ditempatkan di dalam jendela). Tetapi jika Anda menyetel parameter ini "di dahi", maka hampir pasti tidak ada hal baik yang akan terjadi. pada monitor lain dengan resolusi berbeda, jendela tidak akan berada di tempat yang Anda harapkan. Oleh karena itu, koordinat perlu diatur lebih cerdas.

Semua yang diperlukan untuk memusatkan jendela adalah mengetahui ukuran jendela itu sendiri (omong-omong, mereka diatur dalam konstruktor dan membentuk persegi panjang berukuran 600 kali 400 piksel) dan resolusi layar, dan kemudian, menggunakan aritmatika sederhana , hitung koordinat sudut kiri atas yang diperlukan. Ini dicapai dengan menempatkan kode berikut

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);

tepat setelah baris setSize (Dimensi baru (600, 400)); dalam konstruktor. Buat perubahan yang diperlukan pada kode sumber, kompilasi program dan jalankan untuk dieksekusi; jendela akan muncul di tengah layar monitor.

Sekarang beberapa kata tentang tampilan jendela. Penampilannya yang aneh dijelaskan oleh fakta bahwa pengembang Java berusaha untuk memastikan bahwa, terlepas dari platform perangkat keras dan "pengisian" perangkat lunak, semua elemen grafis (jendela, tombol, daftar, dll.) Memiliki rendering tunggal dan skema warna tunggal. Untuk melakukan ini, mereka mengembangkan gaya khusus, yang mereka sebut "METAL". Jika pengembang tidak mengambil upaya khusus, maka elemen antarmuka grafis dalam programnya akan terlihat persis dengan gaya ini, tanpa memperhitungkan fitur komputer tertentu dan perangkat lunak. Dalam beberapa kasus, ini masuk akal, tetapi tetap saja, Anda harus setuju bahwa jauh lebih baik jika program yang berjalan di Windows terlihat seperti program windows, dan berjalan di LINUX terlihat seperti program linux. Ini mudah dicapai. Yang diperlukan hanyalah menyertakan kode berikut di titik masuk, sebelum membuat instance kelas:

coba(UIManager.setLookAndFeel

(UIManager.getSystemLookAndFeelClassName());

catch(Exceptionlfe)()

Ini adalah bagaimana kita akan melakukannya. Sekarang, setelah mengkompilasi versi terbaru dari program kami dan menjalankannya untuk dieksekusi, jendela grafik akan terlihat lebih "layak":

Tergantung pada pengaturan properti tampilan monitor Anda, tampilan jendela akan berbeda; kami menggunakan klasik Tema jendela xp. Jendela Anda mungkin terlihat seperti ini:

Pastikan semuanya berfungsi seperti yang diharapkan: jendela ditampilkan di tengah layar dan tampilannya seperti yang diharapkan.

Ini menyimpulkan pelajaran pertama kami tentang GUI. Di dalamnya, kami menunjukkan "fasad", tetapi benar-benar meninggalkan "berlebihan" banyak masalah yang sangat penting dan tanpanya pemrograman di Java pada umumnya dan antarmuka grafis pada khususnya tidak mungkin dilakukan. Kami akan mulai menangani masalah ini di pelajaran berikutnya, tetapi untuk saat ini, bermain-mainlah dengan kode sumber yang Anda miliki.

Sebagai latihan, hitung, misalnya, koordinat keluaran jendela kita di pojok kanan bawah layar dan periksa hasilnya.

Latihan lain lebih sederhana, tetapi Anda perlu menggunakan dokumentasi (Anda benar-benar harus memulai dari suatu tempat): buat agar Anda tidak dapat mengubah ukuran jendela, mis. ke daerah tombol sistem tampak seperti gambar

(petunjuk: cari informasi tentang kata kunci javax dan JFrame). Jadi singsingkan lengan baju Anda dan semoga berhasil!

Komentar

Mungkin saja jendela yang dibuat tidak terlihat seluruhnya atau sebagian (karena Anda salah menghitung koordinat tampilannya di layar). Tombol kontrol jendela mungkin juga tidak tersedia. Bagaimana cara menghentikan aplikasi tanpa menghapus tugas di "Task Manager" atau memulai ulang komputer?

Karena kami meluncurkan program untuk dieksekusi dari FAR, menghentikan eksekusi program Java dilakukan dengan menekan kombinasi tombol Control-C (di sini "C" adalah huruf Latin, jangan bingung dengan huruf Cyrillic yang serupa).