Tutorial NetBeans

Prévia do material em texto

DASS - Programação Orientada a Objetos com Java - Prof Gilmar Carvalho
Como criar projetos na IDE NetBeans
1.1 Criar um novo Projeto e escolher o tipo do projeto.
Após abrir o NetBeans clique em Arquivo e Novo Projeto / File e New Project
	Projeto = Sistema
Um projeto é um conjunto de classes organizadas em pacotes com o objetivo de executar os Casos de Uso especificados para um Sistema ou criar uma Biblioteca de Classes (Aplication Programan Interface - API)
Escolher Projeto: Categoria: Java e Projeto: Aplicação Java.
1.2 Escolher a localização do projeto.
O nome do projeto deverá sempre começar com a primeira letra em maiúscula e as demais em minúscula. Caso o nome seja composto por duas palavras, a segunda deverá, também, começar com maiúscula e o restante em minúsculo.
1.3 Configuração inicial do projeto ControleBibliotecario
1.4 Criando os pacotes do projeto MVC
Model-view-controller (MVC), em português modelo-visão-controlador, é um padrão de arquitetura de software (design pattern) que separa a representação da informação da interação do usuário com ele. O modelo (model) consiste nos dados da aplicação, regras de negócios, lógica e funções. Uma visão (view) pode ser qualquer saída de representação dos dados, como uma tabela ou um diagrama. É possível ter várias visões do mesmo dado, como um gráfico de barras para gerenciamento e uma visão tabular para contadores. O controlador (controller) faz a mediação da entrada, convertendo-a em comandos para o modelo ou visão. As ideias centrais por trás do MVC são a reusabilidade de código e separação de conceitos. (fonte: https://pt.wikipedia.org/wiki/MVC)
Clique com o botão direito do mouse sobre o o ícone do pacote e aparecerá a tela
Clique em Pacote Java e altere o nome do pacote para controlebibliotecario.view
Repita o procedimento anterior para criar os pacotes controlebibliotecario.control e controlebibliotecario.model. Ao final você tera a seguinte configuração de pacotes:
1.5 Conteúdo dos Pacotes para aquitetura MVC (Model, View e Control)
Pacote controlebibliotecario
	Este pacote conterá apenas uma classe. Esta classe sempre terá o nome do projeto (ControleBibliotecario.java) e apenas o método principal (public static void main(String[] args))
Pacote controlebibliotecario.view
	Este pacote conterá as classes de telas da aplicação.
Pacote controlebibliotecario.control
	Este pacote conterá as classes de controle.
	Classes de controle são classes que fazem uma ponte entre os pacotes da view e model.
Essas classes implementam as regras de negócio
Pacote controlebibliotecario.model
	Este pacote conterá as classes de persistência de dados, ou seja, as classes de de 
controle (CRUD - Create, Read, Update e Delete) e de Entidades de Banco de Dados.
2. Exemplo de uma aplicação com apenas duas camadas (view e model)
2.1 Análise
2.1.1 Descrição textual do Sistema Controle Bibliotecário
Uma biblioteca quer automatizar seus registros de livros, leitores e empréstimos. Nessa biblioteca o prazo de devolução é de uma semana, não há multa, e não há limite para retirada de livros. O sistema deve permitir, ao leitor ou bibliotecária, a manutenção do cadastro de livros (inclusão, exclusão e consulta) e registro de consultas (para verificar se o livro está disponível ou emprestado). O Sistema também deve fornecer consultas a usuários em atraso e livros disponíveis e retirados.
2.1.2 Casos de Uso
Manter (incluir, excluir, alterar) livros
Consultar livros
Consultar usuários em atraso
Manter usuários
Consultar livros disponíveis
Consultar livros emprestados
2.1.3 Caso de Uso Manter Livros
Sistema: 			Controle Bibliotecário
Nome do Caso de Uso: 	Manter Livros
Ator: 				Bibliotecária
Pré-condição: 			Menu do sistema disponível para a Bibliotecária
1) O caso de uso começa quando a Bibliotecária acessa a tela Manter Livros
2) O Sistema exibe uma tela com os campos para cadastramento (código do livro, título, autor, ISBN, Editora)
3) A Bibliotecária digita o código do livro
4) A Bibliotecária clica no botão consultar
5) O Sistema localiza o livro e exibe os dados na tela.
6) A bibliotecária preenche os dados na tela.
7) A bibliotecária clica num dos botões: Incluir, Excluir ou Alterar
8) O Sistema valida os dados (exceção 1)
9) O Sistema faz a manutenção (inclui, exclui ou altera) o livro.
Exceção 1
O Sistema envia ao bibliotecário uma mensagem dizendo qual campo foi preenchido incorretamente.
Tela de Menu
Tela do Caso de Uso Manter Livros
2.1.3 Caso de Consultar Livros
Sistema: 			Controle Bibliotecário
Nome do Caso de Uso: 	Consultar Livros
Ator: 				Bibliotecária e Usuário
Pré-condição: 			Menu do sistema disponível para a Bibliotecária/usuário
1) O caso de uso começa quando a Bibliotecária/usuario acessa a consultar livros
2) O Sistema exibe uma tela com as opcções de consulta 
3) A Bibliotecária opta por uma das opções de consulta: autor, titurlo, editora ou ano.
4) A Bibliotecária clica no botão consultar
5) O Sistema localiza os livros e exibe os dados na tela.
6) A bibliotecária clica no botão limpar
7) O Sistema lmpa a tela
2.1.4 Entidade de Banco de Dados
Biblioteca 	(código, nome, endereço,CEP, cidade, UF)
	Livro 		(código, título, autor, editora, ISBN, ano)
	Leitor 		(código, nome, endereço, CEP, cidade, UF)
	Empréstimo 	(códigoLivro, códigoLeitor, dataSaida, dataDevolução)
	Diagrama de Clases
	
2.2 Desenvolvimento do projeto em Java com NetBeans
2.2.1 Criando a tela Manter Livros (pacote view)
Abra o projeto ControleBibliotecario (file/open project)
Clique com o botão direito do mouse sobre o pacote controlebibliotecario.view
Clique na opção Form JFrame. Caso não encontre esta opção clique em outros(others) e opte pela cotegoria Forms GUI Swing e tipo de arquivo Form JFrame.
Clique em próximo(next) e atribua o nome da classe TelaManutencaoLivros. Verifique se o pacote é controlebibliotecario.view e clique em Finalizar. 
Será exibido a seguinte tela:
	No canto esquerdo temos a estrutura do projeto.
	No centro uma tela em branco para onde serão arrastados os componentes (Controles Swing)
	Na direita temos os componentes (Controles Swing)
Nesta primeira etapa vamos usar apenas os componetes Label, Campo de Texto e Botão.
Rótulo (Label) - Componente utilizado para escrever um rótulo na tela (Título da tela, descriçaõ do conteúdo de um componente, etc.)
Campo de Texto (JTextField) - Componente que permite a entrada de uma linha de texto (String).
Botão (Button) - Componente que executa uma ação para a tela.
Inserindo o título da tela
Clique no componente Label e clique na tela (centro).
Aparecerá um compoente jLabel1 
Para alterar as propriedades deste componente, clique com o botão da direita sobre ele. 
Aparecerá o menu:
A opção Editar Texto permite alterar o texto do Label. Clique nesta opção e escreva o título da tela: Manutenção de Livros.
Inserindo os campos de entrada de dados
	Por enquanto vamos usar apenas o componte Campo de Texto (JTextField).
	Para cada Campo de Texto que inserirmos na tela vamos acrescentar um Label (JLabel) descrevendo o que conterá este campo.
	Clique no componete Campo de Texto da paleta Controles Swing (direita da tela).
	Agoraclique na posição da tela que você quer que este componente apareça.
	Agora clique com o botão da direita sobre ele para limpar o texto (Editar Texto) do componente e dar um nome para este componente (Alterar o Nome da Variável). O Nome da Variável deverá obedecer o padrão de nomes para variáveis do java. Neste caso usaremos o nome de variável codigoDoLivro.
	Repita esta operação para os demais campos de texto da tela.
Inserindo os botões
	Clique no componente Botão da paleta de Controles Swing clique na posição da tela que você quer que este componente apareça. Mude o rótulo do botão clicando com o botão da direta sobre este componente e clique em Editar Texto (digite o títulodo botão: Consultar, Gravar, Alterar ou Excluir). Clique com o botão da direita sobre o componente e clique em Alterar Nome da Variável (ex: botaoConsultar, botaoGravar, botaoAlterar, botaoExcluir).
2.2.2 Criando as classes de Entidades de Banco de Dados (pacote model)
Na análise do sistema Controle Bibliotecário, identificamos as seguintes Classes de Entidades de Banco de Dados:
Biblioteca 	(código, nome, endereço,CEP, cidade, UF)
	Livro 		(código, título, autor, editora, ISBN, ano)
	Leitor 		(código, nome, endereço, CEP, cidade, UF)
	Empréstimo 	(códigoLivro, códigoLeitor, dataSaida, dataDevolução)
Criando a Classe Entidade de Banco de Dados para a classe Livro.
Clique com o botão da direita sobre o pacote model, Novo e Classe Java.
Dê o nome Livro para a classe.
Digite o código abaixo:
	 package controlebibliotecario.model;
import java.util.Objects;
public class Livro {
 private String codigoLivro;
 private String titulo;
 private String autor;
 private String editora;
 private String ISBN;
 private Integer ano;
 public Livro(String codigoLivro, String titulo, String autor, String editora, String ISBN, Integer ano) {
 // codigoLivro é uma variável locall
 // this.codigoLivro é um atributo
 this.codigoLivro = codigoLivro;
 this.titulo = titulo;
 this.autor = autor;
 this.editora = editora;
 this.ISBN = ISBN;
 this.ano = ano;
 }
 public String getCodigoLivro() {
 return codigoLivro;
 }
 public void setCodigoLivro(String codigoLivro) {
 this.codigoLivro = codigoLivro;
 }
 public String getTitulo() {
 return titulo;
 }
 public void setTitulo(String titulo) {
 this.titulo = titulo;
 }
 public String getAutor() {
 return autor;
 }
 public void setAutor(String autor) {
 this.autor = autor;
 }
 public String getEditora() {
 return editora;
 }
 public void setEditora(String editora) {
 this.editora = editora;
 }
 public String getISBN() {
 return ISBN;
 }
 public void setISBN(String ISBN) {
 this.ISBN = ISBN;
 }
 public Integer getAno() {
 return ano;
 }
 public void setAno(Integer ano) {
 this.ano = ano;
 }
 @Override
 public String toString() {
 return "Livro{" + "codigoLivro=" + codigoLivro + ", titulo=" + titulo + ", autor=" + autor + ", editora=" + editora + ", ISBN=" + ISBN + ", ano=" + ano + '}';
 }
 @Override
 public int hashCode() {
 int hash = 5;
 hash = 37 * hash + Objects.hashCode(this.codigoLivro);
 return hash;
 }
 @Override
 public boolean equals(Object obj) {
 if (obj == null) {
 return false;
 }
 if (getClass() != obj.getClass()) {
 return false;
 }
 final Livro other = (Livro) obj;
 if (!Objects.equals(this.codigoLivro, other.codigoLivro)) {
 return false;
 }
 return true;
 }
 
 
}
Agora vamos criar a classe Contraladora para Livro. Esta classe será a responsável por fazer o CRUD de Livro, ou seja, inserir um livro, recuperar um livro, atualizar os dados de um livro ou excluir um livro.
Clique com o botão da direita sobre o pacote model, Novo e Classe Java.
Dê o nome de ControleLivros para esta classe..
Digite o código abaixo:
import controlebibliotecario.model.Livro;
import java.util.ArrayList;
import java.util.List;
public class ControleLivros {
 ArrayList<Livro> livros = new ArrayList<Livro>();
 public void incluirLivro (Livro x){
 livros.add(x);
 }
 public void excluirLivro (Livro x){
 for (Livro y:livros){
 if (y.equals(x)){
 livros.remove(y);
 }
 }
 }
 public void alterarLivro (Livro x){
 for (Livro y: livros){
 if (y.equals(x)){
 y.setAutor(x.getAutor());
 y.setTitulo(x.getTitulo());
 y.setEditora(x.getEditora());
 y.setISBN(x.getISBN());
 y.setAno(x.getAno());
 }
 }
 }
 public Livro consultarLivro (String codigoLivro){
 Livro livroRetorno=null;
 for (Livro y: livros){
 if (y.getCodigoLivro().equals(codigoLivro)){
 livroRetorno = y;
 }
 }
 return livroRetorno;
 }
 
}
2.2.3 Modelo UML da Aplicação com duas camadas (View e Model)
	Diagrama de Classes
	Esse diagrama de classes exibe como as classes estão relacionadas e o pacote a que pertencem. Há dois tipos de relacionamentos: 
a) Dependência ( ) Este tipo de relacionamento se dá através de um método. A variável de referência do objeto - no caso acima, uma instância da classe TelaManterLivros - é uma variável local dentro de uma método da classe ControleBibliotecario. Portanto, assim que o método - nesse caso o método main da classe ControleBibliotecário - terminar, a variável será descartada. Esse relacionamento existe também entre a classe TelaManterLivros e a classe Livro (vide exemplos abaixo). 
Exemplos:
 public static void main(String[] args) {
 TelaManterLivros tml = new TelaManterLivros();
 tml.setVisible(true);
 }
 private void botaoIncluirActionPerformed(java.awt.event.ActionEvent evt) { 
 Livro umLivro = new Livro(
 this.codigoLivro.getText(),
 this.tituloLivro.getText(),
 this.autor.getText(),
 this.isbn.getText(),
 Integer.parseInt(this.ano.getText())
 );
 controleLivros.incluirLivro(umLivro);
 
 } 
b) Associação () Este tipo relacionamento se dá através de um atributo do tipo uma classe. Esse relaciomento existe enquanto o objeto existir. 
Exemplos:
public class TelaManterLivros extends javax.swing.JFrame {
 private ControleLivros controleLivros;
public class ControleLivros {
 private ArrayList<Livro> livros;
2.2.4 Como Conectar as Classes desse Sistema (relacionamentos)
Classe ControleBibliotecário com TelaManterLivros
	A Classe ManterLivros é a classe a partir do qual o sistema será inicializado.
	Essa classe tem apenas o método main - método que é executado pela máquina virtual Java. Esse método criará uma instância/objeto (new) da classe TelaManterLivros e executará o método setVisible(true) desse objeto. O relacionamento da classe ControleBibliotecario com a TelaManterLivros será do tipo dependência ( ), que significa um relacionamento acionado através de um método, portanto, temporário.
public class ControleBibliotecario {
 		public static void main(String[] args) {
 			TelaManterLivros tml = new TelaManterLivros();
 			 tml.setVisible(true);
 		 }
 
}
Classe TelaManterLivros com ControleLivros
Essa classe terá sempre associado a ela um atributo do tipo ControleLivros, que servirá para fazer o CRUD de Livro. Essa relação é do tipo associaçao () - significa que essa classe tem um atributo do tipo ControleLivros.
public class TelaManterLivros extends javax.swing.JFrame {
		private ControleLivros controleLivros;
		public TelaManterLivros() {
 			controleLivros = new ControleLivros();
 			initComponents();
		}
Vamos associar aos botões (Consultar, Incluir, Alterar e Excluir), métodos que serão acinados quando clicarmos nesses botões.
Para associar um evento (clicar) sobre um componente do tipo botão (JButton):
	a) Botão Consultar : Clique com o botão da direita do mouse sobre o o botão Consultar.
 
	b) Clique na opção Eventos/Action/actionPerformed.Será criado um método que será acionado (vide abaixo) sempre que clicarmos no botão.
	private void botaoConsultarActionPerformed(java.awt.event.ActionEvent evt) { 	 
 		String codigoLivro = this.codigoLivro.getText();
 		Livro umLivro = controleLivros.consultarLivro(codigoLivro);
 		if (umLivro != null){
 			this.autor.setText(umLivro.getAutor());
 			this.ano.setText(umLivro.getAno().toString());
 			this.isbn.setText(umLivro.getISBN());
 		} else {
 			JOptionPane.showMessageDialog (null,"Livro Inexistente");
 		}
 	 
	}
	c) Botão Incluir: Clique com o botão da direita do mouse sobre o botão Incluir.
	private void botaoIncluirActionPerformed(java.awt.event.ActionEvent evt) { 	 
 		Livro umLivro = new Livro(
 					this.codigoLivro.getText(),
 					this.tituloLivro.getText(),
 					this.autor.getText(),
 					this.isbn.getText(),
 					Integer.parseInt(this.ano.getText()));
 		controleLivros.incluirLivro(umLivro);
 	 
	}
d) Botão Excluir
	
Classe ControleLivros de Livro
A classe ControleLivros terá um conjunto (ArrayList) de objetos do tipo Livro. Essa classe terá os métodos que permirão fazer o CRUD (incluir, consultar, alterar e excluir) de objetos do tipo Livro do ArrayList de Livro. Essa relação entre ControleLivros e Livro é do tipo associação - essa classe terá um atributo do tipo ArrayList<Livro>. Temos, através da classe ArrayList<Livro>, um relacionamento do tipo um para muitos, ou melhor, um objeto da classe ControleLivros terá um conjunto de zero ou n objetos do tipo Livro.
package controlebibliotecario.model;
import java.awt.List;
import java.util.ArrayList;
public class ControleLivros {
 private ArrayList<Livro> livros;
 public ControleLivros() {
 livros = new ArrayList<Livro>();
 }
 public void incluirLivro (Livro x){
 livros.add(x);
 }
 public void alterarLivro (Livro x){
 for (Livro y : livros){
 if (x.equals(y)){
 y.setAno(x.getAno());
 y.setAutor(x.getAutor());
 y.setISBN(x.getISBN());
 y.setTitulo(x.getTitulo());
 }
 }
 }
 public void excluirLivro (Livro x){
 for (Livro y : livros){
 if (x.equals(y)){
 livros.remove(x);
 }
 }
 }
 public Livro consultarLivro(String codigoLivro){
 Livro livroRetorno = null;
 for (Livro y : livros){
 if (y.getCodigoLivro().equals(codigoLivro)){
 livroRetorno = y;
 }
 }
 return livroRetorno;
 }
}
2.3 Diagrama de Sequência (UML) do CDU Manter Livros
	Os Diagramas de Sequência são utilizados para modelar os aspectos dinâmicos de sistemas. Esse diagrama mostra uma interação (geralmente um Caso de Uso), formada por um conjunto de objetos e seus relacionametnos, incluindo as mensagens que poderão ser enviadas entre eles. Esse digrama enfatiza à ordenação temporal das mensagens.
No exemplo acima vemos um trecho de diagrama de sequẽncia para o caso de uso ManterLivro. Os retângulos representam os objetos (variável de referência : Classe). As setas são as mensagens (métodos) que um objeto requisita de outro. As mensagens (chamadas de métodos de um objeto por outro) pode ser síncronas ou assíncronas. Quando a mensagem é assíncrona (sem retorno), a seta é fina, quando é síncrona (chamada com retorno) a linha tem uma seta retangular cheia. Uma resposta de uma mensagem síncrona é representada por uma linha tracejada com uma seta fina.
2.4 Conceitos de Orientação a Objetos utilizados neste projeto.
2.4.1 Camada de Visão
2.4.1.1 Componente
Um componente é um objeto que tem uma representação gráfica que pode ser exibido numa tela GUI (Graphical User Interface) e que pode interagir (respoder a eventos como clicar, arrastar, etc.) com o usuário. Exemplos de componentes são os buttons, checkboxes, comboboxes , radiobuttons, textfields, labels, frames, etc.
Os componentes que foram utilizados nessa aplicação pertencem ao pacote javax.swing e estão agrupados em Controles Swing da paleta de componentes do NetBeans: javax.swing.JButton, javax.swing.JCheckBox, javax.swing.JComboBox, javax.swing.JRadioButton, javax.swing.JTextFiled, javax.swing.JLabel, etc.
2.4.1.2 Herança
Um outro tipo de componentes são os contêineres. Os componentes do tipo contêiner podem agrupar outros componentes no seu interior (Ex. JFrame, JPanel, JScrollPanel, etc.)
Quando criamos a tela ManterLivros optamos pelo JFrame que é um componente do tipo contêiner. Ao criarmos a classe ManterLivros, o que aconteceu foi que essa classe passou a ser um JFrame, ou seja, herdou as características (atributos) e comportamentos (métodos) da classe JFrame. Podemos ver essa herança explícita no código da classe ManterLivros:
public class TelaManterLivros extends javax.swing.JFrame {
…
Em UML
2.4.1.3 Tratamento de eventos
	Um comportamento associado as classes que definem os componentes é a capacidade de interagir com os usuários. Assim, um componente pode ser programado (método) para ter uma ação quando o usário clica nele, arrasta, entra, sai, etc.
Os eventos são objetos criados quando uma ação sobre um componente é executada. Por exemplo, quando programamos o botão Consultar para que ele executasse uma consulta à lista de livros, optamos pelo evento ActionPerformed (clicar sobre o botão) para executar a ação desejada.
Vimos então que foi criado o seguinte método:
private void botaoConsultarActionPerformed(java.awt.event.ActionEvent evt) { 	 
}
Nome do método: botaoConsultarActionPerformed
Retorno do método: void
Parâmetros do método: ActionEvent evt
Percebemos que:
a) o nome do método está associado ao nome do componente + o nome do evento,
b) o método não devolverá (return) nenhum valor, após o término da execução,
c) o método receberá um objeto do tipo ActionEvent associado a variável evt.
Os itens a e b são perfeitamente entendidos. A questão é como associar a um componente um evento. Se expandirmos o método initComponents() veremos que:
a) foi gerado uma instância de JButton: consultar = new javax.swing.JButton()
b) foi acionado o método addActionListener do botão consultar:
 botaoconsultar.addActionListener(new java.awt.event.ActionListener() {
 public void actionPerformed(java.awt.event.ActionEvent evt) {
 consultarActionPerformed(evt);
 }
 });
Para entender este comando é preciso entender que:
a) O método addActionListener recebe um parâmetro que é um objeto do tipo ActionListener.
b) Se observamos a descrição do parâmetro veremos o comando new indicando que ali será criado um objeto do tipo ActionListener.
c) Essa forma de criar um objeto diretamento no parâmetro é chamado de inner class anônima.
2.4.1.4 Estado de um objeto.
	O estado de um objeto envolve todos os atributos (propriedades) do objeto juntamente com valores atuais de cada uma desses atributos. O estado de um objeto é dinâmico. Assim, ao visualizar seu estado, estamos realmente especificando o valor de seu estado em um determinado momento no tempo e no espaço.
	Uma classe que não tem nenhum atributo próprio ou herdado, terá sempre o mesmo estado para todos os objetos criados. O mesmo vale se os atributos forem todos do tipo static. Nesse caso, geralmente os métodos da classe têm o modificador static indicando que o método pode ser chamado sem a necessidade de criar uma instância/objeto, bastando apenas que se faça referência ao nome da classe, seguido de ponto e o nome do método. As classes que agrupam funções como a classe Math do pacote java.lang, têm seus métodos declarados como static, portanto podemos acionar seus métodos diretamentepelo nome da classe (Ex. Math.cos(), Math.pow(double a, double b), Math.cos(double a), Math.sqrt(double a), Math.round(double a), Math.random(), etc.).
	
	
 
2.4.2 Camada Modelo
2.4.2.1 Classe de Entidade
2.4.2.2 Classe de Controle
2.4.2.3 Listas (ArrayList)