Menu

Tutorial Java SWING: Container, Componentes e Manipulação de Eventos

  • Principal
  • De Outros
  • Tutorial Java SWING: Container, Componentes e Manipulação de Eventos

java swing tutorial container

Experimente Nosso Instrumento Para Eliminar Problemas

Este abrangente tutorial em vídeo Java Swing explica vários componentes da GUI Swing Framework e conceitos relacionados, como JPanel, JFrame, JButton, etc:

Usamos interfaces gráficas de usuário (comumente chamadas de GUI) para construir aplicativos que possuem uma interface visual, tornando mais fácil para o usuário usar o aplicativo.

Ter uma interface visual para um aplicativo torna o aplicativo fácil de navegar, usa os controles com mais eficiência e também é visualmente atraente para o usuário.

O Swing é usado principalmente para criar a GUI para aplicativos.

=> Visite aqui para ver a série de treinamento Java para todos.

Java SWING

O que você aprenderá:

Tutorial em vídeo sobre Java Swing

O que é Java Swing

Java fornece muitas estruturas de GUI que nos ajudam no desenvolvimento de uma variedade de aplicativos de GUI. Vimos um em nosso tutorial anterior, ou seja, Abstract Window Toolkit ou AWT. AWT é uma das estruturas GUI mais antigas em Java e também depende da plataforma. Outra desvantagem do AWT são seus componentes pesados.

Neste tutorial, discutiremos outra estrutura de GUI em Java, ou seja, “SWING”. A estrutura Swing em Java é uma parte das Java Foundation Classes ou comumente chamada de JFCs. JFC é uma API semelhante a MFCs (Microsoft Foundation Classes) em C ++. JFC contém Swing, AWT e Java2D.

A estrutura Swing em Java é construída em cima da estrutura AWT e pode ser usada para criar aplicativos GUI como AWT. Mas, ao contrário do AWT, os componentes do Swing são leves e independentes de plataforma.

A estrutura Swing é inteiramente escrita em Java. A estrutura Swing em Java é fornecida por meio do pacote ‘javax.swing’. As classes no pacote javax.swing começam com a letra ‘J’. Portanto, em um pacote javax.swing, teremos classes como JButton, JFrame, JTextField, JTextArea, etc.

Em geral, a API Swing tem todos os controles definidos no pacote javax.swing que está presente no AWT. Portanto, o swing de certa forma atua como um substituto do AWT. Além disso, o Swing possui vários painéis com guias de componentes avançados. A API Swing em Java adapta a arquitetura MVC (Model View Controller).

As principais características desta arquitetura são:

  • Os dados do componente de balanço são representados usando o modelo.
  • É representado visualmente por meio de uma visualização.
  • O componente controlador da arquitetura MVC lê a entrada do usuário na visualização e, em seguida, essas alterações são passadas para os dados do componente.
  • Em cada componente Swing, a visualização e o controlador são combinados, enquanto o modelo é separado. Isso dá ao swing um recurso de aparência plugável.

Os recursos da API swing estão resumidos abaixo.

  1. Os componentes do Swing são independentes da plataforma.
  2. A API é extensível.
  3. Os componentes do balanço são leves. Os componentes swing são escritos em Java puro e também os componentes são renderizados usando código Java em vez de chamadas de sistema subjacentes.
  4. A API Swing fornece um conjunto de controles avançados como TabbedPane, Tree, Colorpicker, controles de tabela, etc. que são ricos em funcionalidades.
  5. Os controles de swing são altamente personalizáveis. Isso ocorre porque a aparência ou aparência do componente é independente da representação interna e, portanto, podemos personalizá-lo da maneira que desejarmos.
  6. Podemos simplesmente alterar os valores e, assim, alterar a aparência e comportamento no tempo de execução.

Componentes Java Swing

O Swing tem um grande conjunto de componentes que podemos incluir em nossos programas e aproveitar as ricas funcionalidades com as quais podemos desenvolver aplicativos GUI altamente personalizados e eficientes.

Então, o que é um componente?

Um componente pode ser definido como um controle que pode ser representado visualmente e geralmente é independente. Ele tem uma funcionalidade específica e é representado como uma classe individual na API Swing.

Por exemplo, A classe JButton na API swing é um componente de botão e fornece a funcionalidade de um botão.

Um ou mais componentes formam um grupo e este grupo pode ser colocado em um “Container”. Um contêiner fornece um espaço no qual podemos exibir componentes e também gerenciar seu espaçamento, layout, etc.

Em Java, os contêineres são divididos em dois tipos, conforme mostrado abaixo:

Tipos de recipientes

Classes de Swing em Java

Uma hierarquia de API Swing em Java é mostrada abaixo:

Introdução às aulas de Swing

Como visto na hierarquia acima, temos classes de Container - frame, dialog, Panel, Applet, etc. Existem também classes de Component derivadas da classe JComponent da API Swing. Algumas das classes que herdam de JComponent são JLabel, JList, JTextBox, etc.

Algumas das classes importantes da API Swing são as seguintes:

  • JWindow: A classe JWindow do Swing herda a classe Window diretamente. A classe JWindow usa ‘BorderLayout’ como layout padrão.
  • JPanel: JPanel é um descendente da classe JComponent e está em linhas semelhantes à classe AWT Panel e tem ‘FlowLayout’ como layout padrão.
  • JFrame: JFrame desce da classe Frame. Os componentes adicionados à moldura são chamados de conteúdo da moldura.
  • JLabel: A classe JLabel é uma subclasse do JComponent. Ele é usado para criar rótulos de texto no aplicativo.
  • JButton: A funcionalidade do botão de pressão no Swing é fornecida pelo JButton. Podemos associar uma string, um ícone ou ambos ao objeto JButton.
  • JTextField: A classe JTextField fornece um campo de texto no qual podemos editar uma única linha de texto.

JFrame em Java

Um quadro, em geral, é um contêiner que pode conter outros componentes, como botões, rótulos, campos de texto, etc. Uma janela de quadro pode conter um título, uma borda e também menus, campos de texto, botões e outros componentes. Um aplicativo deve conter um quadro para que possamos adicionar componentes dentro dele.

O Frame em Java Swing é definido na classe javax.swing.JFrame. A classe JFrame herda a classe java.awt.Frame. JFrame é como a janela principal do aplicativo GUI usando swing.

Podemos criar um objeto de janela JFrame usando duas abordagens:

como abrir um arquivo .7z mac

# 1) Estendendo a classe JFrame

A primeira abordagem é criar uma nova classe para construir um Frame. Esta classe herda da classe JFrame do pacote javax.swing.

O programa a seguir implementa essa abordagem.

import javax.swing.*; class FrameInherited extends JFrame{ //inherit from JFrame class JFrame f; FrameInherited(){ JButton b=new JButton('JFrame_Button');//create button object b.setBounds(100,50,150, 40); add(b);//add button on frame setSize(300,200); setLayout(null); setVisible(true); } } public class Main { public static void main(String() args) { new FrameInherited(); //create an object of FrameInherited class } }

Resultado:

Ao estender a classe JFrame

# 2) Instanciando a classe JFrame

import javax.swing.*; public class Main { public static void main(String() args) { JFrame f=new JFrame('JFrameInstanceExample');//create a JFrame object JButton b=new JButton('JFrameButton');//create instance of JButton b.setBounds(100,50,150, 40);//dimensions of JButton object f.add(b);//add button in JFrame f.setSize(300,200);//set frame width = 300 and height = 200 f.setLayout(null);//no layout manager specified f.setVisible(true);//make the frame visible } }

Resultado:

Instanciando a classe JFrame

No programa acima, criamos um quadro da classe JFrame criando uma instância da classe JFrame.

JPanel em Java

Um painel é um componente que está contido dentro de uma janela de quadro. Uma moldura pode ter mais de um componente de painel dentro dela, com cada componente de painel tendo vários outros componentes.

Em termos mais fáceis, podemos usar painéis para particionar o quadro. Cada painel agrupa vários outros componentes dentro dele. Em outras palavras, usamos painéis para organizar os componentes dentro do quadro.

A classe API do swing que implementa o componente do painel é JPanel. A classe JPanel herda de JComponent e tem FlowLayout como seu layout padrão.

O programa a seguir demonstra a criação de um contêiner de painel em um quadro usando classes de pacote javax.swing.

import javax.swing.*; class JPanelExample { JPanelExample(){ JFrame frame = new JFrame('Panel Example'); //create a frame JPanel panel = new JPanel(); //Create JPanel Object panel.setBounds(40,70,100,100); //set dimensions for Panel JButton b = new JButton('ButtonInPanel'); //create JButton object b.setBounds(60,50,80,40); //set dimensions for button panel.add(b); //add button to the panel frame.add(panel); //add panel to frame frame.setSize(400,400); frame.setLayout(null); frame.setVisible(true); } } public class Main { public static void main(String() args) { new JPanelExample(); //create an object of FrameInherited class } }

Resultado:

JPanel em Java

Aqui temos um Frame. Dentro da moldura, criamos um painel. Então, dentro do painel, criamos um botão. Desta forma, podemos usar um painel para conter os outros componentes.

JTextArea em Java

TextArea define um campo de texto editável. Ele pode ter várias linhas. A classe swing que define a área de texto é JTextArea e herda a classe JTextComponent.

public class JTextArea estende JTextComponent

A classe JTextArea contém 4 construtores que nos permitem criar uma área de texto com várias opções.

  • JTextArea (): Construtor padrão. Crie uma área de texto vazia.
  • JTextArea (String s): Cria uma textarea com s como o valor padrão.
  • JTextArea (linha interna, coluna interna): Cria uma área de texto com uma linha x coluna especificada.
  • JTextArea (String s, linha interna, coluna interna): Cria um texto are2a com a linha x coluna especificada e o valor padrão s.

O programa Java a seguir mostra um exemplo do componente JTextArea no balanço.

import javax.swing.*; class JTextAreaExample { JTextAreaExample(){ JFrame frame= new JFrame(); JTextArea t_area=new JTextArea('JTextArea example'); //create object of JTextArea t_area.setBounds(10,30, 150,100); //set its dimensions frame.add(t_area); //add it to the frame frame.setSize(200,200); frame.setLayout(null); frame.setVisible(true); } } public class Main { public static void main(String() args) { new JTextAreaExample(); //create an object of TextAreaExample class } }

Resultado:

JTextArea em Java

JButton em Java

Um botão é um componente usado para criar um botão de ação com um nome ou rótulo nele. No swing, a classe que cria um botão rotulado é JButton. JButton herda a classe AbstractButton. Podemos associar o evento ActionListener ao botão para fazer com que ele execute alguma ação quando for pressionado.

Vamos implementar um programa de exemplo para JButton em oscilações Java.

import javax.swing.*; public class Main { public static void main(String() args) { JFrame frame=new JFrame('JButton Example'); //create JFrame object JButton button=new JButton('Button'); //Create a JButton object button.setBounds(50,50,75,35); //set dimensions for button frame.add(button); //add button to the frame frame.setSize(250,200); frame.setLayout(null); frame.setVisible(true); } }

Resultado:

JButton em Java

JList em Java

Uma lista consiste em vários itens de texto. Os usuários podem selecionar um único item ou vários itens de uma vez. A classe que implementa a lista na API swing é JList. JList é um descendente da classe JComponent.

A seguir estão os construtores da classe JList.

  • JList (): Construtor padrão que cria uma lista vazia somente leitura.
  • JList (array () listItem): Crie uma JList que inicialmente contenha elementos do array listItem.
  • JList (ListModel dataModel): Cria uma lista com elementos do modelo dataModel especificado.

Uma demonstração simples do componente JList é fornecida abaixo.

import javax.swing.*; public class Main { public static void main(String() args) { JFrame frame= new JFrame('JList Example'); //create a list model and add items to it DefaultListModel colors = new DefaultListModel<>(); colors.addElement('Red'); colors.addElement('Green'); colors.addElement('Blue'); //create JList object and add listModel to it JList colorsList = new JList<>(colors); colorsList.setBounds(100,100, 75,50); frame.add(colorsList); //add list to the frame frame.setSize(400,400); frame.setLayout(null); frame.setVisible(true); } }

Resultado:

JList em Java

No programa acima, primeiro definimos um listModel com entradas de cores nele. Em seguida, criamos um objeto JList e adicionamos listModel a ele. Em seguida, o objeto JList é adicionado ao objeto de quadro que é então exibido.

JComboBox em Java

A classe JCombobox mostra uma lista de opções da qual um usuário pode selecionar uma opção. A escolha selecionada está no topo. JComboBox deriva da classe JComponent.

A seguir estão os construtores fornecidos pela classe JComboBox:

  • JComboBox (): Construtor padrão que cria um ComboBox com o modelo de dados padrão.
  • JComboBox (Object () items): Este construtor cria uma ComboBox tendo itens como elementos dos itens de array fornecidos.
  • JComboBox (itens de vetor): Esse construtor lê os elementos do vetor fornecido e constrói um ComboBox com esses elementos como seus itens.

A classe JComboBox também fornece métodos para adicionar / remover itens, adicionar ActionListener, ItemListener, etc.

O exemplo a seguir demonstra a implementação JComboBox em Java.

import javax.swing.*; class ComboBoxExample { JFrame frame; ComboBoxExample(){ frame=new JFrame('ComboBox Example'); //create a string array String country()={'India','SriLanka','Singapore','Maldives','SeyChelles'}; //create a combobox object with given string array JComboBox countries=new JComboBox(country); countries.setBounds(50, 50,90,20); frame.add(countries); //add it to the frame frame.setLayout(null); frame.setSize(200,300); frame.setVisible(true); } } public class Main { public static void main(String arg()) { new ComboBoxExample(); } }

Resultado:

Implementação JComboBox

JSlider em Java

Um controle deslizante nos permite selecionar um intervalo específico de valores. Na API Java Swing, JSlider é a classe usada para implementar o controle deslizante.

A seguir estão os construtores fornecidos pela classe JSlider.

  • JSlider (): Um construtor padrão que cria um controle deslizante tendo 50 como o valor inicial e o intervalo de 0 a 100.
  • JSlider (orientação interna): Este construtor cria um controle deslizante como acima, mas com uma orientação especificada. O valor de orientação pode ser JSlider.HORIZONTAL ou JSlider.VERTICAL.
  • JSlider (int min, int max): Este construtor é usado para criar um controle deslizante horizontal usando o mínimo e o máximo fornecidos.
  • JSlider (int min, int max, int value): Este construtor cria um controle deslizante que é horizontal com o valor especificado de min, max e value.
  • JSlider (orientação interna, mínimo interno, máximo interno, valor interno): Este construtor constrói um controle deslizante com orientação especificada, mínimo, máximo e valor.

O programa a seguir demonstra o JSlider em Java com ticks. Este programa também demonstra o uso dos métodos suportados pela classe JSlider.

import javax.swing.*; class SliderExample extends JFrame { public SliderExample() { //create a slider object JSlider slider = new JSlider(JSlider.HORIZONTAL, 0, 50, 25); //set major and minor ticks for the slider slider.setMinorTickSpacing(2); slider.setMajorTickSpacing(10); slider.setPaintTicks(true); slider.setPaintLabels(true); JPanel panel = new JPanel(); panel.add(slider); //add slider to the panel add(panel); } } public class Main{ public static void main(String s()) { SliderExample frame=new SliderExample(); frame.pack(); frame.setVisible(true); } }

Resultado:

JSlider em Java

Tratamento de eventos em Java

Um evento pode ser definido como uma mudança de estado de um objeto. Do ponto de vista da GUI, um evento ocorre quando o usuário final interage com os componentes da GUI. Os eventos que são acionados na GUI podem ser o clique de um botão, rolagem, seleção de itens da lista, alteração de texto, etc.

Os eventos que ocorrem na GUI listado acima são principalmente eventos de primeiro plano. Também podemos ter alguns eventos em segundo plano, como conclusão da operação em segundo plano, expiração do temporizador, etc.

O tratamento de eventos é um mecanismo pelo qual uma ação é executada quando um evento ocorre. Para isso, definimos um método que também é chamado de manipulador de eventos, que é chamado quando ocorre um evento. Java usa um mecanismo padrão denominado “modelo de evento de delegação” para gerar e manipular eventos.

O modelo de evento de Delegação consiste em:

# 1) Fonte: A fonte do evento é o objeto. O objeto no qual ocorre um evento é a fonte e a fonte é responsável por enviar informações sobre o evento ao tratador de eventos.

# 2) Ouvinte: O ouvinte nada mais é do que o manipulador de eventos responsável por executar uma ação quando um evento ocorre. Em Java, um ouvinte é um objeto que espera por um evento. Assim que o evento ocorre, o ouvinte processa o evento.

O requisito é registrar o ouvinte com o objeto para que, quando ocorrer um evento, o ouvinte possa processá-lo.

Por exemplo,para um evento de clique de botão, podemos ter a seguinte sequência de etapas.

  1. O usuário clica no botão que gera um evento Click.
  2. O objeto de classe de evento apropriado é criado e os dados de origem e de evento são passados ​​para este objeto.
  3. Este objeto de evento é então passado para a classe de ouvinte registrada com o objeto.
  4. O ouvinte é executado e retorna.

Agora vamos discutir alguns dos ouvintes fornecidos pelo Java.

ActionListener em Java

Um actionListener é o ouvinte de um botão ou item de menu. Quando clicamos em um botão, o Listener do botão que está envolvido é o actionListener. O actionListener é notificado no ActionEvent.

O pacote de eventos java.awt.an define a interface ActionListener. Esta interface possui apenas um método actionPerformed ().

public abstract void actionPerformed (ActionEvent e);

Quando um componente registrado como um botão é clicado, o método actionPerformed () é chamado automaticamente.

A abordagem mais comum para incluir ActionListener no programa é implementar a interface ActionListener e, em seguida, implementar o método actionPerformed ().

As etapas para implementar a classe ActionListener são as seguintes:

# 1) Implementar a interface ActionListerner.

public class ActionListenerImpl Implementa ActionListener

# 2) Registre o componente com este ouvinte. Se o botão for um componente que desejamos registrar com o ouvinte, o registraremos da seguinte maneira:

button.addActionListener (instanceOfListenerclass);

# 3) Implementar / substituir o método actionPerformed ().

public void actionPerformed (ActionEvent e){ //code to perform action }

Portanto, usando as etapas acima, podemos associar qualquer evento ao componente GUI.

O exemplo a seguir demonstra um evento Click de botão usando ActionListener.

import javax.swing.*; import java.awt.event.*; public class Main { public static void main(String() args) { JFrame frame=new JFrame('Button Click Example'); final JTextField text_field=new JTextField(); //JTextField object text_field.setBounds(50,100, 150,20); JButton click_button=new JButton('Click Me!!!'); //JButton object click_button.setBounds(20,50,75,30); click_button.addActionListener(new ActionListener(){ //add an event and take action public void actionPerformed(ActionEvent e){ text_field.setText('You Clicked the button'); } }); //add button and textfield to the frame frame.add(click_button);frame.add(text_field); frame.setSize(400,400); frame.setLayout(null); frame.setVisible(true); } }

Resultado:

ActionListener em Java

O programa acima implementa um evento ActionListener. O evento é o evento de clique de botão e com ele, associamos um ActionListener que exibe o texto no campo de texto ao clicar no botão.

KeyListener em Java

Sempre que houver uma mudança no estado da chave, um KeyListener é notificado. Assim como ActionListener, o KeyListener também é encontrado no pacote java.awt.event.

A interface KeyListener fornece os seguintes métodos:

resumo público void keyPressed (KeyEvent e);

public abstract void keyReleased (KeyEvent e);

public abstract void keyTyped (KeyEvent e);

Precisamos implementar os métodos acima para associar os principais eventos ao componente. Deixamos que o usuário implemente um exemplo de KeyListener usando swings em Java.

Layouts de Swing em Java

Quando organizamos vários componentes em um contêiner, dizemos que estamos organizando esses componentes. Portanto, um layout pode ser definido como o posicionamento de componentes em um contêiner.

melhor software para baixar vídeos do youtube

Enquanto houver menos componentes, eles podem ser posicionados arrastando e soltando manualmente. Mas torna-se difícil organizar os componentes em grande número. Nesse momento, o Layout Manager do Java vem em nosso auxílio.

LayoutManager é responsável pelo layout dos componentes em aplicativos GUI. LayoutManager é uma interface e é implementado por todas as classes do gerenciador de layout. Java fornece as seguintes classes LayoutManager.

LayoutManagerDescrição
javax.swing.GroupLayoutAgrupa os componentes e os posiciona no contêiner.
java.awt.BorderLayoutOs componentes são dispostos para caber em cinco direções, nomeadamente centro, leste, oeste, sul, norte.
java.awt.FlowLayoutEste é o layout padrão. Ele estabelece os componentes no fluxo direcional.
java.awt.GridLayoutOrganiza os componentes em uma grade retangular.
javax.swing.BoxLayoutOs componentes são organizados em uma caixa.
java.awt.CardLayoutCada componente é visto como uma carta em um baralho e por vez, apenas um componente é visível.
java.awt.GridBagLayoutOrganiza os componentes verticalmente, horizontalmente ou mesmo ao longo de suas linhas de base. Os componentes não precisam ser do mesmo tamanho.
javax.swing.ScrollPaneLayoutUsado pela classe JScrollPane e é responsável por organizar os componentes em contêineres roláveis.
javax.swing.SpringLayout etc.Um conjunto de restrições, como a distância horizontal e vertical entre os componentes, etc., é fornecido e os componentes são organizados de acordo com esse conjunto de restrições.

Neste tutorial, discutiremos apenas FlowLayout e GridLayout.

FlowLayout em Java

O FlowLayout organiza os componentes em uma direção de fluxo, um após o outro. Este é o layout padrão para os containers como Panel e Applet.

A classe FlowLayout em Java que representa o gerenciador FlowLayout contém os seguintes Fields e construtores.

Campos da classe FlowLayout

  • public static final int LEADING
  • public static final int TRAILING
  • public static final int LEFT
  • public static final int RIGHT
  • public static final int CENTER

Os campos acima definem as posições nas quais os componentes serão colocados ou alinhados.

Construtores da classe FlowLayout

  • FlowLayout (): Este é um construtor padrão. Este construtor cria um layout de fluxo com componentes alinhados centralmente com uma lacuna padrão de 5 unidades nas direções horizontal e vertical.
  • FlowLayout (int align): Este construtor cria um layout de fluxo com o valor de alinhamento especificado e com uma lacuna horizontal e vertical de 5 unidades.
  • FlowLayout (int align, int hgap, int vgap): Cria um layout de fluxo com valor de alinhamento especificado e lacuna horizontal e vertical.

A seguir está um exemplo de FlowLayout em Java.

import javax.swing.*; import java.awt.*; class FlowLayoutClass { JFrame frame; FlowLayoutClass() { frame = new JFrame('FlowLayout Example'); //create button components JButton b1 = new JButton('A'); JButton b2 = new JButton('B'); JButton b3 = new JButton('C'); JButton b4 = new JButton('D'); JButton b5 = new JButton('E'); //add components to the frame frame.add(b1); frame.add(b2); frame.add(b3); frame.add(b4); frame.add(b5); //set layout as 'FlowLayout.CENTER' frame.setLayout(new FlowLayout(FlowLayout.CENTER)); //setting flow layout of right alignment frame.setSize(300, 300); frame.setVisible(true); } } public class Main{ public static void main(String() args) { new FlowLayoutClass(); } }

Resultado:

Construtores da classe FlowLayout

GridLayout em Java

Usando GridLayout, podemos fazer o layout dos componentes em uma grade retangular, ou seja, cada componente é organizado em cada retângulo.

Construtores da classe GridLayout

  1. GridLayout (): construtor padrão que gera um layout de grade com uma coluna por componente em uma linha.
  2. GridLayout (linhas inteiras, colunas inteiras): Este construtor gera um layout de grade com linhas e colunas especificadas. Não há lacuna entre os componentes.
  3. GridLayout (linhas int, colunas int, hgap int, vgap int): usando este construtor, geramos um layout de grade com linhas e colunas especificadas e intervalos horizontais e verticais.

O exemplo a seguir implementa o GridLayout em Java.

import javax.swing.*; import java.awt.*; class GridLayoutClass { JFrame frame; GridLayoutClass() { frame=new JFrame('GridLayout Example'); //create components to be laid out as per GridLayout JButton b1=new JButton('P'); JButton b2=new JButton('Q'); JButton b3=new JButton('R'); JButton b4=new JButton('S'); JButton b5=new JButton('T'); JButton b6=new JButton('U'); JButton b7=new JButton('V'); JButton b8=new JButton('W'); JButton b9=new JButton('X'); //add components to the frame frame.add(b1);frame.add(b2);frame.add(b3);frame.add(b4);frame.add(b5); frame.add(b6);frame.add(b7);frame.add(b8);frame.add(b9); //set frame layout to GridLayout of 3 rows and 3 columns frame.setLayout(new GridLayout(3,3)); frame.setSize(300,300); frame.setVisible(true); } } public class Main{ public static void main(String() args) { new GridLayoutClass(); } }

Resultado:

GridLayout em Java

Setbounds em Java

Se verificarmos os exemplos de programação neste tutorial antes do tópico de layout, podemos ver que definimos o layout como nulo nesses exemplos (setLayout (null)). Vimos que, quando usamos gerenciadores de layout em nosso programa, eles posicionam automaticamente os componentes.

Quando os gerenciadores de layout não são usados, podemos usar o método setBounds para definir o tamanho e a posição do componente. Portanto, o método setBounds é usado para posicionar manualmente o componente e também definir o tamanho.

A sintaxe geral do método setBounds é a seguinte:

setBounds (int coordenada x, int y - coordenada, largura interna, altura interna)

Vamos agora implementar um exemplo do método SetBounds.

import javax.swing.*; public class Main { public static void main(String arg()) { JFrame frame = new JFrame('SetBounds Method Test'); frame.setSize(375, 250); // Set layout as null frame.setLayout(null); // Create a Button JButton button = new JButton('ButtonWithSetBounds'); // Set position and size of a button using setBounds button.setBounds(80,30,200,40); frame.add(button); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); frame.setLocationRelativeTo(null); frame.setVisible(true); } }

Resultado:

implementação de lista duplamente vinculada c ++

Setbounds em Java

No programa acima, temos um componente Botão. Não definimos nenhum layout, mas usamos o método setBounds para definir sua posição e dimensões.

Swing Vs JavaFX

BalançoJavaFX
Swing fornece uma API para criar componentes GUI.JavaFX fornece scripts e rápido desenvolvimento de IU associado ao construtor de tela.
Não haverá nenhuma nova funcionalidade adicionada ao Swing em versões futuras.O JavaFX fornece funcionalidade rica e tem potencial para mais recursos em versões futuras.
Podemos criar todos os componentes padrão usando a API Swing.O JavaFX nos permite criar componentes GUI ricos usando aparência e comportamento avançados.
Um grande número de componentes está presente no Swing.JavaFX tem um número comparativamente menor de componentes.
Swing é uma biblioteca de IU com recursos completos.JavaFX é uma API nova e futura com componentes de UI ricos.
Swing tem suporte de MVC solto.JavaFX suporta o padrão MVC de forma consistente.

perguntas frequentes

P # 1) O Swing ainda é usado em Java?

Responda: Sim, o Swing ainda está sendo usado em Java e muito pesadamente. Às vezes, ele é usado como um substituto completo para AWT. Às vezes, também é usado junto com alguns dos componentes AWT. É usado até com o JavaFX mais recente. Portanto, o Swing ainda é usado e será usado por muito tempo.

P # 2) Como funciona o Java Swing?

Responda: O Swing em Java é escrito sobre a estrutura AWT. Portanto, a manipulação de eventos do AWT é herdada completamente pelo swing. O Swing também fornece um grande número de componentes que podemos usar para desenvolver aplicativos GUI eficientes.

P # 3) O Swing segue MVC?

Responda: A API Swing tem suporte flexível para MVC. O modelo representa os dados do componente. O componente swing tem um elemento separado chamado Model, enquanto Controller e View são combinados em elementos UI. Este baqueteamento permite que o swing tenha uma aparência plugável.

P # 4) O JavaFX é melhor que o Swing?

Responda: O Swing já existe há muito tempo e tem um suporte IDE mais maduro. Ele também tinha uma grande biblioteca de componentes. JavaFX é comparativamente mais recente e tem uma pequena biblioteca de componentes, mas com atualizações mais consistentes e suporte MVC consistente. Portanto, depende de como o JavaFX se desenvolve e fornece mais recursos.

P # 5) Qual é o melhor AWT ou Swing?

Responda: O Swing é construído em cima do AWT e fornece um conjunto rico e grande de componentes de IU quando comparado ao AWT. Os componentes Swing também podem ter sua aparência e comportamento em relação aos componentes AWT que têm a aparência do sistema operacional.

Os componentes do Swing são mais rápidos do que AWT. Todos esses fatores tornam o swing melhor do que o AWT.

Mais sobre Java Swing

Ao criar um aplicativo, inicialmente você deve ter um contêiner básico e adicionar os componentes necessários, como botões e campos de texto, ao contêiner.

E quando você clica ou executa alguma operação em qualquer campo, o evento ocorrerá e seu código deverá ouvir os eventos e também tratar o evento.

Container Swing

Um contêiner é um elemento raiz de um aplicativo. Todos os outros componentes são adicionados a essa raiz e ela forma uma hierarquia.

Existem três classes de contêineres:

  • JFrame
  • JDialog
  • JApplet

Demonstração de contêiner usando JFrame:

import java.awt.Color; import javax.swing.JFrame; import javax.swing.JPanel; public class ContainerDemo { public static void main(String() args) { JFrame baseFrame =new JFrame(); baseFrame.setTitle('Base Container'); JPanel contentPane=new JPanel(); contentPane.setBackground(Color.pink); baseFrame.setSize(400, 400); baseFrame.add(contentPane); baseFrame.setDefaultCloseOperation(baseFrame.EXIT_ON_CL OSE); baseFrame.setVisible(true); } }

Demonstração de contêiner usando JFrame

Ao executar o programa acima, você obterá a saída abaixo.

recipiente de base

Componentes

A classe JComponent é uma classe base para todos os componentes em um swing.

Os componentes usados ​​com frequência incluem,

  • JButton
  • JTextField
  • JTextArea
  • JRadioButton
  • JComboBox etc.

Todos esses componentes devem ser adicionados ao contêiner, caso contrário, ele não aparecerá no aplicativo.

Exemplo:

Para criar a instância do botão,

JButton clickButton = novo JButton ();

Para adicionar o botão ao contêiner,

myFrame.add ();

Manipulação de eventos

Todos os aplicativos são orientados por eventos como cliques de botão, cliques do mouse, entrada de texto do usuário etc. Quando o evento ocorre, você deve adicionar um ouvinte e deve passar o objeto de evento de origem.

Com uma classe interna, você pode manipular o evento com sua lógica, conforme mostrado abaixo.

public class ContainerDemo { public void createApp() { JFrame baseFrame =new JFrame(); JPanel contentPane=new JPanel(); baseFrame.setTitle('Base Container'); baseFrame.setSize(400, 400); baseFrame.add(contentPane); JButton demoButton =new JButton('click'); demoButton.setBounds(100,95,95,30); JTextArea result =new JTextArea(); result.setBounds(130,140,95,30); contentPane.add(demoButton); contentPane.add(result); baseFrame.setDefaultCloseOperation(baseFrame.EXIT_ON_CL OSE); baseFrame.setVisible(true); demoButton.addMouseListener(new MouseAdapter() { @Override public void mouseClicked(MouseEvent e) { result.setText('button clicked'); } }); } public static void main(String() args) { ContainerDemo c =new ContainerDemo(); c.createApp(); } }

Manipulação de eventos

Conclusão

Neste tutorial, abordamos a base com a API Swing fornecida por Java para a construção de aplicativos GUI. Discutimos os principais contêineres e componentes giratórios e sua implementação.

Também discutimos o tratamento de eventos no Swing. Embora o mecanismo de tratamento de eventos seja AWT, o swing implementa os eventos de maneira eficiente. Em seguida, discutimos os vários gerenciadores de layout fornecidos pela API Swing que nos permitem fazer o layout ou organizar vários componentes nos aplicativos Swing GUI.

=> Confira o guia de treinamento Java perfeito aqui.

Leitura recomendada

^