Как создать интерфейс для программы на java

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

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

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

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

«Создание графического интерфейса в приложении на Java»

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

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

события

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

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

Для обработки событий элемента в нем необходимо зарегистрировать объект обработчик

КАКИЕ ЕСТЬ ГРАФИЧЕСКИЕ БИБЛИОТЕКИ НА JAVA? GUI НА JAVAFX

в числе слушателей. Делается это методами типа 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 в проект со шаблоном, подправить шаблон и запустить его.

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

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

Менеджеры компоновки используются для автоматического позиционирования и задания размеров дочерних элементов в контейнере. Компоновщиком является любой объект реализующий интерфейс 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); // добавляем ящик влево >>

Источник: pro-prof.com

Руководство по Java Swing

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

Библиотека Swing построена на основе Java Abstract Widget Toolkit (AWT), более старого, зависимого от платформы инструментария GUI. Вы можете использовать компоненты библиотеки Java, такие как кнопка, текстовое поле и т. д. из библиотеки, и вам не нужно создавать компоненты с нуля.

Все компоненты в Swing являются JComponent, который может быть добавлен к классам контейнера.

Что такое контейнерный класс?

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

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

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

Пример: Чтобы научиться проектировать GUI в Java.

Шаг 1) Скопируйте следующий код в редактор

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

Шаг 2) Сохраните, скомпилируйте и запустите код.

Шаг 3) Теперь давайте добавим кнопку в наш фрейм. Скопируйте следующий код в редактор

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

Шаг 4) Выполнив код, вы получите большую кнопку.

Шаг 5) Как насчет добавления двух кнопок? Скопируйте следующий код в редактор.

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

Шаг 6) Сохраните, скомпилируйте и запустите программу.

Шаг 7) Неожиданный вывод =? Кнопки перекрываются.

Менеджер макетов используется для компоновки (или упорядочивания) компонентов JAVA GUI внутри контейнера. Существует много менеджеров макетов, но наиболее часто используемые из них-

Java BorderLayout – BorderLayout помещает компоненты в пять областей: верхнюю, нижнюю, левую, правую и центральную. Это менеджер макетов по умолчанию для каждого Java JFrame.

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

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

Шаг 8) Как насчет создания фрейма чата, как показано ниже?

Попробуйте написать код, прежде чем смотреть на программу ниже.

//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(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-blog.ru

Основы создания интерфейса

Графический интерфейс пользователя представляет собой иерархию объектов android.view.View и android.view.ViewGroup . Каждый объект ViewGroup представляет контейнер, который содержит и упорядочивает дочерние объекты View . В частности, к контейнерам относят такие элементы, как RelativeLayout, LinearLayout, GridLayout, ConstraintLayout и ряд других.

Простые объекты View представляют собой элементы управления и прочие виджеты, например, кнопки, текстовые поля и т.д., через которые пользователь взаимодействует с программой:

Большинство визуальных элементов, наследующихся от класса View, такие как кнопки, текстовые поля и другие, располагаются в пакете android.widget

При определении визуального у нас есть три стратегии:

• Создать элементы управления программно в коде java
• Объявить элементы интерфейса в XML
• Сочетание обоих способов — базовые элементы разметки определить в XML, а остальные добавлять во время выполнения

Сначала рассмотрим первую стратегию — определение интерейса в коде Java.

Создание интерфейса в коде java

Для работы с визуальными элементами создадим новый проект. В качестве шаблона проекта выберем Empty Activity :

Пусть он будет называться ViewsApp:

И после создания проекта два основных файла, которые будут нас интересовать при создании визуального интерфейса — это класс MainActivity и определение интерфейса для этой activity в файле activity_main.xml .

Определим в классе MainActivity простейший интерфейс:

При создании виджетов в коде Java применяется их конструктор, в который передается контекст данного виджета, а точнее объект android.content.Context , в качестве которого выступает текущий класс MainActivity.

TextView textView = new TextView(this);

Здесь весь интерфейс представлен элементом TextView, которое предназначено для выводa текста. С помощью методов, которые, как правило, начинаются на set , можно установить различные свойства TextView. Например, в данном случае метод setText() устанавливает текст в поле, а setTextSize() задает высоту шрифта.

Для установки элемента в качестве интерфейса приложения в коде Activity вызывается метод setContentView() , в который передается визуальный элемент.

Если мы запустим приложение, то получим следующий визуальный интерфейс:

Подобным образом мы можем создавать более сложные интерейсы. Например, TextView, вложенный в ConstraintLayout:

Для каждого контейнера конкретные действия по добавлению и позиционированию в нем элемента могут отличаться. В данном случае контейнеров выступает класс ConstraintLayout, поэтому для определения позиционирования и размеров элемента необходимо создать объект ConstraintLayout.LayoutParams . (Для LinearLayout это соответственно будет LinearLayout.LayoutParams, а для RelativeLayout — RelativeLayout.LayoutParams и т.д.). Этот объект инициализируется двумя параметрами: шириной и высотой. Для указания ширины и высоты можно использовать константу ViewGroup.LayoutParams.WRAP_CONTENT , которая устанавливает размеры элемента, необходимые для размещения а экране его содержимого.

Далее определяется позиционирование. В зависимости от типа контейнера набор устанавливаемых свойств может отличаться. Так, строка кода

layoutParams.leftToLeft = ConstraintLayout.LayoutParams.PARENT_ID;

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

layoutParams.topToTop = ConstraintLayout.LayoutParams.PARENT_ID;

указывает, что верхняя граница элемента будет выравниваться по верхней ганице контейнера. В итоге элемент будет размещен в левом верхнем углу ConstraintLayout.

Для установки всех этих значений для конкретного элемента (TextView) в его метод setLayoutParams() передается объект ViewGroup.LayoutParams (или один из его наследников, например, ConstraintLayout.LayoutParams).

textView.setLayoutParams(layoutParams);

Все классы контейнеров, которые наследуются от android.view.ViewGroup (RelativeLayout, LinearLayout, GridLayout, ConstraintLayout и т.д.), имеют метод void addView(android.view.View child) , который позволяет добавить в контейнер другой элемент — обычный виджет типа TextView или другой контейнер. И в данном случае посредством данного метода TextView добавляется в ConstraintLayout:

constraintLayout.addView(textView);

Опять же отмечу, что для конкретного контейнера конкретные действия могут отличаться, но как правило для всех характерно три этапа:

• Создание объекта ViewGroup.LayoutParams и установка его свойств
• Передача объекта ViewGroup.LayoutParams в метод setLayoutParams() элемента
• Передача элемента для добавления в метод addView() объекта контейнера

Хотя мы можем использовать подобный подход, в то же время более оптимально определять визуальный интерейс в файлах xml, а всю связанную логику определять в классе activity. Тем самым мы достигнем разграничения интерфейса и логики приложения, их легче будет разрабатывать и впоследствии модифицировать. И в следующей теме мы это рассмотрим.

Источник: metanit.com