Как сделать окно на весь экран в java
Обновлено: 28.04.2024
Окна являются основой пользовательского интерфейса любой операционной системы. Они визуально разделяют выполняемые в среде приложения. Окна, используемые в библиотеке Swing, мало чем отличаются от окон библиотеки AWT, которые представляют собой окна операционной системы.
Все окна библиотеки Swing — а к ним относятся окно без рамки JWindow, окно с рамкой JFrame и диалоговое окно JDialog — являются исключением из правила, согласно которому все компоненты Swing представляют собой легковесные компоненты и унаследованы от базового класса JComponent. Окна Swing являются тяжеловесными контейнерами для размещения в них легковесных компонентов, которые операционная система не видит.
Наиболее полезные JFrame методы
| Методы | Описание |
|---|---|
| setLocation() | Эта группа методов позволяет задать позицию и размеры окна на экране. setLocation() задает позицию окна, setSize() позволяет указать его размеры, а с помощью setBounds() можно сразу задать прямоугольник, который займет ваше окно на экране |
| setSize() | |
| setBounds() | |
| раск() | Позволяет «упаковать» имеющиеся в окне компоненты, так чтобы они занимали столько места, сколько им необходимо. Компоненты при вызове этого метода переходят в «видимое» состояние, хотя и не появляются на экране до вызова одного из следующих методов |
| show() | Отображение окна на экране. После вызова этих методов компоненты переходят в «видимое» состояние и начинают обслуживаться очередью событий. Метод show() к тому же проводит валидацию содержащихся в окне компонентов |
| setVisible() | |
| dispose() | Убирает окно с экрана (если оно в момент вызова метода видимо) и освобождает все принадлежащие ему ресурсы. |
Окно JWindow
«Родителем» всех окон Swing является окно без рамки и без элементов управления JWindow.
Класс JWindow представляет собой окно без рамки и без элементов управления, предназначенных, к примеру, для его закрытия или перемещения. Данный тип окна дает минимальные возможности по своей настройке, в отличие от чаще всего используемого окна JFrame. Окно без рамки не часто требуется в программах. Однако в отдельных случаях оно может быть полезно, особенно в тех случаях, когда необходимо ненадолго вывести на экран какую-либо информацию типа заставки программы или подсказку для пользователя, и управлять окном с этой информацией не нужно.
Окна JWindow используются всплывающими меню JPopupMenu в тех ситуациях, когда в окне приложения не хватает места для размещения легковесного компонента в слое POPUP_LAYER многослойной панели, где всплывающие меню располагаются по умолчанию. В такой ситуации вместо легковесного компонента создается небольшое окно без рамки JWindow, которое можно разместить в любом месте экрана, потому что оно принадлежит операционной системе. В этом окне и размещается всплывающее меню.
Рассмотрим пример JWindowTest. Основная идея использования окна без рамки JWindow заключается в копировании части "изображения рабочего стола" в окно приложения. Благодаря появившемуся в пакете JDK 1.3 классу Robot можно "снимать" экранную копию рабочего стола.
Пример JWindow
В этом примере приложение наследуем от окна 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 пример
В примере создается окно 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, как это представлено в следующих строках кода :
При выходе из программы открывается диалоговое окно в панели JOptionPane и у пользователя спрашивается подтверждение, действительно ли он желает закончить работу с приложением. Если ответ положительный, то программа завершает работу.
Диалоговое окно JDialog
Диалоговые окна чаще всего используются в приложениях для получения дополнительной информации с целью установки параметров приложения, вывода важной вспомогательной/отладочной информации. Диалоговые окна, как правило, создаются модальными (modal), блокирующими доступ к остальным окнам приложения, пока пользователь не закончит работу с модальным диалоговым окном. Модальные диалоговые окна располагаются поверх основного окна приложения. Внешний вид диалоговых окон мало отличается от окон с рамкой JFrame, но обычно у них меньше элементов управления окна (чаще всего, имеется только кнопка закрытия окна) и отсутствует системное меню.
В Swing диалоговые окна реализуются классом JDialog, унаследованном от базового класса окон JWindow и позволяющим создавать как обычные, так и модальные диалоговые окна. JDialog поддерживает как и JFrame закрытие окна, а в остальном сходен с другими окнами Swing.
При создании диалоговых окон Swing необходимо указать «родительское окно», которым может быть окно с рамкой JFrame или другое диалоговое окно JDialog. Имеется также конструктор, не требующий «родительского» окна, но использующий вспомогательное прозрачное окно, о котором было сказано на странице «Окно без рамки JWindow».
JDialog пример создания диалоговых окон
В примере создаем окно с рамкой JFrame, в панели содержимого которого размещается две кнопки JButton. По нажатию на кнопки создаются диалоговые окна в отдельном методе createDialog(). Диалоговое окно с заданным заголовком JDialog может быть модальным и немодальным. Программа позволяет создать несколько немодальных окон одновременно, но только одно модальное. Немодальные окна не блокируют работу с основным окном приложения. При закрытии диалогового окна используется константа DISPOSE_ON_CLOSE, удаляющую окно после закрытия.
Интерфейс работы примера JDialog представлен на следующем скриншоте.
Библиотека Swing предоставляет набор стандартных диалоговых окон JDialog для получения и вывода несложной информации. Прежде чем создавать собственное диалоговое окно, следует рассмотреть возможность использования стандартного.
Оформление окон
Начиная с JDK 1.4 появилась возможность настраивать так называемое визуальное «оформление» окон: рамка, элементы управления окном (кнопки закрытия или свертывания), системное меню. Необходимость этого ощущалась с самых первых выпусков Swing.
Сейчас создание различных интерфейсов окон возможна благодаря усовершенствованиям в UI-представителе корневой панели JRootPane. UI-представитель позволяет создавать специальные рамки, заголовок, системное меню и кнопки управления окном, и размещать их в корневой панели нужным образом, используя специализированный менеджер расположения. Менеджер расположения контролирует пространство корневой панели. Кроме этого, при новом оформлении окон отключаются системные элементы окна.
В классах JFrame и JDialog имеется статический метод setDefaultLookAndFeelDecorated(), обеспечивающий возможность оформления всех создаваемых окон.
Пример оформления окон : JDialog decoration
В примере создается простое окно с рамкой и диалоговое окно. Перед создания окон вызывается метод setDefaultLookAndFeelDecorated(), означающий, что для создаваемых окон JFrame и JDialog потребуется специальное оформление. Далее определяются размеры окон и они выводятся на экран.
Интерфейс примера окон, оформленных с внешним видом Metal, представлен на следующем скриншоте.
Специальное оформление окон может быть полезно как средство, позволяющее полностью, вплоть до окон, управлять внешним видом вашего приложения. Создав собственного UI-представителя корневой панели, можно придать своему приложению уникальный вид, легко узнаваемый пользователями.
Исходные коды примеров, рассмотренных в тексте страницы, можно скачать здесь (3.54 Кб).
какой самый простой способ центрировать a java.awt.Window , например, JFrame или JDialog ?
Если вы используете Java 1.4 или более поздняя, вы можете использовать простой метод setLocationRelativeTo (null) на диалоговое окно, рамка или окно в центр он.
Это должно работать во всех версиях Java
обратите внимание, что как setLocationRelativeTo (null), так и Tookit.getDefaultToolkit().методы getScreenSize () работают только для основного монитора. Если вы находитесь в среде с несколькими мониторами, вам может потребоваться получить информацию о конкретном мониторе, на котором находится окно, перед выполнением такого рода вычислений.
иногда важно, иногда нет.
посмотреть GraphicsEnvironment javadocs для получения дополнительной информации о том, как сделать это.
setLocationRelativeTo (null) следует вызывать после использования setSize(x,y) или pack ().
окно в случайном месте каждый раз, когда я запустил его, в среде нескольких дисплеев. И код
"вырезать" окно пополам с размещением его в точном центре, который находится между моими двумя дисплеями. Я использовал следующий метод, чтобы центрировать его:
окно появляется прямо в центре первого дисплея. Вероятно, это не самое простое решение.
работает должным образом на Linux, Windows и Mac.
я, наконец, получил эту кучу кодов для работы в NetBeans, используя формы Swing GUI, чтобы центрировать главный jFrame:
следующее не работает для JDK 1.7.0.07:
Он помещает верхний левый угол в центр - не то же самое, как центрирование окна. Другой тоже не работает, включая фрейм.getsize не() и размер.getsize не():
метод getSize () наследуется от класса Component и, следовательно, frame.getSize также возвращает размер окна. Таким образом, вычитание половины вертикальных и горизонтальных размеров из вертикальных и горизонтальные размеры, чтобы найти координаты x,y, где разместить верхний левый угол, дает вам местоположение центральной точки, которая в конечном итоге центрирует окно. Однако первая строка вышеуказанного кода полезна: "измерение. ". Просто сделайте это, чтобы центрировать его:
JLabel устанавливает размер экрана. Это в FrameDemo.java доступен в учебниках java на сайте Oracle / Sun. Я установил его на половину высоты/ширины экрана. Затем я центрировал его, помещая верхний левый на 1/4 размера размера экрана слева и 1/4 размера размера экрана сверху. Вы можете использовать аналогичную концепцию.
ниже приведен код для отображения рамки в верхнем центре существующего окна.
> public static void main (String[] args) выдает исключение
Ниже приведен вывод вышеуказанного фрагмента кода:
Он отобразит графику в окне. Было бы удобно, если я использую JFrame или что-то подобное.
Я не знаю, какое окончательное разрешение экрана будет. Скажите, пожалуйста, если графики будут автоматически перемасштабированы?
ОТВЕТЫ
Ответ 1
Ответ 2
Если вы хотите перевести рамку в полноэкранный режим (например, в полноэкранный фильм), проверьте эти ответы.
Классы java.awt.GraphicsEnvironment и java.awt.GraphicsDevice используются для перевода приложения в полноэкранный режим на одном экране (диспозитив).
Ответ 3
Ответ 4
Один из способов - использовать расширенное состояние. Это требует, чтобы базовая ОС максимизировала JFrame.
Другим подходом было бы вручную увеличить экран для вас.
Но у этого есть подводные камни в ОС Ubuntu. Работа, которую я нашел, была такой.
В Fedora вышеуказанной проблемы нет. Но есть сложности, связанные с Gnome или KDE. Так что будьте осторожны. Надеюсь, это поможет.
Ответ 5
Просто используйте этот код:
Надеюсь, это поможет.
Ответ 6
Самое простое решение:
Ответ 7
это поможет вам использовать мгновенный объект фрейма
Ответ 8
Прежде всего, это разрешение, которое вы хотели бы использовать, 1650,1080 .
Если у вас есть проблемы с компонентами в JFrame, то после добавления всех компонентов с помощью frame.add(component) добавьте следующий оператор.
Ответ 9
Значения выделены, что я имею в виду:
Ответ 10
Вам нужно только это:
Когда вы используете модификатор MAXIMIZED_BOTH, он будет максимальным по всему окну (высота и ширина).
Есть некоторые, которые предложили использовать это:
Я не буду рекомендовать это, потому что у вашего окна не будет заголовка, поэтому нет кнопки закрытия/восстановления/сворачивания.
Как каждое нормальное окно, JFrame имеет кнопки для управления размерами окна, а также для его закрытия. Эти кнопки располагаются в правом верхнем углу заголовка окна JFrame. Здесь есть кнопка минимизации окна, при нажатии на которую окно сворачивается. Имеется кнопка максимизации размеров окна, когда JFrame разворачивается на весь экран. Как только окно развернуто, появляется кнопка возврата к «нормальному» размеру окна до разворачивания. Ну и последняя кнопка – это закрытие окна. Интересно то, что для выполнения этих задач разработчик может использовать специальные методы JFrame. Рассмотрим, как можно сворачивать, разворачивать и закрывать окно, используя эти методы.
Для того, чтобы свернуть окно, используется метод setState с параметром JFrame.ICONIFIED. Чтобы развернуть окно на весь дисплей вызывается метод setExtendedState с параметром JFrame.MAXIMIZED_BOTH. Для восстановления нормального размера после того, как окно было развернуто, вызываем всё тот же setExtendedState, но только с параметром JFrame.NORMAL. Далее в случае, если потребуется скрыть окно, используем setVisible с параметром false. Если окно, которое мы хотим скрыть, является главным окном приложения, то при скрытии окна потребуется осуществить выход из приложения. Например, у нас есть пункт главного меню «Выход», при выборе которого нужно выйти из приложения, то тогда можно сразу вызвать System.exit(0).
Ну и для демонстрации вышеописанных методов предлагаю код приложения, внешний вид которого представлен на рисунке.
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
public class TestFrame
public static void createGUI() JFrame.setDefaultLookAndFeelDecorated(true);
final JFrame frame = new JFrame(«Test frame»);
JPanel panel = new JPanel();
panel.setLayout(new FlowLayout());
JButton minButton = new JButton(«Minimize»);
minButton.addActionListener(new ActionListener() public void actionPerformed(ActionEvent e) frame.setState(JFrame.ICONIFIED);
>
>);
panel.add(minButton);
JButton maxButton = new JButton(«Maximize»);
maxButton.addActionListener(new ActionListener() public void actionPerformed(ActionEvent e) frame.setExtendedState(JFrame.MAXIMIZED_BOTH);
>
>);
panel.add(maxButton);
JButton normalButton = new JButton(«Normal»);
normalButton.addActionListener(new ActionListener() public void actionPerformed(ActionEvent e) frame.setExtendedState(JFrame.NORMAL);
>
>);
panel.add(normalButton);
JButton exitButton = new JButton(«Exit»);
exitButton.addActionListener(new ActionListener() public void actionPerformed(ActionEvent e) frame.setVisible(false);
System.exit(0);
>
>);
panel.add(exitButton);
frame.getContentPane().add(panel);
frame.setPreferredSize(new Dimension(400, 80));
frame.pack();
frame.setLocationRelativeTo(null);
frame.setVisible(true);
>
public static void main(String[] args) javax.swing.SwingUtilities.invokeLater(new Runnable() public void run() createGUI();
>
>);
>
>
Основой для создания графического интерфейса в JavaFX является класс javafx.stage.Stage . По сути он является контейнером, в который помещаются все остальные компоненты интерфейса. Его конкретная реализация зависит от платформы, на которой запускается приложение. Так, на десктопах это будет отдельное графическое окно, а на мобильных устройствах интерфейс может представлять весь экран устройства.
В программе на JavaFX можно использовать множество объектов Stage, но один из них является основным. При запуске приложения основной объект Stage создается средой JavaFX и передается в метод start() :
Этот объект Stage определяет главное окно или экран программы. Однако внутри приложения мы также можем создавать другие объекты Stage - другие графические окна.
Класс Stage унаследован от класса javafx.stage.Window , который опредляет базовые возможности окна приложения.
Stage позволяет управлять позиционированием, размерами и некоторыми другими настройками окна приложения. Рассмотрим некоторые основные методы класса Stage:
close() : закрывает объект Stage (на десктопах по сути закрывает окно)
hide() : cкрывает окно
centerOnScreen() : располагает окно в центре экрана
toBack() : перемещает окно на задний план
toFront() : перемещает окно на передний план
sizeToScene() : устанавливает размеры окна в соответствии с размерами содержимого объекта Scene
show() : отображает окно
getX() : возвращает x-координату окна
getY() : возвращает y-координату окна
getWidth() : возвращает ширину
getHeight() : возвращает высоту
getScene() : возвращает объект Scene окна
getOpacity() : возвращает значение прозрачности
getTitle() : возвращает заголовок
getMaxHeight() : возвращает максимальную высоту
getMaxWidth() : возвращает максимальную ширину
getMinHeight() : возвращает минимальную высоту
getMinWidth() : возвращает минимльную ширину
getStyle() : возвращает стиль окна в виде объекта StagesStyle
getModality() : возвращает модальность окна в виде объекта Modality
getOwner() : возвращает родительское окно в виде объекта Window, которое владеет текущим окном
getTitle() : возвращает заголовок
initModality(Modality modality) : устанавливает модальность окна
initOwner(Window owner) : устанавливает родительское окно
initStyle(StageStyle style) : устанавливает стиль окна
setAlwaysOnTop(boolean value) : при передаче значения true окно будет всегда располагаться поверх других окон
setFullScreen(boolean value) : при передаче значения true окно раскрывается на весь экран
setOpacity(double value) : устанавливает прозрачность
setResizable(boolean value) : при передачи значения true позволяет изменять размеры окна (растягивать его и сжимать)
setScene(Scene value) : устанавливает сцену (объект Scene) для объекта Stage
setTitle(String value) : устанавливает заголовок окна
setMaxHeight(double value) : устанавливает максимальную высоту
setMaxWidth(double value) : устанавливает максимальную ширину
setMinHeight(double value) : устанавливает минимальную высоту
setMinWidth(double value) : устанавливает минимальную ширину
setHeight(double value) : устанавливает высоту окна
setWidth(double value) : устанавливает ширину окна
setX(double value) : устанавливает координату X окна, то есть положение по горизонтали
setY(double value) : устанавливает координату Y окна, то есть положение по вертикали
Читайте также: