Как написать оконное приложение на java

Так как в большинстве своем сегодняшние начинающие программисты не любят окно командной строки — приведу пример оконного приложения.

Начнем с простого[править]

import javax.swing.JFrame;

public class MyWindowApp extends JFrame { //Наследуя от JFrame мы получаем всю функциональность окна

  public MyWindowApp(){
    super("My First Window"); //Заголовок окна
    setBounds(100, 100, 200, 200); //Если не выставить 
                                   //размер и положение 
                                   //то окно будет мелкое и незаметное
    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); //это нужно для того чтобы при 
                                                    //закрытии окна закрывалась и программа,
                                                    //иначе она останется висеть в процессах
  }

  public static void main(String[] args) { //эта функция может быть и в другом классе
    MyWindowApp app = new MyWindowApp(); //Создаем экземпляр нашего приложения
    app.setVisible(true); //С этого момента приложение запущено!
  }
}

Вот у нас и получилось ничего не делающее приложение!

Делаем что-то полезное[править]

Это конечно замечательно уметь показывать пустое окно, но мы хотим, чтобы оно приносило пользу! Создадим форму для подсчета ворон на заборе. Для этого будем отображать текущее количество ворон и с помощью двух кнопок добавлять или вычитать по одной.

Дизайн[править]

Это то, что мы примерно хотим увидеть:

Скелет программы[править]

Пишем программу:

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class VoronCalc extends JFrame {
  private int voron = 0;
  private JLabel countLabel;
  private JButton addCrow;
  private JButton removeCrow;

  public VoronCalc(){
    super("Crow calculator");
    //Подготавливаем компоненты объекта
    countLabel = new JLabel("Crows:" + voron);
    addCrow = new JButton("Add Crow");
    removeCrow = new JButton("Remove Crow");

    //Подготавливаем временные компоненты
    JPanel buttonsPanel = new JPanel(new FlowLayout()); 
    //Расставляем компоненты по местам
    buttonsPanel.add(countLabel, BorderLayout.NORTH); //О размещении компонент поговорим позже

    buttonsPanel.add(addCrow);
    buttonsPanel.add(removeCrow);

    add(buttonsPanel, BorderLayout.SOUTH);
    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  }

public static void main(String[] args) {
    VoronCalc app = new VoronCalc();
    app.setVisible(true);
    app.pack(); //Эта команда подбирает оптимальный размер в зависимости от содержимого окна
  }
}

После компиляции и запуска — получится что-то такое:

Добавляем функциональность[править]

Пришло время добавить немного интерактивности. Нам нужно сделать 3 вещи:

1. Научить кнопку addCrow добавлять 1 к переменной voron.
2. Научить кнопку removeCrow вычитать 1 из переменной voron.
3. Научить countLabel — обновлять свое значение в зависимости от содержимого переменной voron.

addCrow[править]

Добавляем listener для кнопки addCrow.

addCrow.addActionListener(new ActionListener(){
  public void actionPerformed(ActionEvent e) {
    voron = voron+1;     //Добавляем одну ворону
     countLabel.setText("Crows:" + voron); //Сообщаем приложению, что количество ворон изменилось
  }
});

removeCrow[править]

Добавляем listener для кнопки removeCrow.

removeCrow.addActionListener(new ActionListener(){
  public void actionPerformed(ActionEvent e) {
    if( voron > 0 ) {
      voron = voron - 1;
      countLabel.setText("Crows:" + voron);  //Сообщаем приложению, что количество ворон изменилось
    } 
  }
});

updateCrowCounter[править]

private void updateCrowCounter() {
  countLabel.setText("Crows:" + voron);
}

Конечный результат[править]

• VoronCalc.java — главный класс программы

Всем привет. Как Вы помните в предыдущей статье мы перешли на язык Java для написания небольших приложений по обработки данных, на компьютере, полученных с устройств на микроконтроллере. Также мы условились, что дальнейший материал требует знание начального уровня java. Если его нет, то не расстраивайтесь, самые основы похожи на Си, но объектно-ориентированную часть придется подучить. Литературу я приводил в предыдущей статье.

Итак приступим. Сегодня мы создадим оконное приложение (кнопка и текстовое поле) используя фреймворк awt. Также добавим код обработки событий по нажатию на кнопку и закрытия окна.  Хочется сказать о том что вариантов написания кода — много, и с помощью какой библиотеки и как создавать приложение решать только Вам. В дальнейшем мы будем работать с данным языком проектируя Android-приложение под умный дом. Ниже приведен код, который выполняет выше описанную задачу.

import java.awt.*; /*Подключаем библиотеку для создания апплетов и независимых
                                приложений с графическим интерфейсом.*/
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;

public class logWindow extends Frame{   /*Создаем подкласс logWindow  класса Frame*/
      public logWindow ()   /*Конструктор класса*/
      {
            super («Логгер»);    /*Вызываем конструктор суперкласса и передаем ему параметр, в данном случае имя программы*/
            setSize (200,200);  /*Метод суперкласса для установкиразмеров окна, в пикселях*/
            //Создаем объекты
            Button myButton = new Button («Мониторинг»);  /*Создаем кнопку и надпись на  ней*/
            Label myLabel = new Label («Данные логгера»); / Создаем текстовое поле и надпись в нем*/
            add (myLabel, BorderLayout.NORTH); /* С помощью менеджера размещения, располагаем текстовое поле в северной части окна*/    
            add (myButton, BorderLayout.SOUTH); /*Кнопку в южной части*/   
            myButton.addActionListener (new ActionListener () {    /*Для кнопки выбираем событие слушателя, и создаем новое событие в скобках.*/
                  public void actionPerformed (ActionEvent e) {
                        myLabel.setText («Мониторинг»); /*Выполняется действие, т.е. при нажатии на кнопку в поле выводится сообщение  «Мониторинг» */
                  }
            });
      }
      public static void main (String[] args) {      //Точка входа программы
            logWindow log = new logWindow ();      //Создаем объект класса
            log.setVisible (true);                                //Устанавливаем видимость окна
           /*Наше окно запускается и отображается, при нажатии на кнопку меняется надпись в текстовом поле. Что бы закрыть окно необходимо добавить код обработки события, который работает следующим образом: мы вызываем для объекта log метод addWindowListener для того, чтобы назначить слушателя оконных событий. В качестве параметра создаем объект абстрактного класса WindowAdapter, в котором создаем класс и переопределяем метод для обработки события закрытия окна —  dispose.*/
            log.addWindowListener (new WindowAdapter () { 
                  public void windowClosing (WindowEvent e) {    // в качестве аргумента передаем событие
                         e.getWindow ().dispose ();                               // уничтожает объект Frame
            }          
      });
 }
}

Слева на рисунке внешний вид нашего простого оконного приложения на java. На данный момент нас устроит простое меню с одной кнопкой для дальнейших экспериментов. В  следующей статье мы научимся мониторить COM — порт, для приема информации с наших устройств, в данном случае такой же строки, которую мы вывели на терминал в статье №42.

Выше использовалась библиотека awt для построения графического интерфейса. Ниже пример разработки приложения с использованием JavaFX и интеграцию в него в качестве FrontEnd SVG c javascript — ом. Скрины приложения ниже. Полный код по ссылке на GitHub:

https://github.com/nik137/Diagnostics

Справа скрин анимированного splash screen for java application. Использование заставки с применением JavaFX,  SVG c javascript — ом.

Ниже скрин самого приложения с графическим интерфейсом. Описание программы в статье Java Collection for diagnostic software. Step №109. Полный код по ссылке выше.

На этом все. Всем пока.

В стандарт Java входит два пакета для создания оконного пользовательского интерфейса: awt и его надстройка swing. Компоненты swing имеют расширенные возможности по сравнению с аналогичными awt компонентами, поэтому упор будет сделан на них. Во-вторых, в отличие от awt компоненты swing не содержат платформо-зависимого кода. Так сказать являются облегченными (lightweight) компонентами.

контейнеры верхнего уровня

• JApplet — главное окно апплета;
• JFrame — окно приложения;
• JDialog — диалог приложения.
• JColorChooser — диалог выбора цвета;
• JFileChooser — диалог выбора файлов и директорий;
• FileDialog — диалог выбора файлов и директорий (awt компонент).

простые контейнеры

• JPanel — простая панель для группировки элементов, включая вложенные панели;
• JToolBar — панель инструментов (обычно это кнопки);
• JScroolPane — панель прокрутки, позволяющая прокручивать содержимое дочернего элемента;
• JDesktopPane — контейнер для создания виртуального рабочего стола или приложений на основе MDI (multiple-document interface);
• JEditorPane, JTextPane — контейнеры для отображения сложного документа как HTML или RTF;
• JTabbedPane — контейнер для управления закладками;
• JSplitPane — контейнер, разделяющий два элемента и позволяющий пользователю изменять их размер.

элементы интерфейса

Следующие элементы управления могут использоваться и как контейнеры, так как наследуются от класса java.awt.Container.

• JButton — кнопка;
• JCheckBox — кнопка-флажок;
• JComboBox — выпадающий список;
• JLabel — метка, надпись;
• JList — список;
• JPasswordField — текстовое поле для скрытого ввода;
• JProgressBar — компонент для отображения числа в некотором диапазоне;
• JRadioButton — преключатели, радио-кнопки, обычно используется с
  компонентом ButtonGroup;
• JSlider — компонент позволяющий выбрать значение из заданного диапазона;
• JSpinner — компонент позволяющий выбрать значение из указанной последовательности;
• JTable — таблица;
• JTextField — однострочное текстовое поле;
• JTextArea — многострочное текстовое поле;
• JTree — дерево.

управление позиционированием и размерами

Для автоматического позиционирования и задания размеров дочерних элементов контейнерыиспользуют специальные объекты — компоновщики. Для ручного позиционирования надо установить пустой объект вызовом метода setLayout(null).

Ниже приведен список стандартных компоновщиков:

• BorderLayout — размещает элементы в один из пяти регионов, как было указано при добавлении элемента в контейнер:
  наверх, вниз, влево, вправо, в центр;
• FlowLayout — размещает элементы по порядку в том же направлении, что и ориентация контейнера (слева на право по умолчанию)
  применяя один из пяти видов выравнивания, указанного при создании менеджера.
  Данный менеджер используется по умолчанию в большинстве контейнерах;
• GridLayout — размещает элементы таблично. Колличество столбцов и строк указывается
  при создании менеджера. По умолчанию одна строка, а число столбцов равно числу элементов;
• BoxLayout — размещает элементы по вертикали или по горизонтали. Обычно он используется не
  напрямую а через контейнерный класс Box, который имеет дополнительные возможности;
• SpringLayout — это менеджер низкого уровня и был разработан для программ
  построителей форм;
• GroupLayout — данный менеджер также был разработан для построителей форм.

события

Элементы интерфейса и контейнеры генерируют ряд событий, например:

• ActionEvent — событие, определяемое компонентом, например нажатие кнопки;
• ComponentEvent — генерируется, когда позиция, размер или видимость компонента изменяются;
• ContainerEvent — генерируется при добавлении или удалении элемента из контейнера;
• FocusEvent — генерируется при получении или потери фокуса ввода компонентом;
• ItemEvent — событие выбора или отменены выбора элемента.
  Например, изменение состояния кнопки-флажка, выбор элемента меню или списка;
• KeyEvent — событие ввода с клавиатуры;
• MouseEvent — события мыши;
• WindowEvent — события окна, как активация и свертывание.

Для обработки событий элемента в нем необходимо зарегистрировать объект обработчик
в числе слушателей. Делается это методами типа addxxxListener, например addMouseListener(). В качестве объектов обработчиков обычно выбирают контейнер, в котором содержится элемент.Обработка события осуществляется через соответствующий интерфейс, например:

• ActionListener — интерфейс обработки события ActionEvent;
• ItemListener — интерфейс обработки события ItemEvent;
• KeyListener — интерфейс обработки события KeyEvent;
• MouseListener — интерфейс обработки события MouseEvent, для нажатия/отжатия кнопок и входа/ухода курсора мыши с
  области компонента;
• MouseMotionListener — интерфейс обработки события MouseEvent, для движение курсора мыши или перетаскивании мышью;
• MouseWheelListener — интерфейс обработки события MouseEvent, для прокрутки
  колеса мыши.

Если весь интерфейс реализовывать не нужно, например, нужен только
один из методов, то можно воспользоваться адаптерами.

Первое оконное приложение с использованием Java Swing

Обычно оконное приложение состоит из одного и более окон и диалогов.
В отличие от простых контейнеров контейнеры верхнего уровня имеют более сложную внутреннюю структуру. Для них автоматически создается корневой контейнер — объект класса JRootPane, который можно получить методом getRootPane(). Внутри корневого создаются еще дваобъекта: слойный контейнер и объект представляющий окно как компонент.

В большинстве случаев в слойном контейнере используются первых два контейнера слоя. Первый для хранения большинства элементов управления окна, так сказать клиентская область окна. Для доступа к нему прямо из окна используется метод getContentPane, также его можно заменить любым другим контейнером методом setContentPane(). Второй контейнер слой используется для хранения меню, панелей инструментов и т.п. Например, панель меню, добавляемая к окну, методом setJMenuBar() сохраняется именно там.

Методом getGlassPane можно получить объект представляющий окно как компонент для обработки событий или рисования поверх всех других компонент.

Ниже приведен минимальный шаблон оконного приложения.
Классы MyPanel и MyComponent — пользовательские классы, которые будут реализованы в некоторыхследующих примерах для демонстрации возможностей swing. Вам остается просто скопировать со страницы код MyPanel/MyComponent в проект со шаблоном, подправить шаблон и запустить его.

import java.awt.BorderLayout;
import java.awt.Container;
import java.awt.Dimension;
import javax.swing.JFrame;
/**
 * @author DarkRaha
 *
 */
public class MyWin extends JFrame {

    // серийный номер класса
    private static final long serialVersionUID = 1L;

    public MyWin() {
        Container c = getContentPane(); // клиентская область окна
        c.setLayout(new BorderLayout()); // выбираем компоновщик

        // добавляем какие-нибудь дочерние элементы
        //MyComponent child = new MyComponent();
        MyPanel child= new MyPanel();    
        c.add(child);

        // -------------------------------------------
        // настройка окна
        setTitle("Example window"); // заголовок окна
        // желательные размеры окна
        setPreferredSize(new Dimension(640, 480));
        // завершить приложение при закрытии окна
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        pack(); // устанавливаем желательные размеры
        setVisible(true); // отображаем окно
    }

    // запуск оконного приложения
    public static void main(String args[]) {
        new MyWin();
    }
}

Ниже приведен более сложный пример с несколькими дочерними элементами и обработкой
событий.

// пример оконного приложения
import java.awt.BorderLayout;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;

/**
 * @author DarkRaha
 * 
 */
public class MainWin extends JFrame implements ActionListener {
// версия класса
private static final long serialVersionUID = 1L;

// некоторые элементы окна 
private JTextArea jta = new JTextArea(
                        "Scroll bar will appear, when much text");

public MainWin() {
   // ------------------------------------------
   // добавление и настройка компонент
   Container c = getContentPane(); // клиентская область окна
   c.setLayout(new BorderLayout()); // выбираем компоновщик

   // метку наверх
   c.add(new JLabel("my first label :)"), BorderLayout.NORTH);
   // две кнопки в дополнительную панель
   JPanel jp = new JPanel();
   JButton jbt = new JButton("Add text");
   jbt.addActionListener(this); // назначаем обработчик события
   jp.add(jbt);
   jbt = new JButton("Clear text");
   jbt.addActionListener(this); // назначаем обработчик события
   jp.add(jbt);
   // добавляем панель вниз
   c.add(jp, BorderLayout.SOUTH);
   // помещаем текст. поле в область прокрутки
   // а область прокрутки в центр окна,
   // BorderLayout.CENTER значение по умолчанию
   c.add(new JScrollPane(jta));
   jta.setLineWrap(true); // автоматический перенос строк
   // всплывающая подсказка
   jta.setToolTipText("this is simple text editor");

   // -------------------------------------------
   // настройка окна
   ...
}

// обработчик события, метод интерфейса ActionListener
public void actionPerformed(ActionEvent arg0) {
   if (arg0.getActionCommand().equals("Add text"))
      jta.append(" Add text\n");

   if (arg0.getActionCommand().equals("Clear text"))
      jta.setText("");
   
   // если ссылки на объекты сохранены можно сравнивать
   // по объектам, например для JButton jbOK= new JBUtton("Ok");
   // то сравнение будет таким 
   //    if(arg0.getSource().equals(jbOK))
}

// запуск оконного приложения
public static void main(String args[]) {
   new MainWin();
}

}

Компоновщики

Менеджеры компоновки используются для автоматического позиционирования и задания размеров дочерних элементов в контейнере. Компоновщиком является любой объект реализующий интерфейс LayoutManager или LayoutManager2 (поддерживает выравнивание и ограничения).

стандартные компоновщики

• BorderLayout — размещает элементы в один из пяти регионов, как было указано при добавлении элемента в контейнер: наверх, вниз, влево, вправо, в центр. По умолчанию элемент добавляется в центр. Если в указанном регионе уже есть элемент, то он замещается новым. Поэтому, когда надо разместить несколько элементов в одном регионе, то их объединяют в один контейнер (обычно JPanel);
• FlowLayout — размещает элементы по порядку в том же направлении, что
  и ориентация контейнера (слева на право по умолчанию)
  применяя один из пяти видов выравнивания, указанного при создании менеджера.
  Данный менеджер используется по умолчанию;
• GridLayout — размещает элементы таблично. Колличество столбцов и строк указывается при создании менеджера. По умолчанию одна строка, а число столбцов равно числу элементов. Вся область контейнера разбивается на ячейки и размер каждого элемента устанавливается в размерячейки. Это больше подходит для выравнивания панелей и других контейнеров, а не элементов управления (нам ведь не нужны гигантские кнопки);
• BoxLayout — размещает элементы по вертикали или по горизонтали.
  Обычно он используется не напрямую, а через контейнерный класс Box (ящик).

точное позиционирование и задание размеров

Если в контейнере отсутствует компоновщик (был вызван метод контейнера setLayout(null)), то позицию и размеры элементов необходимо задать явно методами элемента

• setLocation(Point p) — переместить компонент в указанную точку;
• setLocation(int x, int y) — переместить компонент в указанную точку;
• setSize(Dimension d) — установить размеры компонента;
• setSize(int width, int height) — установить размеры компонента;
• setBounds(Rectangle r) — переместить и установить размеры компонента
  (вписать в четырехугольник);
• setBounds(int x,int y, int width, int height) — переместить и установить
  размеры компонента.

предпочтительные размеры

Компоненты обладают минимальными, максимальными и предпочтительными размерами.
Некоторые компоновщики используют эти параметры, а значит можно повлиять на их работу, изменяя их. Эти размеры также могут пригодится при разработке собственного компоновщика. Если все размеры компонента равны, то говорят, что у компонента фиксированный размер. Получить и установить эти значения можно методами:

• getMaximumSize() — получение максимального размера;
• setMaximumSize(Dimension d) — установка максимального размера;
• getMinimumSize() — получение минимального размера;
• setMinimumSize(Dimension d) — установка минимального размера;
• getPreferredSize() — получение желательного размера;
• setPreferredSize(Dimension d) — установка желательного размера.

компоновщики низкого уровня

Существует также два компоновщика низкого уровня, разработанных для программ построителей форм SpringLayout и GroupLayout. В
документации
для SpringLayout можно скачать файлик SpringUtilities.java, где реализованы два полезных способа компоновки на его основе (как там сказано просто вызываем методы из этого файла, не вникая в детали:).

класс Box

Класс Box реализует контейнер с компоновщиком BoxLayout. Если элементы размещаются по горизонтали, то высота всех элементов равна высоте самого высокого элемента.А ширина элементов такова, чтобы заполнить весь контейнер по ширине.
При изменении ширины контейнера элементы растягиваются пропорционально. Если у всех элементов достигнут предел растяжения (значение getMaximumSize()), то первый элемент растягивается насильно. Если остается хотя бы один элемент доступный для растяжения, то растягивается только он.

Подобным образом происходит и вертикальное размещение. Ширина всех элементов равна ширине самого широкого элемента, а высота элеметов такова, чтобы заполнить весь контейнер по высоте. При этом может понадобится явное задание выравнивания элементов методом setAlignmentX. Иначе даже при одинаковой ширине, элементы не будут выстроены в красивый столбик.

Класс Box имеет статические методы для создания невидимых элементов для различных целей:

• createHorizontalStrut(int width) — создает компонент с фиксированной шириной. При горизонтальной укладке элемент используется чтобы освободить пространство между соседними элементами, иначе элементы будут впритык. При вертикальной укладке элемент используется для задания минимальной ширины остальных элементов;
• createVerticalStrut(int height) — создает компонент с фиксированной высотой. При вертикальной укладке элемент используется чтобы освободить пространство между соседними элементами, иначе элементы будут впритык. При горизонтальной укладке элемент используется для задания минимальной высоты остальных элементов;
• createRigidArea(Dimension d) — создает невидимый элемент фиксированного размера;
• createGlue() — создает невидимый растягиваемый компонент. Используется, чтобы предотвратить насильное растяжение элементов. Например, пусть в контейнере видимые элементы фиксированного размера. Тогда положив данный компонент в начало и в конец контейнера, мы получим центрирование видимых элементов. А если расположить его после каждого видимого, то при увеличении размера контейнера, видимые элементы «разойдутся» друг от друга.

пример использования компоновщиков

Ниже приведен пример использования некоторых компоновщиков. Цветные бордюры служат для разграничения текстовых полей друг от друга, если вызовы метода createVerticalStrut буду закомментированы.

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.GridLayout;

import javax.swing.BorderFactory;
import javax.swing.Box;
import javax.swing.BoxLayout;
import javax.swing.JButton;
import javax.swing.JComboBox;
import javax.swing.JPanel;
import javax.swing.JTextArea;

public class MyPanel extends JPanel {
    private static final long serialVersionUID = 1L;
    private String items[] = new String[] { "item1", "item2", 
          "item3", "item4", "item5" };

    public MyPanel() {
        setLayout(new BorderLayout()); // выбираем компоновщик

        // сеточная растановка в два столбца
        // много строк
        JPanel jp = new JPanel();
        jp.setLayout(new GridLayout(0, 2));
        JButton jb;
        JComboBox cb = new JComboBox(items);
        jp.add(cb);
        jb = new JButton("bt1");
        jp.add(jb);
        jb = new JButton("bt2");
        jp.add(jb);
        jb = new JButton("bt3");
        jp.add(jb);
        jb = new JButton("bt4");
        jp.add(jb);

        // укладываем элементы в ящик
        Box bv = new Box(BoxLayout.Y_AXIS);
        // минимальная ширина текстовых полей
        bv.add(Box.createHorizontalStrut(60));

        JTextArea jta = new JTextArea();
        // рамка вокруг текстового поля
        jta.setBorder(BorderFactory.createLineBorder(Color.green));
        bv.add(jta);
        // пустое место в 15 пикселей
        bv.add(Box.createVerticalStrut(15));
        // для эксперемента с размерами
        // jta.setPreferredSize(new Dimension(60,100));
        // jta.setMaximumSize(new Dimension(60,100));
        // jta.setAlignmentX(LEFT_ALIGNMENT); // явно задаем выравнивание

        jta = new JTextArea();
        jta.setBorder(BorderFactory.createLineBorder(Color.green));
        bv.add(jta);
        bv.add(Box.createVerticalStrut(15));

        jta = new JTextArea();
        jta.setBorder(BorderFactory.createLineBorder(Color.green));
        bv.add(jta);
        bv.add(Box.createVerticalStrut(15));

        add(jp); // добавляем панель в центр
        add(bv, BorderLayout.WEST); // добавляем ящик влево
    }
}

Практически каждый начинающий программист пишет консольные программы, с этого начинают все. Как говориться «я просто написал hello world, и тут понеслось». Однако писать консольные программки уже начинает надоедать и
новички пробуют осваивать построение графических интерфейсов, присматриваться к фреймворкам или выбирают свою нишу в мире программирования, будь то мобильные платформы, серверные и клиентские приложения для десктопов и т.д. Направлений можно перечислять много, но не буду на этом зацикливаться, разговор пойдет о стандартной графической библиотеке Swing.

В данной статье мы рассмотрим:

• Краткая теория про Swing и AWT. 
• Обзор стандартных компонентов. 
• Пишем первое приложение выводящее ваше имя. 
• Ссылки для дополнительного чтения.

Библиотека Swing была создана компанией Sun Microsystems, как надстройка над AWT,она расширяет классы и интерфейсы AWT. Кратко говоря Swing — это графическая библиотека, с помощью которой можно создавать интерфейсы для программ. В своем наборе имеет такие компоненты как кнопки, диалоговые окна, текстовые поля, чек-боксы и т.д.

На счет AWT забыл упомянуть, это ранняя библиотека графических компонентов, её особенностью было то, что она имела ограничения в разработке интерфейса, то есть разработанный интерфейс под любой платформой, будет отображать лишь элементы которые есть в самой ОС, выходит, что, как бы, нету возможности создавать кастомные объекты. Так же есть возможность работы этих двух библиотек совместно, поскольку как говорилось ранее Swing построена на AWT. Разница между ними разве что в сложности построения (разработки) интерфейса.

Для группировки компонентов интерфейса принято использовать контейнеры (Container). Обычно используют JFrame, так же имеются JWindows и JApplet. Рассмотрим их основные методы:
—setBounds(x,y,w,h); — с помощью этого метода задаются размеры окна, а так же ширина и высота;
—setResizable(boolean); — этот метода позволяет задать, можно ли будет изменить размер окна, или же оставить его фиксированным;
—setTitle(String); — метод позволяет задать название окна;
—setVisible(boolean); — отображение окна;
—setDefaultCloseOperation(operation); – позволяет указать операцию, которая будет произведена по закрытии окна.

Swing обладает множеством «строительных блоков», основные из них перечислены ниже:

• JLabel – элемент для отображения текста; 
• JTextField — элемент для редактирования текста; 
• JButton – обычная кнопка; 
• JCheckBox – элемент выбора, так называемый флажок; 
• JRadioButton — элемент выбора, так называемый «радио-кнопки».

Для этих случаев были разработаны такие классы как Java.util.java.awt и java.event.
Кратко говоря, система построена на слушателях событий и передатчиках событий (об этом отдельно напишу). Для отслеживания действий используется интерфейс ActionListener.

Вот, вроде бы немножко объяснил, что и к чему, теперь можно написать простенький пример. Напишем приложение, которое будет выводить ваше имя (говорить вам привет), написанное в поле ввода текста, и по нажатию кнопки покажет вам «привет (Вася,Петя,Саша)».

И так, начнем:

1. Откройте Eclipse IDE (надеюсь, она у вас есть).
2. Добавьте плагины для создания графического интерфейса. Для этого:
      2.1 Перейдите в Help -> Install New Software;
      2.2 В поле Work with выберите —All Available Sites— ;
      2.3 У вас появиться список множества плагинов;
      2.4 Найдите поле под названием General Purpose Tools;

      2.5 В вкладке General Purpose Tools выберите плагины как показано ниже на скрине

     2.6   Далее читаем лицензионное соглашение, соглашаемся и Next -> Next -> Finish

     2.7  Среда разработки вежливо попросит вас её перезапустить.

3. Затем создайте новый проект (думаю уже умеете).

4. В проект добавьте новую форму (JFrame), как показано на скрине

5. Создав её можете поэкспериментировать с разработкой интерфейса, повставлять кнопочки и т.д.
6. Добавим в форму такой код:

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JTextField;

public class MyFrame extends JFrame implements ActionListener {
    private JTextField textField;
    private JLabel lblNewLabel;
    String name;

    public MyFrame() {
 setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

 setBounds(100, 100, 450, 300);
 getContentPane().setLayout(null);

 JButton btnOk = new JButton("OK");
 btnOk.addActionListener(this);

 btnOk.setBounds(335, 11, 89, 23);
 getContentPane().add(btnOk);

 textField = new JTextField();
 textField.setBounds(10, 12, 315, 20);
 getContentPane().add(textField);
 textField.setColumns(10);

 lblNewLabel = new JLabel("Имя");
 lblNewLabel.setBounds(10, 146, 315, 14);
 getContentPane().add(lblNewLabel);

    }

    @Override
    public void actionPerformed(ActionEvent e) {
 name = textField.getText();
 lblNewLabel.setText("привет " + name);

    }
}

public class Main {
    public static void main(String[] args) {
 MyFrame frame = new MyFrame();
 frame.setVisible(true);
    }
}

Тут забираем исходники.

Про Swing можно почитать тут  и тут. Удачи Вам в начинаниях.

Окна являются основой пользовательского интерфейса любой операционной системы. Они визуально
разделяют выполняемые в среде приложения. Окна, используемые в библиотеке Swing, мало чем
отличаются от окон библиотеки AWT, которые представляют собой окна операционной системы.

Все окна библиотеки Swing — а к ним относятся окно без рамки JWindow, окно с рамкой
JFrame и диалоговое окно JDialog — являются исключением из правила, согласно
которому все компоненты Swing представляют собой легковесные компоненты и унаследованы от
базового класса JComponent. Окна Swing являются тяжеловесными контейнерами для размещения в них
легковесных компонентов, которые операционная система не видит.

Наиболее полезные JFrame методы

Окно JWindow

«Родителем» всех окон Swing является окно без рамки и без элементов управления
JWindow.

Класс JWindow представляет собой окно без рамки и без элементов управления,
предназначенных, к примеру, для его закрытия или перемещения. Данный тип окна дает минимальные
возможности по своей настройке, в отличие от чаще всего используемого окна JFrame. Окно без
рамки не часто требуется в программах. Однако в отдельных случаях оно может быть полезно,
особенно в тех случаях, когда необходимо ненадолго вывести на экран какую-либо информацию типа
заставки программы или подсказку для пользователя, и управлять окном с этой информацией не
нужно.

Окна JWindow используются всплывающими меню JPopupMenu в тех ситуациях, когда в
окне приложения не хватает места для размещения легковесного компонента в слое POPUP_LAYER
многослойной панели, где всплывающие меню располагаются по умолчанию. В такой ситуации
вместо легковесного компонента создается небольшое окно без рамки JWindow, которое можно
разместить в любом месте экрана, потому что оно принадлежит операционной системе. В этом окне и
размещается всплывающее меню.

Рассмотрим пример JWindowTest. Основная идея использования окна без рамки JWindow
заключается в копировании части «изображения рабочего стола» в окно приложения. Благодаря
появившемуся в пакете JDK 1.3 классу Robot можно «снимать» экранную копию рабочего стола.

Пример JWindow

// Пример использования окна без рамки JWindow
import javax.swing.*;

import java.awt.*;

// Класс прорисовки изображения
class ImageDraw extends JComponent
{
    private Image capture;
    ImageDraw (Image capture) {
        this.capture = capture;
    }
    public void paintComponent(Graphics g) {
        // Прорисовка изображения
        g.drawImage(capture, 0, 0, this);
    }
}
public class JWindowTest extends JWindow
{
    // изображение "рабочего стола"
    private Image capture;
    // Размер окна 
    private int window_w = 300, window_h = 300;

    public JWindowTest() {
        super();
        // Определение положение окна на экране
        setLocation(200, 100);
        // Определение размера окна
        setSize (window_w, window_h);
        try {
            // "Вырезаем" часть изображения "рабочего стола"
            Robot robot = new Robot();
            capture = robot.createScreenCapture(
                      new Rectangle(5, 5, window_w, window_h));
        } catch (Exception ex) { ex.printStackTrace(); }
        // Добавляем в интерфейс изображение
        getContentPane().add(new ImageDraw(capture));
        // Открываем окно
        setVisible(true);
        try {
            // Заканчиваем работу через 10 сек
            Thread.currentThread();
            Thread.sleep(10000);
        } catch (Exception e) { }
            System.exit(0);
    }
    public static void main(String[] args) {
        new JWindowTest();
    }
}

В этом примере приложение наследуем от окна JWindow, чтобы удобнее вызывать методы
этого класса и добавлять в окно компоненты. Объект Robot необходимо создавать в блоке
try … catch, т.к. его создание может быть запрещено менеджером
безопасности, используемым виртуальной машиной Java. Впрочем, нам нарушение безопасности не грозит,
потому что мы создаем отдельное приложение, а не апплет.

Вырезаем часть изображения «рабочего стола» методом createScreenCapture() в стороне он
местоположения нашего окна. Затем в панель содержимого окна добавляется компонент ImageDraw,
который и отображает вырезанное изображения рабочего стола. После вывода окна на экран программа
засыпает на 10 секунд, а потом заканчивает свою работу.

Скриншот рабочего стола с интерфейсом окна примера JWindow представлен на следующем рисунке.

Прежде чем производить настройку окна, в примере JWindowTest вызывается конструктор базового
класса ключевым словом super() без параметров. На самом деле окна без рамки JWindow
обязательно требуют при создании указывать своего «родителя» — окно с рамкой JFrame,что
не всегда может быть неудобно. Специально для таких случаев в класс JWindow был добавлен
конструктор без параметров, который создает вспомогательное невидимое окно JFrame и использует
его как «родителя». После этого все окна без рамки, созданные таким образом, задействуют только
это окно и экономят ресурсы.

Следует также отметить, что с помощью конструктора без параметров создается окно JWindow,
неспособное получать фокус ввода. Чаще всего именно такое поведение необходимо (ведь панелям
инструментов, всплывающим заставкам и меню фокус ввода не нужен). При необходимости получения
фокуса ввода, используйте метод setFocusableWindowState(true).

Окно JFrame

Окно JFrame наследует свойства класса JWindow и представляет собой наиболее часто
используемое в приложениях окно «общего назначения». Основные отличия окна JFrame от JWindow :

• наличие рамки, которая позволяет изменять размер окна;
• наличие заголовка с названием приложения (заголовок может быть пустым);
• возможность использования системного меню, позволяющее проводить манипуляции
  с окном и приложением;
• наличие кнопок управления для закрытия и свертывания окна.

Для размещения компонентов пользовательского интерфейса в подавляющем большинстве приложений
применяется класс JFrame. Разработчики Swing определили специальный метод закрытия
окна setDefaultCloseOperation, существенно упрощающий эту операцию. Рассмотрим простой
JFrame пример (JFrameWindowListener) с обработкой события закрытия окна.

JFrame пример

import java.awt.Dimension;
import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;

import javax.swing.JFrame;
import javax.swing.JLabel;

public class JFrameWindowListener extends JFrame
{
    private static final long serialVersionUID = 1L;
    private static int    counter = 0; // счетчик
    private static JLabel label   = null;
    private static String TEMPL   = "Закрытие окна (попыток %d)";
    public JFrameWindowListener ()
    {
        // Создание окна с заголовком
        JFrame frame = new JFrame("JFrameWindowListener");
        // Не закрывать окно по нажатию на кнопку с крестиком 
        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) {
                if (++counter == 3) {
                    event.getWindow().setVisible(false);
                    System.exit(0);
                } else
                    label.setText(String.format(TEMPL, counter));
            }
        }); 
        label = new JLabel(String.format(TEMPL, counter));
        frame.getContentPane().add(label);

        frame.setPreferredSize(new Dimension(250, 80));
        frame.pack();
        frame.setVisible(true);
    }
    public static void main(String[] args)
    {
        JFrame.setDefaultLookAndFeelDecorated(true);
        new JFrameWindowListener();
    }
}

В примере создается окно JFrame с определением заголовка в конструкторе базового
класса. Для определения титульной строки окна можно также использовать метод setTitle()
класса JFrame.

Прежде чем задать размеры окна и отобразить его на экране, вызывается метод
setDefaultCloseOperation(). Данный метод позволяет указать, какое действие будет произведено
при предварительной обработке события processWindowEvent() перед закрытием окна. По умолчанию
используется константа HIDE_ON_CLOSE, убирающая окно с экрана при его закрытии. Можно
использовать значение EXIT_ON_CLOSE, которое указывает, что при закрытии окна необходимо
закончить работу приложения.

В примере методу setDefaultCloseOperation передается константа DO_NOTHING_ON_CLOSE —
ничего не делать при закрытии окна. К окну JFrame подключается слушатель и обработка
события закрытия окна выполняется в методе windowClosing. Алгоритм обработки построен таким
образом, что окно закрывается при третьей попытке. Номер попытки отображается в метке
интерфейса.

Скриншот рабочего стола с интерфейсом окна нашей программы представлен на следующем рисунке.

Для определения иконки окна необходимо использовать метод setIconImage(). Иконка
располагается на кнопке свернутого окна или в заголовке окна в нормальном состоянии.

Из дополнительных возможностей окна с рамкой JFrame следует упомянуть о его
способности «прятать» свои «украшения»: рамку и элементы управления окном. Делает это метод
JWindow.

События окон, WindowListener, WindowFocusListener

Окна Swing (JWindow, JFrame, JDialog) поддерживают два типа событий :

• WindowListener — позволяет узнать об изменениях в состоянии окна;
• WindowFocusListener — сообщает о получении или потере компонентами окна
  фокуса ввода

Полный список методов данных слушателей можно найти в интерактивной документации Java.

В интерфейсе слушателя WindowListener чаще остальных применяют метод
windowClosing, вызываемый системой событий при закрытии окна. Рассмотренный выше
пример наглядно демонстрирует это.

К фрейму JFrame можно подключить слушателя окна, созданного на основе
WindowAdapter (чтобы не реализовывать все определенные в интерфейсе WindowListener
методы) и переопределить метод windowClosing, как это представлено в следующих строках кода :

// Добавляем слушателя событий от окна
frame.addWindowListener (new WindowAdapter() {
    @Override
	public void windowClosing(WindowEvent e) {
    // Потверждение закрытия окна JFrame
    int res = JOptionPane.showConfirmDialog(null, "Выйти из программы?");
    if (res == JOptionPane.YES_OPTION)
         System.exit(0);
    }
});

При выходе из программы открывается диалоговое окно в панели JOptionPane и у
пользователя спрашивается подтверждение, действительно ли он желает закончить работу с
приложением. Если ответ положительный, то программа завершает работу.

Диалоговое окно JDialog

Диалоговые окна чаще всего используются в приложениях для получения дополнительной информации
с целью установки параметров приложения, вывода важной вспомогательной/отладочной
информации. Диалоговые окна, как правило, создаются модальными (modal), блокирующими доступ к
остальным окнам приложения, пока пользователь не закончит работу с модальным диалоговым окном.
Модальные диалоговые окна располагаются поверх основного окна приложения. Внешний вид диалоговых
окон мало отличается от окон с рамкой JFrame, но обычно у них меньше элементов управления окна
(чаще всего, имеется только кнопка закрытия окна) и отсутствует системное меню.

В Swing диалоговые окна реализуются классом JDialog, унаследованном от базового класса
окон JWindow и позволяющим создавать как обычные, так и модальные диалоговые окна. JDialog
поддерживает как и JFrame закрытие окна, а в остальном сходен с другими окнами Swing.

При создании диалоговых окон Swing необходимо указать «родительское окно», которым может быть
окно с рамкой JFrame или другое диалоговое окно JDialog. Имеется также конструктор, не
требующий «родительского» окна, но использующий вспомогательное прозрачное окно, о котором было
сказано на странице «Окно без рамки JWindow».

JDialog пример создания диалоговых окон

/**
 * Тестовый класс создания диалоговых окон
 */
import javax.swing.*;
import java.awt.event.*;

public class JDialogTest extends JFrame 
{
    private static final long serialVersionUID = 1L;
    public JDialogTest() {
        super("DialogWindows");
        // Выход из программы при закрытии
        setDefaultCloseOperation(EXIT_ON_CLOSE);
        // Кнопки для создания диалоговых окон
        JButton button1 = new JButton("Немодальное окно");
        button1.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                JDialog dialog = createDialog("Немодальное", false);
                dialog.setVisible(true);
            }
        });
        JButton button2 = new JButton("Модальное окно");
        button2.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                JDialog dialog = createDialog("Модальное", true);
                dialog.setVisible(true);
            }
        });
        // Создание панели содержимого с размещением кнопок
        JPanel contents = new JPanel();
        contents.add(button1);
        contents.add(button2);
        setContentPane(contents);
        // Определение размера и открытие окна
        setSize(350, 100);
        setVisible(true);
    }
    /** Функция создания диалогового окна.
     * @param title - заголовок окна
     * @param modal - флаг модальности
     */
    private JDialog createDialog(String title, boolean modal)
    {
        JDialog dialog = new JDialog(this, title, modal);
        dialog.setDefaultCloseOperation(DISPOSE_ON_CLOSE);
        dialog.setSize(180, 90);
        return dialog;
    }

    public static void main(String[] args)
    {
        new JDialogTest();
    }
}

В примере создаем окно с рамкой JFrame, в панели содержимого которого размещается две
кнопки JButton. По нажатию на кнопки создаются диалоговые окна в отдельном методе createDialog().
Диалоговое окно с заданным заголовком JDialog может быть модальным и немодальным. Программа
позволяет создать несколько немодальных окон одновременно, но только одно модальное. Немодальные
окна не блокируют работу с основным окном приложения. При закрытии диалогового окна используется
константа DISPOSE_ON_CLOSE, удаляющую окно после закрытия.

Интерфейс работы примера JDialog представлен на следующем скриншоте.

Библиотека Swing предоставляет набор стандартных диалоговых окон JDialog для получения и
вывода несложной информации. Прежде чем создавать собственное диалоговое окно, следует
рассмотреть возможность использования стандартного.

Оформление окон

Начиная с JDK 1.4 появилась возможность настраивать так называемое визуальное «оформление»
окон: рамка, элементы управления окном (кнопки закрытия или свертывания), системное меню.
Необходимость этого ощущалась с самых первых выпусков Swing.

Сейчас создание различных интерфейсов окон возможна благодаря усовершенствованиям в
UI-представителе корневой панели JRootPane. UI-представитель позволяет создавать специальные
рамки, заголовок, системное меню и кнопки управления окном, и размещать их в корневой панели
нужным образом, используя специализированный менеджер расположения. Менеджер расположения
контролирует пространство корневой панели. Кроме этого, при новом оформлении окон отключаются
системные элементы окна.

В классах JFrame и JDialog имеется статический метод setDefaultLookAndFeelDecorated(),
обеспечивающий возможность оформления всех создаваемых окон.

Пример оформления окон : JDialog decoration

// Оформление окон Swing

import javax.swing.*;

public class JFrameDecorations
{
    public static void main(String[] args)
    {
        // Подключение украшений для окон
        JFrame.setDefaultLookAndFeelDecorated(true);
        JDialog.setDefaultLookAndFeelDecorated(true);
        // Создание окна с рамкой
        JFrame frame = new JFrame("Oкнo с рамкой");
        // Определение способа завершения работы программы
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setSize(200, 200);
        frame.setVisible(true);
        // Создание диалогового окна
        JDialog dialog = new JDialog(frame, "Диалоговое окно");
        // Определение способа завершения работы диалогового окна
        dialog.setDefaultCloseOperation(JDialog.DISPOSE_ON_CLOSE);
        dialog.setSize(150, 100);
        // Определение типа оформления диалогового окна
        dialog.getRootPane().setWindowDecorationStyle(JRootPane.INFORMATION_DIALOG);
        dialog.setVisible(true);
    }
}

В примере создается простое окно с рамкой и диалоговое окно. Перед создания окон вызывается
метод setDefaultLookAndFeelDecorated(), означающий, что для создаваемых окон JFrame и
JDialog потребуется специальное оформление. Далее определяются размеры окон и они
выводятся на экран.

Следует обратить внимание на метод корневой панели setWindowDecorationStyle(), позволяющий
настроить оформление окна. Если окно с рамкой имеет только один тип оформления, то
диалоговые окна в зависимости от их цели (представление информации, сообщение об ошибке и т.д.)
могут выглядеть по-разному. В примере было определено, что создаваемое диалоговое окно требуется
для вывода информации и должно выглядеть соответствующим образом.

Интерфейс примера окон, оформленных с внешним видом Metal, представлен на следующем
скриншоте.

Специальное оформление окон может быть полезно как средство, позволяющее полностью, вплоть
до окон, управлять внешним видом вашего приложения. Создав собственного UI-представителя
корневой панели, можно придать своему приложению уникальный вид, легко узнаваемый
пользователями.

Скачать примеры

Исходные коды примеров, рассмотренных в тексте страницы, можно
скачать здесь (3.54 Кб).

Swing в Java является частью базового класса Java, который является независимым от платформы. Он используется для создания оконных приложений и включает в себя такие компоненты, как кнопка, полоса прокрутки, текстовое поле и т. д.

Объединение всех этих компонентов создает графический интерфейс пользователя.

Swing в Java – это легкий инструментарий с графическим интерфейсом, который имеет широкий спектр виджетов для создания оптимизированных оконных приложений. Это часть JFC (Java Foundation Classes). Он построен на основе AWT API и полностью написан на Java. Он не зависит от платформы в отличие от AWT и имеет легкие компоненты.

Создавать приложения становится проще, поскольку у нас уже есть компоненты GUI, такие как кнопка, флажок и т. д.

Контейнерный класс

Любой класс, в котором есть другие компоненты, называется контейнерным классом. Для создания приложений с графическим интерфейсом необходим как минимум один класс контейнеров.

Ниже приведены три типа контейнерных классов:

1. Панель – используется для организации компонентов в окне.
2. Рамка – полностью функционирующее окно со значками и заголовками.
3. Диалог – это как всплывающее окно, но не полностью функциональное, как рамка.

Разница между AWT и Swing

Иерархия

Объяснение: Все компоненты в свинге, такие как JButton, JComboBox, JList, JLabel, унаследованы от класса JComponent, который можно добавить в классы контейнера.

Контейнеры – это окна, такие как рамка и диалоговые окна. Основные компоненты являются строительными блоками любого графического приложения. Такие методы, как setLayout, переопределяют макет по умолчанию в каждом контейнере. Контейнеры, такие как JFrame и JDialog, могут добавлять только компонент к себе. Ниже приведены несколько компонентов с примерами, чтобы понять, как мы можем их использовать.

JButton Class

Он используется для создания помеченной кнопки. Использование ActionListener приведет к некоторым действиям при нажатии кнопки. Он наследует класс AbstractButton и не зависит от платформы.

Пример:

import javax.swing.*;
public class example{
public static void main(String args[]) {
JFrame a = new JFrame("example");
JButton b = new JButton("click me");
b.setBounds(40,90,85,20);
a.add(b);
a.setSize(300,300);
a.setLayout(null);
a.setVisible(true);
}
}

JTextField Class

Он наследует класс JTextComponent и используется для редактирования однострочного текста.

Пример:

import javax.swing.*;
public class example{
public static void main(String args[]) {
JFrame a = new JFrame("example");
JTextField b = new JTextField("edureka");
b.setBounds(50,100,200,30);
a.add(b);
a.setSize(300,300);
a.setLayout(null);
a.setVisible(true);
}
}

JScrollBar Class

Он используется для добавления полосы прокрутки, как горизонтальной, так и вертикальной.

Пример:

import javax.swing.*;
class example{
example(){
JFrame a = new JFrame("example");
JScrollBar b = new JScrollBar();
b.setBounds(90,90,40,90);
a.add(b);
a.setSize(300,300);
a.setLayout(null);
a.setVisible(true);
}
public static void main(String args[]){
new example();
}
}

JPanel Class

Он наследует класс JComponent и предоставляет пространство для приложения, которое может присоединить любой другой компонент.

import java.awt.*;
import javax.swing.*;
public class Example{
Example(){
JFrame a = new JFrame("example");
JPanel p = new JPanel();
p.setBounds(40,70,200,200);
JButton b = new JButton("click me");
b.setBounds(60,50,80,40);
p.add(b);
a.add(p);
a.setSize(400,400);
a.setLayout(null);
a.setVisible(true);
}
public static void main(String args[])
{
new Example();
}
}

Вывод:

JMenu Class

Он наследует класс JMenuItem и является компонентом выпадающего меню, которое отображается из строки меню.

import javax.swing.*;
class Example{
JMenu menu;
JMenuItem a1,a2;
Example()
{
JFrame a = new JFrame("Example");
menu = new JMenu("options");
JMenuBar m1 = new JMenuBar();
a1 = new JMenuItem("example");
a2 = new JMenuItem("example1");
menu.add(a1);
menu.add(a2);
m1.add(menu);
a.setJMenuBar(m1);
a.setSize(400,400);
a.setLayout(null);
a.setVisible(true);
}
public static void main(String args[])
{
new Example();
}
}

Вывод:

Класс JList

Он наследует класс JComponent, объект класса JList представляет список текстовых элементов.

import javax.swing.*;
public class Example
{
Example(){
JFrame a  = new JFrame("example");
DefaultListModel<String> l = new DefaultListModel< >();
l.addElement("first item");
l.addElement("second item");
JList<String> b = new JList< >(l);
b.setBounds(100,100,75,75);
a.add(b);
a.setSize(400,400);
a.setVisible(true);
a.setLayout(null);
}
public static void main(String args[])
{
new Example();
}
}

Вывод:

JLabel Class

Используется для размещения текста в контейнере. Он также наследует класс JComponent.

import javax.swing.*;
public class Example{
public static void main(String args[])
{
JFrame a = new JFrame("example");
JLabel b1;
b1 = new JLabel("edureka");
b1.setBounds(40,40,90,20);
a.add(b1);
a.setSize(400,400);
a.setLayout(null);
a.setVisible(true);
}
}

Вывод:

JComboBox Class

Он наследует класс JComponent и используется для отображения всплывающего меню выбора.

import javax.swing.*;
public class Example{
JFrame a;
Example(){
a = new JFrame("example");
string courses[] = { "core java","advance java", "java servlet"};
JComboBox c = new JComboBox(courses);
c.setBounds(40,40,90,20);
a.add(c);
a.setSize(400,400);
a.setLayout(null);
a.setVisible(true);
}
public static void main(String args[])
{
new Example();
}
}  

Вывод:

Для размещения компонентов внутри контейнера мы используем менеджер макета. Ниже приведены несколько менеджеров макетов:

Макет границы

Менеджер по умолчанию для каждого JFrame – BorderLayout. Он размещает компоненты в пяти местах: сверху, снизу, слева, справа и по центру.

Макет потока

FlowLayout просто кладет компоненты в ряд один за другим, это менеджер компоновки по умолчанию для каждого JPanel.

GridBag Layout

GridBagLayout размещает компоненты в сетке, что позволяет компонентам охватывать более одной ячейки.

Пример: фрейм чата

import javax.swing.*;
import java.awt.*;
class Example {
    public static void main(String args[]) {

      
        JFrame frame = new JFrame("Chat Frame");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setSize(400, 400);

        JMenuBar ob = new JMenuBar();
        JMenu ob1 = new JMenu("FILE");
        JMenu ob2 = new JMenu("Help");
        ob.add(ob1);
        ob.add(ob2);
        JMenuItem m11 = new JMenuItem("Open");
        JMenuItem m22 = new JMenuItem("Save as");
        ob1.add(m11);
        ob1.add(m22);

        
        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);
        JTextArea ta = new JTextArea();

        frame.getContentPane().add(BorderLayout.SOUTH, panel);
        frame.getContentPane().add(BorderLayout.NORTH, tf);
        frame.getContentPane().add(BorderLayout.CENTER, ta);
        frame.setVisible(true);
    }
}

Это простой пример создания GUI с использованием Swing в Java.