Introdução ao BorderLayout em Java
O BorderLayout em Java ou o gerenciador de layout é um objeto que todo objeto de contêiner possui, que controla seu layout, ou seja, o tamanho e a posição dos componentes. Na linguagem leiga, esses gerenciadores de layout são usados para organizar os componentes de uma maneira particular ou específica. 'LayoutManager' pode ser dito como uma interface implementada por todas as suas classes. Existem algumas classes AWT e SWING que foram fornecidas como gerenciadores de layout para uso geral. Alguns deles estão listados abaixo:
- BorderLayout
- BoxLayout
- SpringLayout
- FlowLayout
- GroupLayout
- GridLayout, etc
Antes de passar para BorderLayout, vamos supor discutir alguns pontos.
Quase tudo no mundo dos computadores é organizado hierarquicamente, para melhor armazenamento ou para criar um sistema de recuperação fácil. Os gerenciadores de layout usados para criar GUIs usando as classes AWT disponíveis fazem parte de um desses sistemas hierárquicos. Tem o nome Hierarquia de Contenção. Embora o foco deste artigo seja um dos LayoutManager disponíveis, conhecido como BorderLayout, antes disso, devemos saber onde fica o BorderLayout nesta Hierarquia. Nossa estrutura em árvore que percorre quadros, componentes da GUI, contêineres etc. Começa com:
- Primeiro, um contêiner de nível superior ou uma classe de contêiner de nível superior, como JFrame, JApplet ou JDialog, que atua como o 'ROOT' dessa hierarquia de contenção.
- Segundo, para que um componente apareça como um componente da GUI na tela, ele deve ser incluído na hierarquia de contenção.
- Terceiro, um componente precisa estar ou estará contido apenas em um contêiner.
- Quarto, cada contêiner de nível superior terá um painel de conteúdo, falando livremente, todas as GUI visíveis (direta ou indiretamente) estão contidas nesse painel de conteúdo.
O que é BorderLayout?
Uma classe BorderLayout é uma das classes do gerenciador de layout que é considerada o layout padrão dos objetos da janela. Os objetos da janela, como JFrame, JWindow, JDialog, usam essa classe para serem exibidos como componentes da GUI. BorderLayout é usado para fazer o layout de um contêiner, ou seja, organizar e redimensionar seus componentes. O layout da borda organiza esses componentes em cinco regiões diferentes. Das cinco, quatro regiões ou áreas são chamadas de norte, sul, leste e oeste, e a região do meio é chamada de centro. Cada região pode conter apenas um componente. O layout da borda fornece uma coleção de constantes usadas para posicionar componentes. As regiões discutidas aqui identificadas por uma constante correspondente denominada NORTE, SUL, ORIENTE, OESTE e a constante para a região do meio como CENTRO. Usamos essas constantes ao adicionar um componente usando um layout de borda. As constantes para cada região usada em nosso código estão listadas abaixo:
- public static final int NORTE: A constante de layout Norte na parte superior do contêiner.
- public static final int SUL: A constante de layout sul na parte inferior do contêiner.
- public static final int CENTRE: O layout do centro constante no meio do contêiner.
- public static final int WEST: a constante West do layout à direita do contêiner.
- public static final int EAST: a constante de layout Leste à esquerda do contêiner.
Além das constantes listadas acima, o BorderLayout também fornece outras constantes de posicionamento, como PAGE_START, PAGE_END etc.
Construtores BorderLayout
Os construtores BorderLayout são usados para criar novos layouts de borda com intervalos ou sem intervalos entre os componentes. O construtor de layout de borda usa parâmetros de espaço e espaço para especificar espaços horizontais e verticais entre os componentes. Os construtores de layout de borda são discutidos abaixo:
Vamos discuti-los um por um, juntamente com seus exemplos.
1. BorderLayout ()
A classe BorderLayout é usada para criar um layout de borda, mas sem intervalos entre os componentes. A seguir está um código de exemplo usando o construtor BorderLayout (). O programa a seguir cria componentes em um JFrame cuja classe de instância é 'border'. Você pode ver na imagem abaixo (após o código), existem cinco regiões.
Nosso código criou cinco regiões usando cinco JButton e, em seguida, elas são adicionadas ao layout ou JFrame usando um método add (). O tamanho e a visibilidade são determinados separadamente para o JFrame. O método setSize () é usado para definir o tamanho do quadro e o método set visible () está sendo usado para definir a visibilidade do quadro.
Código
//Java Program illustrating the BorderLayout
import java.awt.*;
import javax.swing.*;
public class border
(
JFrame JF;
border()
(
JF=new JFrame(); //JFrame object
//Lying at top, will be the button named 'North'
JButton b1=new JButton("NORTH");
//Lying at bottom, will be the button named 'South'
JButton b2=new JButton("SOUTH");
//Lying at left, will be the button named 'East'
JButton b3=new JButton("EAST");
//Lying at right, will be the button named 'West'
JButton b4=new JButton("WEST");
//In the center, will be the button named 'Center'
JButton b5=new JButton("CENTER");
//Adding our buttons
JF.add(b1, BorderLayout.NORTH);
JF.add(b2, BorderLayout.SOUTH);
JF.add(b3, BorderLayout.EAST);
JF.add(b4, BorderLayout.WEST);
JF.add(b5, BorderLayout.CENTER);
//Function to set size of the Frame
JF.setSize(300, 300);
//Function to set visible status of the frame
JF.setVisible(true);
)
//Driver Code
public static void main(String() args)
(
//Calling the constructor
new border();
)
)
Na captura de tela abaixo, você pode ver como o código se parece no editor de texto. Eu usei o Eclipse como meu editor de texto.
Quando o código é executado, a seguinte saída é exibida.
Resultado:
2. BorderLayout (int hgap, int vgap)
BorderLayout (int hgap, int vgap) também é gravado como BorderLayout (int, int) é usado para criar um layout de borda com os intervalos ou espaços horizontais (hgap) e verticais (vgap) entre os seguintes é um código de exemplo usando BorderLayout ( int, int) construtor. O programa a seguir cria componentes em um JFrame cuja classe de instância é 'border' de maneira semelhante à anterior, mas com lacunas verticais e horizontais. Você pode ver na imagem abaixo (após o código).
Nosso código criou cinco regiões com intervalos entre elas usando os parâmetros vgap e hgap em BorderLayout (). O tamanho e a visibilidade são novamente determinados separadamente para o JFrame. O método setSize () é usado para definir o tamanho do quadro e o método set visible () está sendo usado para definir a visibilidade do quadro.
Você pode ver o código para gerar um quadro usando BorderLayout com os parâmetros vgap e hgap, criando espaços ou espaços entre as regiões é mostrado abaixo:
Código
//Java Program illustrating the BorderLayout with SPACES between COMPONENTS
import java.awt.*;
import javax.swing.*;
import java.awt.BorderLayout;
import java.awt.Color;
public class borderlayout_spaces extends Frame
(
public borderlayout_spaces(String title)
(
super(title);
setLayout(new BorderLayout(20, 30));
//setBackground(Color.RED);
//Lying at top, will be the button named 'North'
JButton b1=new JButton("North");
add(b1, BorderLayout.NORTH);
//Lying at left, will be the button named 'East'
JButton b2=new JButton("EAST");
add(b2, BorderLayout.EAST);
//In the center, will be the button named 'Center'
JButton b3=new JButton("CENTER");
add(b3, BorderLayout.CENTER);
//Lying at right, will be the button named 'West'
JButton b4=new JButton("WEST");
add(b4, BorderLayout.WEST);
//Lying at bottom, will be the button named 'South'
JButton b5=new JButton("SOUTH");
add(b5, BorderLayout.SOUTH);
)
//Driver Code
public static void main(String() args)
(
//Calling the constructor
borderlayout_spaces screen =
new borderlayout_spaces("Border Layout");
screen.setSize(300, 300); //Function to set size of the Frame
screen.setVisible(true); //Function to set visible status of
the frame
)
)
Na captura de tela abaixo, você pode ver como o código se parece no editor de texto.
A linha de código "setLayout (novo BorderLayout (20, 30)))" define a saída como a imagem mostrada abaixo. Aqui 20 é o espaço horizontal e 30 representa o espaço vertical.
Quando o código é executado, a seguinte saída é exibida.
Resultado:
Além disso, você pode tentar outras propriedades, por exemplo, definir a cor do plano de fundo. No código acima, se você vir uma linha de código comentada como "setBackground (Color.RED);" se você tentar esse código com essa linha descomentada, seu quadro será exibido abaixo:
Existem outros métodos comumente usados ao lado do layout da borda, como:
- toString (): Retorna uma string que é uma representação do estado do layout da borda.
- getVgap (): retorna o espaço vertical entre o componente.
- getHgap (): retorna o espaço horizontal entre o componente.
- setVgap (int vgap): É usado para definir o espaço vertical entre o componente.
- setHgap (int hgap): é usado para definir o espaço horizontal entre os componentes, etc.
Este artigo discutiu alguns dos poderosos LayoutManagers usados para organizar seus quadros e GUIs do Windows. O artigo também abordou a criação de layouts de código usando dois construtores diferentes, conhecidos como classe java.awt.BorderLayout e classe java.awt.BorderLayout (int, int) manualmente, o que poderia ser um desafio. Mas você deve tentar desistir. Caso contrário, você pode tentar usar o gerenciador de layout java.awt.GroupLayout. Você pode usar uma ferramenta de construção também junto com seu gerenciador de layout, por exemplo, o NetBeans IDE, que é uma ótima ferramenta para criar sua GUI.
Artigos recomendados
Este é um guia para o BorderLayout em Java. Aqui discutimos uma introdução ao BorderLayout em Java, BorderLayout Constructors com códigos e saídas. Você também pode consultar nossos outros artigos relacionados para saber mais.
- Layout em Java
- Layout de grade em Java
- Variáveis em Java
- Copiar Construtor em Java
- Layout HTML