What is Swing?
Java Swing is a lightweight Graphical User Interface (GUI) toolkit that includes a rich set of widgets. It includes package lets you make GUI components for your Java applications, and It is platform independent.
The Swing library is built on top of the Java Abstract Widget Toolkit (AWT ), an older, platform dependent GUI toolkit. You can use the Java GUI components like button, textbox, etc. from the library and do not have to create the components from scratch.
In this tutorial, you will learn-
Java Swing class Hierarchy DiagramAll components in swing are JComponent which can be added to container classes.
Container classes are classes that can have other components on it. So for creating a GUI, we need at least one container object. There are 3 types of containers.
Example
: To learn to design GUI in Java
Step 1)
Copy the following code into an editor
Import javax.swing.*; class gui{ public static void main(String args){ JFrame frame = new JFrame("My First GUI"); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); frame.setSize(300,300); JButton button = new JButton("Press"); frame.getContentPane().add(button); // Adds Button to content pane of frame frame.setVisible(true); } }
Step 2)
Save, Compile, and Run the code.
Step 3)
Now let"s Add a Button to our frame. Copy following code into an editor
Import javax.swing.*; class gui{ public static void main(String args){ JFrame frame = new JFrame("My First GUI"); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); frame.setSize(300,300); JButton button1 = new JButton("Press"); frame.getContentPane().add(button1); frame.setVisible(true); } }
Step 4) Execute the code. You will get a big button
Step 5) How about adding two buttons? Copy the following code into an editor.
Import javax.swing.*; class gui{ public static void main(String args){ JFrame frame = new JFrame("My First GUI"); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); frame.setSize(300,300); JButton button1 = new JButton("Button 1"); JButton button2 = new JButton("Button 2"); frame.getContentPane().add(button1); frame.getContentPane().add(button2); frame.setVisible(true); } }
Step 6)
Save , Compile , and Run the program.
Step 7)
Unexpected output =? Buttons are getting overlapped.
The Layout manager is used to layout (or arrange) the GUI java components inside a container.There are many layout managers, but the most frequently used are-
It is the more sophisticated of all layouts. It aligns components by placing them within a grid of cells, allowing components to span more than one cell.
Step 8) How about creating a chat frame like below?
Try to code yourself before looking at the program below.
//Usually you will require both swing and awt packages // even if you are working with just swings. import javax.swing.*; import java.awt.*; class gui { public static void main(String args) { //Creating the Frame JFrame frame = new JFrame("Chat Frame"); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); frame.setSize(400, 400); //Creating the MenuBar and adding components JMenuBar mb = new JMenuBar(); JMenu m1 = new JMenu("FILE"); JMenu m2 = new JMenu("Help"); mb.add(m1); mb.add(m2); JMenuItem m11 = new JMenuItem("Open"); JMenuItem m22 = new JMenuItem("Save as"); m1.add(m11); m1.add(m22); //Creating the panel at bottom and adding components JPanel panel = new JPanel(); // the panel is not visible in output JLabel label = new JLabel("Enter Text"); JTextField tf = new JTextField(10); // accepts upto 10 characters JButton send = new JButton("Send"); JButton reset = new JButton("Reset"); panel.add(label); // Components Added using Flow Layout panel.add(label); // Components Added using Flow Layout panel.add(tf); panel.add(send); panel.add(reset); // Text Area at the Center JTextArea ta = new JTextArea(); //Adding Components to the frame. frame.getContentPane().add(BorderLayout.SOUTH, panel); frame.getContentPane().add(BorderLayout.NORTH, mb); frame.getContentPane().add(BorderLayout.CENTER, ta); frame.setVisible(true); } }
В некоторых ситуациях, в процессе разработки программного обеспечения, возникает необходимость, когда разным группам программистов надо «договориться» о том, как их программы будут взаимодействовать. Каждая группа должна иметь возможность писать свой код не зависимо от того, как пишет его другая группа. Интерфейсы и есть этот «договор». Мы уже пользовались интерфейсами в уроке .
В этом уроке мы изучим их подробнее: для чего они нужны, как их объявлять и т.д.
Представьте себе будущее, где автомобилями управляют компьютеры без участия человека. Производители автомобилей пишут программное обеспечение (на Java, конечно 🙂), которое управляет машиной — остановиться, поехать, повернуть и т.д. Другие разработчики делают системы, которые принимают данные GPS (Global Positioning System) и используют эти данные для управления автомобилем. Производители автомобилей публикуют интерфейс-стандарт, который описывает методы для управления машиной. Таким образом сторонние разработчики могут знать какие методы вызывать, чтобы заставить автомобиль двигаться, а производители автомобилей могут изменять внутреннюю реализацию своего продукта в любое время. Ни одна из групп разработчиков не знает как написаны их программы.
Интерфейсы в Java во многом напоминают классы, но могут содержать только константы, сигнатуры методов и . В интерфейсах нет описания методов. Нельзя создать объект типа интерфейса (но можно использовать в качестве типа — интерфейсные ссылки, об этом позже) — интерфейсы могут только реализовываться некоторым классом или наследоваться другим интерфейсом. Объявление интерфейса очень похоже на объявление класса:
Public interface OperateCar { // константы, если есть // enum перечисление направлений RIGHT, LEFT // сигнатуры методов int turn(Direction direction, double radius, double startSpeed, double endSpeed); int changeLanes(Direction direction, double startSpeed, double endSpeed); int signalTurn(Direction direction, boolean signalOn); int getRadarFront(double distanceToCar, double speedOfCar); int getRadarRear(double distanceToCar, double speedOfCar); }
Сигнатуры методов объявляются без скобок и заканчиваются точкой с запятой. Для использования интерфейса вы должны написать класс, который будет реализовывать ваш интерфейс. Класс который реализует интерфейс, должен описывать все методы, объявленные в интерфейсе. Например:
Public class OperateBMW760i implements OperateCar { // здесь методы интерфейса OperateCar с описанием // например: int signalTurn(Direction direction, boolean signalOn) { // поворот RIGHT или LEFT поворотник on или off } }
В примере выше — производители автомобилей пишут программное обеспечение каждый по-своему, но с одинаковым интерфейсом. Сторонние разработчики — клиенты интерфейса, могут писать собственно ПО с использованием методов, объявленных в интерфейсе.
Пример с автомобилями показывает как интерфейсы могут использоваться в качестве API (Application Programming Interface ) или интерфейса программирования приложений. Использование API — обычная практика при разработке коммерческого ПО. Обычно компании-разработчики продают программное обеспечение, содержащее набор методов, которые другие компании хотят использовать в своих продуктах.
Интерфейсы играют еще одну важную роль в языке программировния Java. Java не разрешает множественного наследования, но интерфейсы предоставляют альтернативу. В Java класс может наследовать только один класс, но может реализовывать много интерфейсов. Таким образом объекты могут иметь несколько типов: тип их собственного класса и типы всех реализуемых интерфейсов. При создании объектов класса в качестве типа может указываться имя реализованного в классе интерфейса. Другими словами, если класс реализует интерфейс, то на объект этого класса можно присвоить интерфейсной переменной — переменной, в качестве типа которой указано имя соответствующего интерфейса.
Объявление интерфейса содержит ключевое слово interface , имя интерфейса, список родительских интерфейсов через запятую (если есть) и тело интерфейса. Например:
Public interface GroupedInterface extends Interface1, Interface2, Interface3 { // число e double E = 2.718282; // сигнатуры методов void doSomething (int i, double x); int doSomethingElse(String s); }
Модификатор доступа public означает что интерфейс может быть использован любым классом в любом пакете. Если не определить интерфейс как публичный, он будет доступен только в рамках своего пакета. Интерфейс может наследовать другие интерфейсы, как классы могут наследовать другой класс. В отличие от классов, интерфейсы могут наследовать любое количество других интерфейсов.
Для объявления класса, реализующего интерфейс, вы должны использовать ключевое слово implements после которого перечисляются интерфейсы.
Класс может реализовывать много интерфейсов. Объявление реализуемых интерфейсов идет после объявления наследуемого (extends) класса (если есть).
Рассмотрим интерфейс, который определяет метод для сравнения объектов.
Public interface Relatable { // this (объект, который вызывает isLargerThan) // объект-параметр должен быть того же класса // возвращет 1, 0, -1 // если объект больше, равен или // меньше чем other public int isLargerThan(Relatable other); }
Чтобы иметь возможность сравнивать объекты мы должны реализовать интерфейс Relatable . Любой класс может реализовать интерфейс Relatable , если есть способ сравнить объекты. Для строк сравнивать можно количество символов, для книг — количество страниц, для студентов — вес и т.д. Для плоских геометрических фигур отличной характеристикой будет площадь, для трехмерных — объем. Все эти классы могут реализовать метод isLargerThan() . Если вы знаете, что класс реализует интерфейс Relatable , то вы смело можете сравнивать объекты этого класса.
Напишем класс Rectangle , реализующий интерфейс Relatable .
Public class RectanglePlus implements Relatable { public int width = 0; public int height = 0; public Point origin; // четыре конструктора public RectanglePlus() { origin = new Point(0, 0); } public RectanglePlus(Point p) { origin = p; } public RectanglePlus(int w, int h) { origin = new Point(0, 0); width = w; height = h; } public RectanglePlus(Point p, int w, int h) { origin = p; width = w; height = h; } // метод для передвижения прямоугольника public void move(int x, int y) { origin.x = x; origin.y = y; } // вычисление площади public int getArea() { return width * height; } // метод для реализации интерфейса Relatable public int isLargerThan(Relatable other) { RectanglePlus otherRect = (RectanglePlus)other; if (this.getArea() < otherRect.getArea()) return -1; else if (this.getArea() > otherRect.getArea()) return 1; else return 0; } }
Так как класс RectanglePlus реализует Relatable , размеры любых двух объектов типа RectanglePlus можно сравнивать.
Метод isLargerThan в качестве аргумента принимает объекты типа Relatable . При реализации метода в примере выше мы используем приведение типов, потому что компилятор не поймет что, other — объект типа RectanglePlus и вызов метода other.getArea() без приведения типов приведет к ошибке.
Когда вы объявляете интерфейс, вы объявляете новый ссылочный тип данных. Вы можете использовать название интерфейса в качестве типа данных так же как и любые другие типы. Если вы объявляете переменную типа интерфеса, то вы можете можете присвоить ей объект любого класса, который реализует этот интерфейс.
Рассмотрим пример — метод, который ищет больший объект из двух любых объектов, класс которых реализует интерфейс Relatable:
Public Object findLargest(Object object1, Object object2) { Relatable obj1 = (Relatable)object1; Relatable obj2 = (Relatable)object2; if ((obj1).isLargerThan(obj2) > 0) return object1; else return object2; }
Приведением object1 к типу Relatable , мы делаем возможным вызов метода isLargerThan .
Так же для любого класса, реализующего интерфес Relatable, можно реализвать методы:
Public Object findSmallest(Object object1, Object object2) { Relatable obj1 = (Relatable)object1; Relatable obj2 = (Relatable)object2; if ((obj1).isLargerThan(obj2) < 0) return object1; else return object2; } public boolean isEqual(Object object1, Object object2) { Relatable obj1 = (Relatable)object1; Relatable obj2 = (Relatable)object2; if ((obj1).isLargerThan(obj2) == 0) return true; else return false; }
Допустим, вы написали интерфейс DoIt:
Public interface DoIt { void doSomething(int i, double x); int doSomethingElse(String s); }
Предположим, позже, вы захотели добавить в него третий метод:
Public interface DoIt { void doSomething(int i, double x); int doSomethingElse(String s); boolean didItWork(int i, double x, String s); }
Если вы сделаете это изменение, то все классы, реализующие этот интерфейс сломаются, т.к. они перестанут его реализовывать.
Старайтесь избегать подобных изменений и продумывать интерфейс полностью изначально. Но часто на практике это невозможно и выходом из этой ситуации может быть определение нового интерфейса DoItPlus , который расширяет DoIt:
Public interface DoItPlus extends DoIt { boolean didItWork(int i, double x, String s); }
Теперь пользователи вашего интерфейса смогут перейти к использованию нового интерфейса или остаться со старым без боли.
В Java есть 2 основных пакета для создания графических интерфейсов (Graphics User Interface). Это Abstract Windows Toolkit (AWT) и Swing. AWT использует виджеты операционной системы, поэтому эта библиотека немного быстрее. Но на мой взгляд, Swing более хорошо спроектирован.
В данном туториале мы рассмотрим основные элементы библиотеки Swing и создадим простой интерфейс (GUI) в качестве примера.
Для группировки компонент интерфейса используются контейнеры (Container). Для создания основного контейнера для приложения чаще всего используется контейнер JFrame (есть еще JWindows и JApplet). Проще всего унаследоваться от JFrame тем самым получить доступ ко множеству методов, например:
setBounds(x, y, w, h) - указывает координаты верхней левой вершины окна, а также его ширину и высоту.
setResizable(bool) - указывает, можно ли изменять размер окна.
setTitle(str) - устанавливает название окна.
setVisible(bool) - собственно отображает окно.
setDefaultCloseOperation(operation) - указывает операцию, которая будет произведена при закрытии окна.
Основные элементы управления:
Как видите, все довольно просто и логично.
При отображении элементов управления используются специальные менеджеры - LayoutManager. У всех LayoutManager"ов есть методы для добавления у удаления элементов.
FlowLayout - используется для последовательного отображения элементов. Если элемент не помещается в конкретную строку, он отображается в следующей.
GridLayout - отображения элементов в виде таблицы с одинаковыми размерами ячеек.
BorderLayout - используется при отображении не более 5 элементов. Эти элементы располагаются по краям фрейма и в ценрте: North, South, East, West, Center.
BoxLayout - отображает элементы в виде рядка или колонки.
GridBagLayout - позволяет назначать месторасположение и размер каждого виджета. Это самый сложный, но и самый эффективный вид отображения.
Стоит еще обратить внимание на обработку событий. Для этого используются так называемые Event Listeners.
Ну все, довольно теории, перейдем к примеру GUI:
Import java.awt.*; import java.awt.event.*; import javax.swing.*; public class SimpleGUI extends JFrame { private JButton button = new JButton("Press"); private JTextField input = new JTextField("", 5); private JLabel label = new JLabel("Input:"); private JRadioButton radio1 = new JRadioButton("Select this"); private JRadioButton radio2 = new JRadioButton("Select that"); private JCheckBox check = new JCheckBox("Check", false); public SimpleGUI() { super("Simple Example"); this.setBounds(100,100,250,100); this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); Container container = this.getContentPane(); container.setLayout(new GridLayout(3,2,2,2)); container.add(label); container.add(input); ButtonGroup group = new ButtonGroup(); group.add(radio1); group.add(radio2); container.add(radio1); radio1.setSelected(true); container.add(radio2); container.add(check); button.addActionListener(new ButtonEventListener()); container.add(button); } class ButtonEventListener implements ActionListener { public void actionPerformed(ActionEvent e) { String message = ""; message += "Button was pressed\n"; message += "Text is " + input.getText() + "\n"; message += (radio1.isSelected()?"Radio #1":"Radio #2") + " is selected\n"; message += "CheckBox is " + ((check.isSelected()) ?"checked":"unchecked"); JOptionPane.showMessageDialog(null, message, "Output", JOptionPane.PLAIN_MESSAGE); } } public static void main(String args) { SimpleGUI app = new SimpleGUI(); app.setVisible(true); } }
Примечания:
getContentPane возвращает контейнер верхнего уровня. ButtonGroup служит для создания группы взаимосвязанных радио-кнопок.
Внутренний класс ButtonActionListener реализует интерфейс ActionListener. Для этого необходимо предоставить имплементацию метода actionPerformed.
JOptionPane служит для отображения диалоговых окон.
Жду ваших вопросов и комментариев. Если вы хотите больше узнать о Swing, скажите об этом, и в скором времени я напишу еще одну статью с более сложными приемами и компонентами.
Одно из важных достоинств Java состоит в том, что это не только язык, но и стандартизованная объектно-ориентированная среда выполнения. Любопытно проследить, как в рамках Java решаются традиционные программистские проблемы. Мы остановимся на оконном графическом интерфейсе.
Вместе с различными приятными (главным образом для пользователя) свойствами, оконный интерфейс привносит и довольно неприятные (для разработчика) проблемы. Одна из них - это переносимость приложений между разными платформами. Переносимость является проблемой и без графического интерфейса, однако наличие такового делает ее многократно сложнее.
Дело в том, что каждая оконная среда - это сложный мир, со своими законами, набором строительных блоков и приемов программирования. Motif не похож на MS-Windows и оконную систему Macintosh. По-разному представляются примитивные элементы интерфейса, по-разному обрабатываются внешние события, по-разному происжодит рисование на экране и т.д.
Вместе с тем, по своей сути оконная среда - просто идеальное поле деятельности для объектного программирования. Даже человеку, неискушенному в объектно-ориентированных методах проектирования, ясно, что такие вещи, как кнопки, текстовые поля, меню, вполне заслуживают названия объектов, как бы это слово ни понималось. Иначе говоря, вполне понятно, что такое “кнопка вообще”, “список вообще” и т.д.
Все это дает основания надеяться, что с помощью объектно-ориентированного подхода можно получить по-настоящему высокоуровневую и переносимую оконную среду, основанную на абстрактных типах данных.
Данная особенность оконных сред проявилась, в частности, в появлении довольно большого количества различных классовых библиотек, “обертывающих” оригинальные оконные системы. В качестве примеров можно привести MFC, OWL, Zink и многие другие.
Вот и среди стандартных Java-библиотек присутствует AWT или Abstract Windowing Toolkit - абстрактный оконный инструментарий.
AWT является системой классов для поддержки программирования в оконной среде. Его “абстрактность” проявляется в том, что все, зависящее от конкретной платформы, хорошо локализовано и спрятано. В AWT реализованы такие простые и понятные вещи, как кнопки, меню, поля ввода; простые и понятные средства организации интерфейса - контейнеры, панели, менеджеры геометрии.
Если посмотреть на любое оконное приложение, то легко увидеть, что интерфейсная часть состоит из объектов, объединенных в группы. В AWT объекты называются компонентами (на самом деле они все являются наследниками класса Component), а группы объектов реализованы с помощью так называемых контейнеров. Отметим, что любой контейнер - это тоже компонента, поэтому группы объектов могут быть вложены друг в друга. Как обычно, меню стоят особняком.
К числу примитивных компонент относятся:
Основные контейнеры:
Взаимодействие интерфейсных компонент с пользователем реализовано с помощью аппарата событий, о котором будет рассказано ниже.
У любого разработчика начинается такое время, когда создавать консольные приложения уже не весело, а изучить что-то новое очень хочется.
Тогда в Java есть несколько путей, для нескольких ОС. В зависимости от тех ОС которые вы используете или окружений которые в них установлены.
Небольшое предисловие:
Сам я являюсь пока еще начинающий программистом (могу писать софт средней сложности, но использую обычно скудный набор функций)
Статья рассчитана так же на новичков. Сам я работаю под Debian с Гномом, так что будут библиотеки мультиплатформенные)
Для начала стоило бы уделить внимание библиотеке GTK+
Она доступна не только для Явы, но и многих других языков: C++,C и т.д.
Написание Desktop"ных приложений с помощью GTK следует использовать если приложение рассчитано для работы под средой GNOME.
Сама GTK+ считается одной из самых легких для освоения библиотек под Jav"у.
Основа работы с библиотекой:
Для начала нужно подключить саму библиотеку со всеми ее вытекающими:
import org.gnome.gdk.Event ;
import org.gnome.gtk.Gtk ;
import org.gnome.gtk.Widget ;
import org.gnome.gtk.Window ;
import org.gnome.gtk.WindowPosition ;
Если вышла ошибка, то скорее всего у вас просто не установлена библиотека.
Если юзаете систему типа Debian или Ubuntu, то вам поможет простая команда из терминала:
apt-get install libjava-gnome-java
После этого проблем быть не должно.
public class DesktopExample extends Window {public DesktopExample() {
SetTitle("Пример окна на GTK и Гноме" ) ; // Название приложения
Connect(new Window .DeleteEvent () {
public boolean onDeleteEvent(Widget source, Event event) {
Gtk.mainQuit () ;
return false ;
}
} ) ;SetDefaultSize(250 , 150 ) ; // Размер
setPosition(WindowPosition.CENTER ) ; //Позиция при запуске, в данном случае центр
show() ;
}
Gtk.init (args) ;
new DesktopExample() ;
Gtk.main () ;
}
}
В конечном итоге получаем пустое окошко.
AWT - считается оригинальной системой для разработки графических интерфейсов, ее ругают из-за того, что она
не всегда стабильно работает на разных платформах, но сейчас таких проблем вроде не наблюдается и работать с ней удобно.
Имхо, это мой выбор.
SWT - это детище от IBM, долизанная и перелизанная система, обычно отличается стабильностью при работе и легкой в освоении.
Но SWT тяжеловеснее AWT, обладает большим функционалом, в следствии чего сложней AWT.
Но ее я бы не стал использовать часто, хотя она довольно популярна и держит свои позиции.
Вот пример окна на AWT:
// Подключаем всякие фичи, хотя swing тут лишний, это я в своем приложении прикручивал
// Это просто обрезок кода
import java.awt.EventQueue ;
import javax.swing.* ;
import java.awt.* ;
import java.awt.event.* ;import javax.swing.JFrame ;
public class Main {
private JFrame frame;
/**
* Запуск приложения, что-то типо первоначальной настройки, создание окна и типа того.
*/
public static void main(String args) {EventQueue .invokeLater (new Runnable () {
public void run() {
try {
Main window = new Main() ;
window.frame .setVisible (true ) ;
} catch (Exception e) {
e.printStackTrace () ;
}}
} ) ;
}/**
* Вызываем саму инициализацю
*/
public Main() {Initialize() ;
}/**
* Инициализация окна
*/
private void initialize() {
frame = new JFrame ("Чистое окно сгенерированное через Eclipse" ) ; // Делаем новое окно с названием
frame.setBounds (100 , 100 , 450 , 300 ) ;
frame.setSize (800 , 800 ) ; // Размеры
frame.setDefaultCloseOperation (JFrame .EXIT_ON_CLOSE ) ;}
А вот нам пример окна на SWT:
//Подключаем всякие фичи для веселой жизни
import org.eclipse.swt.SWT ;
import org.eclipse.swt.widgets.Display ;
import org.eclipse.swt.widgets.Shell ;
import org.eclipse.swt.widgets.Text ;public class ExampleApp {
public static void main (String args) {
Display display = new Display () ;
Shell shell = new Shell(display) ;Shell.pack () ; //Подготовка (первичная)
shell.open () ; //Подготавливаем
while (! shell.isDisposed () ) { //Запускаем
if (! display.readAndDispatch () ) display.sleep () ; //Спим до поры, до времени
}
display.dispose () ;
}
}
Она в приципе тоже не сложная, мультиплатформенная. Отличается большим количеством фич и малым количеством подключаемых пополнений.
Вот пример окна со swing"ом:
import javax.swing.JFrame ;
import javax.swing.SwingUtilities ;public class Example extends JFrame {
public Example() {
setTitle("Пример приложения со Свингой" ) ;
setSize(300 , 200 ) ;
setLocationRelativeTo(null ) ;
setDefaultCloseOperation(EXIT_ON_CLOSE) ;
}public static void main(String args) {
SwingUtilities .invokeLater (new Runnable () {
public void run() {
Example ex = new Example() ;
ex.setVisible (true ) ;
}
} ) ;
}
}
Это был основной список графических сред на Java. Почти все представленные здесь «штуки» мультиплатформенны
и работают на любом компьютере - Win, Linux, Mac.
Теги: java , java библиотеки, графические интерфейсы java
