Explicando o Projeto CRUD Estudante em JavaFX

// Esta é a classe principal do sistema responsável por inicializar a aplicação a partir da interface

//Imports dos pacotes MVC

import Model.Estudante;

import View.EstudanteCRUDView;

// Imports JavaFX

import javafx.application.Application;

import javafx.stage.Stage;

// Outros imports

import java.io.IOException;

public class Main extends Application { // A classe principal deve estender a classe Application

    @Override

    public void start(Stage stage) throws IOException {

        // Cria instância da tela/cena da interface de CRUD de Estudante

        EstudanteCRUDView ec = new EstudanteCRUDView();

        // Propriedades do palco onde a aplicação acontece

        stage.setTitle("Projeto CRUD Estudante com JavaFX"); // Título do palco

        stage.setScene(ec.getScene()); // Tela/cena a ser carregada ao iniciar o palco

        stage.show(); // Inicia o palco

    }

    public static void main(String[] args) {

        launch(); // carrega a aplicação

    }

}

1. Main extends Application

Quando sua classe Main estende Application, você herda os métodos e o comportamento necessários para que o JavaFX saiba como inicializar, executar e finalizar sua aplicação de maneira correta. O método start() é onde você define a interface gráfica e, graças a Application, o ambiente gráfico é configurado automaticamente.

Por isso, em qualquer aplicação JavaFX, a classe principal precisa estender Application.

2. throws IOException

O throws IOException em Java é uma declaração usada em um método para indicar que ele pode gerar (ou "lançar") uma exceção do tipo IOException. Isso significa que o método pode encontrar um erro de entrada/saída (I/O), como problemas ao ler ou escrever arquivos, acessar a rede, ou lidar com dados que dependem de recursos externos. 

O código public void start(Stage stage) throws IOException utiliza throws IOException porque o método start pode realizar operações que envolvem entrada/saída (I/O), como carregar arquivos de configuração, recursos de interface (como arquivos FXML) ou outros dados externos necessários para a aplicação. 

3. Stage

stage.setTitle("Projeto CRUD Estudante com JavaFX");

• Define o título da janela (palco) que será exibida na interface gráfica. Aqui, o título será "Projeto CRUD Estudante com JavaFX". Esse texto aparece na barra de título da janela.

stage.setScene(ec.getScene());

• Define a cena a ser exibida dentro da janela (palco). Uma cena (Scene) contém todos os componentes visuais da aplicação, como botões, campos de texto, etc. Neste caso, a cena está sendo obtida a partir da instância ec (que é uma instância de EstudanteCRUDView), através do método getScene(). Isso significa que a tela da interface CRUD do estudante será carregada.

stage.show();

• Exibe a janela (palco) para o usuário. Após configurar o título e a cena, esse método faz com que a janela se torne visível na tela, iniciando a interface gráfica da aplicação.

4. launch()

O método public static void main(String[] args) é o ponto de entrada de qualquer aplicação Java em execução. No contexto de uma aplicação JavaFX, ele tem um papel específico:

1. public static void main(String[] args):

   • Este é o método principal que o Java executa para iniciar a aplicação. O modificador static significa que ele pode ser executado sem a necessidade de criar uma instância da classe.

2. launch();:

   • O método launch() é fornecido pela classe Application (da qual sua classe principal herda) e é responsável por inicializar o ambiente do JavaFX.

   • Ele prepara tudo o que é necessário para a aplicação JavaFX, como a JavaFX Application Thread (a thread onde a interface gráfica é manipulada), e, em seguida, chama o método start(Stage primaryStage) automaticamente.

   • Esse método não precisa de argumentos porque, por padrão, ele carrega a aplicação e inicia a interface gráfica.

// Esta é a classe com a tela/cena da interface das operações do CRUD de Estudante

package View;

//Imports dos pacotes MVC

import Model.Estudante;

// Imports JavaFX

import javafx.geometry.Pos;

import javafx.scene.Scene;

import javafx.scene.layout.VBox;

import javafx.scene.layout.HBox;

import javafx.scene.control.Alert;

import javafx.scene.control.Button;

import javafx.scene.control.Label;

import javafx.scene.control.TableColumn;

import javafx.scene.control.TableView;

import javafx.scene.control.TextField;

import javafx.collections.FXCollections;

import javafx.collections.ObservableList;

import javafx.event.ActionEvent;

import javafx.event.EventHandler;

public class EstudanteCRUDView {

    Label labelRGA, labelNome;

    TextField textFieldRGA, textFieldNome;

    Button botaoCadastrar, botaoAtualizar, botaoExcluir;

    VBox vbox;

    HBox barraBotoes;

    Scene scene;

    TableView<Estudante> tabelaEstudantes;

    TableColumn<Estudante, String> colunaRGA, colunaNome;

    ObservableList<Estudante> listaDadosEstudantes;

    Alert mensagemAlerta;

    // Método construtor que irá inicializar todos os elementos de interface da tela

    public EstudanteCRUDView(){

        // Mensagem de Alerta do tipo WARNING e suas propriedades

        mensagemAlerta = new Alert(Alert.AlertType.WARNING);

        mensagemAlerta.setTitle("Mensagem de Alerta");

        mensagemAlerta.setHeaderText(null);

        // Labels - rótulos de texto

        labelRGA = new Label("RGA:");

        labelNome = new Label("Nome do(a) Estudante:");

        // TextFields - campos de entrada de texto

        textFieldRGA = new TextField();

        textFieldRGA.setMaxWidth(100);

        textFieldNome = new TextField();

        textFieldNome.setMaxWidth(400);

        // Buttons - botões

        botaoCadastrar = new Button("Cadastrar Novo Estudante");

        botaoAtualizar = new Button("Atualizar Estudante");

        botaoExcluir = new Button("Excluir Estudante");

        // HBox - caixa vertical contendo os botões CRUD

        barraBotoes = new HBox(botaoCadastrar, botaoAtualizar, botaoExcluir);

        barraBotoes.setSpacing(10);

        barraBotoes.setAlignment(Pos.CENTER);        

        // TableView - tabela contendo os dados de Estudante

        tabelaEstudantes = new TableView<>();

        listaDadosEstudantes = FXCollections.observableArrayList(); // Lista de dados observáveis a ser carregada para a tabela

        tabelaEstudantes.setItems(listaDadosEstudantes);

        //TableColumns - colunas da tabela e suas propriedades

        colunaRGA = new TableColumn<>("RGA");

        colunaRGA.setPrefWidth(164.0);

        colunaRGA.setCellValueFactory(cellData -> cellData.getValue().RGAProperty());

        colunaNome = new TableColumn<>("Nome");

        colunaNome.setPrefWidth(485.0);

        colunaNome.setCellValueFactory(cellData -> cellData.getValue().nomeProperty());

        // Carrega as colunas na tabela

        tabelaEstudantes.getColumns().addAll(colunaRGA, colunaNome);

        // Listener para carregar as informações da linha selecionada na tabela para as caixas de texto

        tabelaEstudantes.getSelectionModel().selectedItemProperty().addListener((obs, oldSelection, newSelection) -> {

            if (newSelection != null) {

                textFieldNome.setText(newSelection.getNome());

                textFieldRGA.setText(newSelection.getRGA());

            }

        });

        // Ações dos botões das operações de CRUD de Estudante na interface

        botaoCadastrar.setOnAction(new EventHandler<ActionEvent>() { // Cadastrar Estudante

            @Override

            public void handle(ActionEvent e) {

                Estudante estudante = new Estudante(textFieldNome.getText(), textFieldRGA.getText()); // Cria um estudante a partir dos dados das caixas de texto

                listaDadosEstudantes.add(estudante); // Insere o estudante na lista observável

                limparTextFields(); // Limpa caixas de texto

            }

        });

        botaoAtualizar.setOnAction(new EventHandler<ActionEvent>() { // Atualizar Estudante

            @Override

            public void handle(ActionEvent e) {

                int i = tabelaEstudantes.getSelectionModel().getSelectedIndex(); // Pega a posição da linha selecionada da tabela

                Estudante estudante = new Estudante(textFieldNome.getText(), textFieldRGA.getText()); // Cria um estudante a partir dos dados das caixas de texto

                listaDadosEstudantes.set(i, estudante); // Atualiza o estudante na lista observável para a posição obtida

                limparTextFields(); // Limpa caixas de texto

            }

        });

        botaoExcluir.setOnAction(new EventHandler<ActionEvent>() { // Excluir Estudante

            @Override

            public void handle(ActionEvent e) {

                if (textFieldNome.getText().isBlank() || textFieldRGA.getText().isBlank()) { 

                    mensagemAlerta.setContentText("Estudante não encontrado(a)!"); // Exemplo de mensagem de alerta - você pode criar outras!

                    mensagemAlerta.showAndWait();

                } else {

                    Estudante estudante = tabelaEstudantes.getSelectionModel().getSelectedItem();  // Cria um estudante a partir dos dados linha selecionada na tabela

                    listaDadosEstudantes.remove(estudante); // Remove o estudante da lista observável

                    limparTextFields(); // Limpa caixas de texto

                }

            }

        });

        // VBox - caixa vertical que contém todos os elementos da tela/cena e suas propriedades 

        vbox = new VBox(labelRGA, textFieldRGA, labelNome, textFieldNome, barraBotoes, tabelaEstudantes);

        vbox.setSpacing(10);

        vbox.setAlignment(Pos.CENTER);

        scene = new Scene(vbox, 650, 500); // Neste caso a VBox está funcionando como o layout da telan/cena

    }

    public Scene getScene(){ // Método que retorna a tela/cena para ser usada no palco

        return this.scene;

    }

    public void limparTextFields(){ // Método para limpar as caixas de texto

        textFieldRGA.clear();

        textFieldNome.clear();

    }

}

1. Iniciando a Classe

Esta é a classe responsável pela parte de interface de CRUD de objetos do tipo estudante. Ela é utilizada pela classe principal do sistema.

Em seus primeiros passos, a classe faz a declaração do pacote, seguido do importação da classe de modelo Estudante e os imports necessários da JavaFX.

Logo em seguida, são declarados todos os componetes UI que serão utilizados.

2. Método Construtor

Este método construtor EstudanteCRUDView() cria a interface gráfica da aplicação de CRUD de estudantes em JavaFX. Aqui estão os passos explicados de forma simples:

1. Criação de uma mensagem de alerta:

   • Um alerta do tipo "WARNING" é criado para ser usado em casos de erro, com título definido como "Mensagem de Alerta".

2. Criação de rótulos (Labels):

   • Dois rótulos são criados: um para o RGA (identificação do estudante) e outro para o nome do estudante.

3. Criação de campos de texto (TextFields):

   • Dois campos de texto são criados para entrada de dados do RGA e nome do estudante. A largura máxima dos campos é configurada.

4. Criação de botões (Buttons):

   • Três botões são criados para realizar as operações de CRUD: cadastrar, atualizar e excluir estudantes.

5. Organização dos botões em uma barra (HBox):

   • Os três botões são colocados em uma caixa horizontal (HBox), com espaçamento e alinhamento configurados.

6. Criação de uma tabela (TableView):

   • Uma tabela (TableView) é criada para listar os estudantes, e uma lista observável (ObservableList) é associada à tabela para armazenar os dados dos estudantes.

7. Criação de colunas da tabela (TableColumn):

   • Duas colunas são criadas na tabela: uma para o RGA e outra para o nome do estudante. As propriedades dessas colunas (largura e dados) são configuradas.

8. Adição das colunas à tabela:

   • As colunas são adicionadas à tabela.

9. Listener para seleção de linha na tabela:

   • Um "listener" é configurado para preencher os campos de texto com os dados do estudante selecionado na tabela.

10. Ações dos botões de CRUD:

    • Cada botão (Cadastrar, Atualizar, Excluir) é configurado para executar uma ação quando clicado:

      • Cadastrar: Cria um novo estudante a partir dos campos de texto e o adiciona à tabela.

      • Atualizar: Atualiza o estudante selecionado na tabela com os dados dos campos de texto.

      • Excluir: Remove o estudante selecionado da tabela ou exibe uma mensagem de erro se os campos estiverem em branco.

11. Criação de layout vertical (VBox):

    • Todos os componentes (rótulos, campos de texto, barra de botões e tabela) são organizados em uma caixa vertical (VBox), com espaçamento e alinhamento.

12. Criação da cena (Scene):

    • A VBox é usada como o layout da cena, que será exibida na janela com dimensões definidas (650x500).

Resumindo: este construtor monta a interface gráfica do CRUD de estudantes, cria os componentes da tela e define as ações dos botões para interagir com a tabela e os dados de estudantes.

3. TableView

A TableView em JavaFX é um componente gráfico usado para exibir e organizar dados em formato de tabela. Ela permite que os dados sejam apresentados em linhas e colunas, e o usuário pode selecionar, editar e visualizar essas informações de forma estruturada. 

A observableArrayList() cria uma lista observável que pode ser utilizada pela TableView para exibir e atualizar dados em tempo real.

A lista observável é especial porque notifica automaticamente a TableView sobre qualquer alteração na lista (como adição, remoção ou atualização de itens). Isso permite que a tabela seja atualizada dinamicamente sem precisar de recarregamento manual.

Como funciona a TableView:

1. Estrutura de Dados:

   • A TableView possui várias colunas (TableColumn), onde cada coluna representa um atributo dos objetos que estão sendo exibidos (como o RGA ou nome de um estudante).

   • Cada linha da tabela corresponde a um item de uma lista, como uma instância de um objeto (por exemplo, um objeto Estudante).

2. Colunas da Tabela:

   • As TableColumn são responsáveis por definir como os dados de cada objeto devem ser exibidos em cada coluna. Por exemplo, uma coluna pode exibir o nome do estudante e outra o RGA.

   • Cada coluna utiliza um método cellValueFactory para associar os dados da propriedade correta de cada objeto às células da tabela.

Como funciona a observableArrayList:

1. A lista de dados dos estudantes é criada com FXCollections.observableArrayList().

2. A TableView é configurada para usar essa lista observável como fonte de dados através do método setItems().

3. Quando um estudante é adicionado, atualizado ou removido da lista observável, a TableView reflete essas mudanças automaticamente na interface gráfica.

Isso simplifica a sincronização entre os dados e a tabela na interface do usuário.

4. Botões e Eventos

Um botão em JavaFX é um componente interativo que, quando clicado, pode executar uma ação específica. Para que um botão execute uma ação, ele precisa ter um evento associado. 

Como Funciona:

1. botaoCadastrar.setOnAction(...):

   • Este método configura um ouvinte de evento (ou event handler) para o botão botaoCadastrar. Isso significa que quando o botão for clicado, a ação definida no bloco de código dentro do setOnAction será executada.

2. new EventHandler<ActionEvent>() {...}:

   • Aqui, uma nova instância de EventHandler é criada para lidar com eventos do tipo ActionEvent (que é gerado quando o botão é clicado).

   • O método handle é sobrescrito, o que significa que você pode definir o que deve acontecer quando o evento ocorrer.

3. public void handle(ActionEvent e):

   • Este método é chamado automaticamente quando o botão é clicado. O parâmetro e é um objeto ActionEvent que contém informações sobre o evento (como qual botão foi clicado, se necessário).

4. Criação do Estudante:

   • Dentro do método handle, um novo objeto Estudante é criado usando os dados que foram inseridos nos campos de texto (textFieldNome e textFieldRGA). Aqui, o texto dos campos de entrada é obtido através de getText().

5. Adição à Lista:

   • O novo estudante é adicionado à listaDadosEstudantes, que é uma lista observável. Isso faz com que a tabela que exibe os estudantes atualize automaticamente, refletindo a adição do novo estudante.

6. Limpeza dos Campos de Texto:

   • Finalmente, o método limparTextFields() é chamado para limpar os campos de texto, permitindo que o usuário insira novos dados sem precisar apagar manualmente o que já estava lá.

5. public Scene getScene()

O método getScene() é uma forma de fornecer acesso à cena que foi configurada na classe. Quando chamado, ele retorna a cena (um objeto do tipo Scene) para que outras partes da aplicação possam utilizá-la, como configurá-la no palco da aplicação JavaFX. Isso permite que a cena seja reutilizada ou exibida em diferentes contextos dentro da aplicação.