Esquema de fluxo em Java - Aprenda as funções comumente usadas do layout de fluxo

Índice:

Anonim

Visão geral do Flowlayout em Java

Antes de mergulhar fundo no FlowLayout em detalhes de Java, vamos revisar alguns tópicos básicos necessários para o FlowLayout:

Java AWT : AWT é uma API para a criação de GUI ou aplicativos baseados em janelas.

Alguns dos conceitos básicos sobre a hierarquia do AWT são os seguintes:

1. Container : Container é uma classe que contém todos os componentes, como botão, campo de texto, barra de título, barra de menus, etc.

2. Componentes : Os componentes são os objetos da GUI, como botões, rótulo, campo de texto, lista de verificação.

Existem algumas funções básicas de componentes, como:

  • add public void (Componente c): adiciona um componente neste componente.
  • public void setSize (int width, int height): define a largura e a altura do componente.
  • public void setLayout (LayoutManager m): define o gerenciador de layout do componente.
  • public void setVisible (status booleano): define a visibilidade do componente; por padrão, é falso.

3. Painel : Painel é uma classe de contêiner. Ele cria um espaço para um aplicativo no qual todos os componentes podem ser ajustados. Herda a classe de contêiner.

O painel não contém barra de menus ou barra de título, mas pode conter outros componentes, como campo de texto, botões.

4. Quadro : O quadro é uma classe de contêiner. Ele contém uma barra de menus e uma barra de título e também pode conter outros componentes.

5. Gerenciador de Layout : Um gerenciador de layout é um objeto que implementa a interface LayoutManager para determinar o tamanho e a posição dos componentes no contêiner.

Existem muitos tipos de gerenciadores de layout disponíveis, cada um com seus próprios recursos e tarefas específicas:

  • FlowLayout.
  • BorderLayout.
  • CardLayout.
  • BoxLayout.
  • GridLayout.
  • GridBagLayout.
  • GroupLayout.
  • SpringLayout.

Definição de FlowLayout

  • O FlowLayout é um dos gerenciadores de layout fornecidos pelo AWT usados ​​nos applets para organizar os componentes da maneira da esquerda para a direita, como as palavras de um parágrafo.
  • Quando não Dos componentes aumenta que o tamanho da janela, por padrão, o Java permite que o FlowLayout organize os componentes para caberem na vidraça.
  • FlowLayout é o layout padrão fornecido pelo gerenciador de layout. Quando você não seleciona nenhum layout, o layout será configurado para fluir.
  • O FlowLayout usa algumas configurações padrão, como alinhamento central com intervalos de cinco pixels entre os componentes horizontal e verticalmente.

O alinhamento é determinado pela propriedade "align". E o campo de alinhamento é o seguinte:

  • ESQUERDA: Alinha os componentes à esquerda.
  • À DIREITA: Alinha os componentes à direita.
  • CENTRO: Alinha os componentes ao centro.
  • LÍDER: Ele estará na borda principal do contêiner, ou seja, à esquerda, para a orientação da esquerda para a direita.
  • TRAILING: Ele estará na borda do contêiner, ou seja, à direita, da esquerda para a direita

Funções comumente usadas do FlowLayout

  • setAlignment (int align): define o respectivo alinhamento para o layout do contêiner.
  • getAlignment (): obtém o alinhamento do layout do contêiner.
  • addLayoutComponent (): adiciona o componente específico ao layout.
  • setTitle (String string): define o título do contêiner com o texto fornecido.

Construtores no FlowLayout

  • FlowLayout (): constrói uma instância do FlowLayout como alinhado ao centro e com 5 pixels de espaço entre os componentes.
  • FlowLayout (int align): constrói um FlowLayout com um determinado alinhamento com 5 pixels de espaço entre os componentes.
  • FlowLayout (int align, int horizontalGap, int verticalGap): constrói um FlowLayout com um determinado alinhamento e com um intervalo horizontal e vertical determinado entre os componentes.
  • Esse construtor será alinhado pelo campo de alinhamento especificado como DIREITO, ESQUERDO ou CENTRO e também oferece a opção de adicionar espaço horizontal e espaço vertical entre os componentes.

Exemplo para layout de fluxo:

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class Layout extends JFrame
(
private JButton lb;
private JButton rb;
private JButton cb;
private FlowLayout layout;
private Container container;
public Layout()
(
super("the title");
layout = new FlowLayout();
container = getContentPane();
setLayout(layout); //left alignment
lb = new JButton("left");
add(lb);
lb.addActionListener(
new ActionListener()
(
public void actionPerformed(ActionEvent event)
(
layout.setAlignment(FlowLayout.LEFT);
layout.layoutContainer(container);
)
)
);
//right alignment
rb = new JButton("right");
add(rb);
rb.addActionListener(
new ActionListener()
(
public void actionPerformed(ActionEvent event)
(
layout.setAlignment(FlowLayout.RIGHT);
layout.layoutContainer(container);
)
)
);
//center alignment
cb = new JButton("center");
add(cb);
cb.addActionListener(
new ActionListener()(
public void actionPerformed(ActionEvent event)
(
layout.setAlignment(FlowLayout.CENTER);
layout.layoutContainer(container);
)
)
);
)
)

Método principal de Flowlayout em Java

import javax.swing.*;
public class Test
(
public static void main(String() args)
(
Layout l = new Layout();
l.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
l.setSize(300, 100);
l.setVisible(true);
)
)

Resultado:

A explicação para o código acima
  • No código acima, declaramos três botões com a ajuda do JButton como lb, rb e cb.
  • Ao criar a instância da classe, precisamos ver os botões para adicionar os botões a um contêiner no próprio construtor da classe.
  • Estendemos a classe JFrame
  • Com as funções setLayout (), estamos definindo o layout como layout de fluxo.
  • Para o alinhamento à esquerda, quando clicamos no botão chamado "esquerdo", os botões no painel da janela devem estar alinhados à esquerda.
  • Para que isso funcione, o botão específico é adicionado no painel da janela e, no evento de clique desse botão, o layout será definido como Esquerda.
  • No código acima, setAlignment (FlowLayout.LEFT) definirá o alinhamento do layout do painel para a esquerda. FlowLayout.LEFT é o campo disponível para alinhamento. Da mesma forma, FlowLayout.RIGHT, FlowLayout.CENTER, FlowLayout.TRAILING, FlowLayout.LEADING são alguns dos outros campos usados ​​para definir o alinhamento.
  • Observe que esses campos de alinhamento alinham todos os componentes à esquerda, direita ou centro.
  • Não depende do tamanho da sua janela. Ele irá ajustar e alinhar seus componentes com o alinhamento especificado, respeitosamente.
  • Como fizemos no alinhamento esquerdo de maneira semelhante, desenvolvemos o alinhamento central e direito. Por fim, desenvolvemos a Classe de Teste para escrever o método principal para testar nosso código Java FlowLayout.
  • Criando uma instância da classe Layout no método principal, configuramos o tamanho da janela e a visibilidade do componente como true.

Conclusão - Flowlayout em Java

Este tutorial fornece a idéia básica de por que o Java tem FlowLayout e quais são as funcionalidades dele. FlowLayout é o layout padrão devido à sua facilidade e precisão de alinhamento. Lembre-se de que todo conceito fica ainda mais claro quando você o codifica e pratica. Deixe o erro entrar no seu código, não hesite em continuar codificando e entender o conceito com precisão.

Artigos recomendados

Este é um guia para o Flowlayout em Java. Aqui discutimos as funções Construtoras e Comumente usadas do FlowLayout. Você também pode consultar o seguinte artigo para saber mais -

  1. JPanel em Java
  2. Trocando em Java
  3. Fatorial em Java
  4. Classificação em Java
  5. Guia completo para classificação em c # com exemplos
  6. Layout HTML
  7. Função de classificação em Python com exemplos
  8. Guia completo de fatorial em C #