Projeto Desktop

(1)

Aula 05/09/2016

https://sites.google.com/site/profalinerosafeuc

Prof. Aline Rosa

E-mail: aline.sr@gmail.com

RECAPITULANDO

Na última aula iniciamos a construção da Calculadora a partir do Diagrama de Classes, fizemos a classe e o formulário. Na classe criamos os atributos e métodos, no form inserimos os componentes, os eventos e a interação entre os dois. Vimos como fazer o tratamento de exceções.

Nesta aula vamos terminar os métodos das demais operações (subtrair, multiplicar e dividir) e ligar o form da calculadora no menu.

Iniciaremos um novo projeto utilizando Classe Abstrata e Poliformismo.

EVENTOS DE CLICK DO MOUSE PARA BOTÕES

Da mesma forma que criamos o evento de click do mouse para o botão Somar, criaremos para os demais botões.

EVENTO DO BOTÃO SUBTRAIR

1) Em modo design (projeto), dê dois cliques no botão Subtrair para gerar o código do evento.

2) Copie e cole o mesmo código do evento do botão Somar.

3) Altere o método a ser chamado conforme indicado em amarelo:

private void btnSubtrairActionPerformed(java.awt.event.ActionEvent evt) { // Instancia a classe.

Calculadora c = new Calculadora(); // Testa valores a serem enviados.

try{

// Envia valores do Campo de Texto para a variável.

c.setValor1(Double.parseDouble(txtValor1.getText())); c.setValor2(Double.parseDouble(txtValor2.getText())); // Recebe valor do método e exibe no Campo de Texto.

txtResultado.setText(String.valueOf(c.subtrair())); }catch(NumberFormatException erro){

// Exibe a mensagem de erro.

JOptionPane.showMessageDialog(null,"Informe valores válidos."); }

(2)

O código do botão Subtrair obedece à mesma lógica do botão Somar, lê os valores das campos de texto, envia para o método Subtrair(), recebe o cálculo e altera o valor do campo de texto Resultado para exibição.

O tratamento da exceção (erro) é o mesmo, caso o valor em qualquer um dos campos seja inválido, uma caixa de diálogo será exibida.

EVENTO DO BOTÃO MULTIPLICAR

1) Em modo design (projeto), dê dois cliques no botão Multiplicar para gerar o código do evento.

2) Copie e cole o mesmo código do evento do botão Subtrair. 3) Altere o método a ser chamado conforme indicado em amarelo:

private void btnMultiplicarActionPerformed(java.awt.event.ActionEvent evt) { // Instancia a classe.

try{

txtResultado.setText(String.valueOf(c.multiplicar())); }catch(NumberFormatException erro){

}

EVENTO DO BOTÃO DIVIDIR

1) Em modo design (projeto), dê dois cliques no botão Dividir para gerar o código do evento.

2) Copie e cole o mesmo código do evento do botão Multiplicar. 3) Altere o método a ser chamado conforme indicado em amarelo:

private void btnMultiplicarActionPerformed(java.awt.event.ActionEvent evt) { // Instancia a classe.

try{

txtResultado.setText(String.valueOf(c.dividir())); }catch(NumberFormatException erro){

}

(3)

LIGANDO FORMULÁRIOS

Vamos fazer a chamada da Calculadora pelo Menu através do Item de Menu e também do Botão na Barra de Ferramentas.

Clique em Menu para acessar o formulário.

Figura 1 - Acessando o formulário Menu

Dê dois cliques no Item de Menu: Calculadora para gerar o código.

Figura 2 - Gerando código do evento Click.

Dentro do método insira o código seguinte:

private void mniCalculadoraActionPerformed(java.awt.event.ActionEvent evt) { // Instancia a classe.

TelaCalculadora c = new TelaCalculadora();

// Torna o formulário visível.

c.setVisible(true); }

O código é o mesmo utilizado quando ligamos o form do Login com o do Menu. Instanciamos o form que queremos chamar e em seguida o tornamos visível.

Para chamar a Calculadora pela Barra de Ferramentas utilizaremos o mesmo processo do menu. Dê dois cliques no botão Calculadora para gerar o código, no método copie e cole o código do menu sem alterar nada.

private void tbCalculadoraActionPerformed(java.awt.event.ActionEvent evt) { // Instancia a classe.

TelaCalculadora c = new TelaCalculadora(); // Torna o formulário visível.

c.setVisible(true); }

(4)

INVOCANDO MÉTODOS SEM RETORNO

O projeto da calculadora está encerrado, mas vamos fazer alguns testes na Classe Calculadora. Vamos criar um método de Somar que não retorne valor.

MÉTODO VOID

Quando declaramos um método como Void não podemos utilizar “return” no final dele. O método Void apenas executa os comandos e retorna vazio ao finalizá-lo.

Insira o seguinte código na Classe Calculadora:

public void somar1(){

// Mostra o resultado na caixa de diálogo.

JOptionPane.showMessageDialog(null,"Resultado da Soma: " + (valor1 + valor2)); }

Como temos o método public double somar(), criamos agora o método private void somar1().

Queremos nele efetuar o cálculo e exibi-lo. Como não retornamos decidimos apresentá-lo numa caixa de diálogo JOptionPane. A função da caixa efetua a soma e exibe o resultado para o usuário.

Na classe TelaCalculadora vamos alterar o código no evento do Botão Somar.

private void btnSomarActionPerformed(java.awt.event.ActionEvent evt) {

// Instancia a classe.

Calculadora c = new Calculadora();

// Testa valores a serem enviados.

try{

c.setValor1(Double.parseDouble(txtValor1.getText())); c.setValor2(Double.parseDouble(txtValor2.getText()));

// Recebe valor do método Somar e exibe no Campo de Texto.

// Esta linha foi comentada: ---.

//txtResultado.setText(String.valueOf(c.somar()));

// Esta linha foi acrescentada: ---. c.somar1();

}catch(NumberFormatException erro){

}

No código, para não ser executado, deixamos comentado a linha onde o Campo de Texto txtResultado recebia o valor do método s.somar().

(5)

Na próxima vez que o botão Somar for pressionado, o método não irá mais exibir o resultado na janela da Calculadora, mas na caixa de diálogo.

Figura 3 - Resultado sendo exibido na caixa de diálogo.

O método do evento do Botão Somar continua enviando os valores para as variáveis na Classe Calculadora. O método Void consegue com os valores já passados, efetuar a somar e exibi-la.

FECHANDO A JANELA DA CALCULADORA

Pode acontecer de quando o botão Sair Tela da Calculadora for pressionado, toda a aplicação seja encerrada. Isso acontece pois definimos como System.exit(0) no evento de click. Altera para this.dispose() conforme mostra o código seguinte:

private void btnSairActionPerformed(java.awt.event.ActionEvent evt) { // Este código encerra a aplicação.

//System.exit(0);

// Este código fecha o formulário.

this.dispose(); }

Usando o dispose, descarregamos a janela da memória. Lembrando que a instrução “this” faz com que o comando seguinte seja referente à própria classe, neste caso ao formulário TelaCalculadora.

(6)

PROJETO DESKTOP

CLASSES ABSTRATAS, HERANÇA E POLIMORFISMO

Uma Classe Abstrata é uma classe que não será instanciada mas herdada. As classes herdadas dela poderão ser instanciadas.

Herança permite a criação de classificações hierárquicas. Usando herança, você pode

criar uma classe geral que defina características comuns a um conjunto de itens relacionados. Essa classe poderá então ser herdada por outras classes mais específicas, cada uma adicionando suas características exclusivas.

A classe que é herdada se chama superclasse. A classe que herda se chama subclasse. Portanto, uma subclasse é uma versão especializada da superclasse. Ela herda todas as variáveis e métodos definidos pela superclasse e adiciona seus próprios elementos exclusivos.

Java dá suporte à herança, permitindo que uma classe incorpore outra em sua decla- ração. Isso é feito com o uso da palavra-chave extends. Portanto, a subclasse traz acréscimos (estende) à superclasse

Numa Classe Abstrata podemos declarar variáveis e métodos que serão o mesmo em todas as subclasses. Porém, os métodos que serão diferentes em cada subclasse nós apenas declaramos seu cabeçalho e é o que chamamos de Polimorfismo.

Abstração e polimorfismo estão intimamente relacionados.

Vamos criar classes abstratas, e declarar somente o cabeçalho dos métodos. Esses serão os métodos abstratos: somente vamos dizer que tipos de métodos existem, através da declaração deles. Não podemos definir e criar o código desses métodos pois irão se comportar de modo diferente nas subclasses,porém, eles terão o mesmo nome.

Declarando classes abstratas e métodos abstratos em Java

Usamos, em ambos casos, a palavra-chave 'abstract' logo após o modificador de acesso (ou seja, logo após public, private ou protected):

classes:

public abstract class Conta { ... }

método:

(7)

ANALISANDO O DIAGRAMA DE CLASSES

Vamos iniciar um novo projeto com base no diagrama de classes seguinte:

Figura 4 - Diagrama de Classes do pacote Modelo

Neste diagrama temos o pacote (Modelo) contendo uma Classe Abstrata (Conta) e duas subclasses ligadas (ContaPadrao e ContaPopular).

Na classe Conta há a declaração de quatro atributos (nome, telefone, valorPulso e quantPulso) e um método abstrato (CalcularConta()).

As classes ContaPadrao e ContaPopular poderão utilizar os atributos da classe Conta sem a necessidade de instanciar. Também poderão utilizar o método CalcularConta(), para isso deve-se declarar @Override antes do método, esta instrução vai reescrever o método da classe Conta fazendo-a operar de maneira diferente em cada classe onde houver sua implementação.

CRIANDO UM NOVO PROJETO

Vamos implementar o diagrama de classes em um novo projeto. 1. Crie um novo projeto no Netbeans e chame-o de “Projeto2”.

2. Crie três classes Java com os nomes de “Conta”, “ContaPopular” e “ContaPadrao”, todas ficarão no pacote “Modelo”.

(8)

CLASSE CONTA

A classe Conta será a nossa classe abstrata. Vamos por os atributos e o método.

package Modelo;

public abstract class Conta {

private String nome; private String telefone; private double valorPulso; private int quantPulso;

public abstract double CalcularConta(); }

Clique com o botão direito do mouse sobre o código, no menu suspenso escolha

Inserir Código  Getter e Setter. Marque as quatro variáveis e confirme.

Agora temos a Classe Conta implementada:

package Modelo;

public abstract class Conta { private String nome; private String telefone; private double valorPulso; private int quantPulso;

public String getNome() {

return nome; }

public void setNome(String nome) {

this.nome = nome; }

public String getTelefone() {

return telefone; }

public void setTelefone(String telefone) {

this.telefone = telefone; }

public double getValorPulso() {

return valorPulso; }

public void setValorPulso(double valorPulso) { this.valorPulso = valorPulso;

}

public int getQuantPulso() {

return quantPulso; }

public void setQuantPulso(int quantPulso) { this.quantPulso = quantPulso;

}

public abstract double CalcularConta(); }

(9)

CLASSE CONTA PADRÃO

Vamos implementar a classe ContaPadrao conforme o diagrama de classes:

package Modelo;

public class ContaPadrão extends Conta{ private double assinatura;

public double CalcularConta() {

return (getValorPulso() * getQuantPulso() + getAssinatura()); }

}

Crie o getter e setter para a variável assinatura.

No método CalcularConta(), vamos retornar a multiplicação entre as variáveis

valorPulso e QuantPulso, que estão na classe Conta, com a soma da variável assinatura que está nessa classe. Como a classe Conta foi estendida não houve a necessidade de instanciá-la, usamos seus métodos como se fosse da própria classe ContaPadrão.

Repare que quando declaramos o “extends Conta”, houve uma sinalização de que a classe estendida contém métodos abstratos. Clique o botão direito do mouse para ver as opções.

Figura 6 - Dica para implementar os métodos.

Escolha: Implementar Todos os Métodos Abstratos.

Caso já tenhamos implementado o método “public double CalcularConta()” então a sinalização será outra:

Figura 7 - Dica para acrescentar @Override ao método.

Escolha: Adicionar Anotação @Override. E nossa classe já está pronta:

(10)

package Modelo;

public class ContaPadrao extends Conta{

private double assinatura; public double getAssinatura() { return assinatura;

}

public void setAssinatura(double assinatura) { this.assinatura = assinatura;

}

@Override

public double CalcularConta(){

return (getValorPulso() * getQuantPulso() + getAssinatura() ); }

}

CLASSE CONTAPOPULAR

Vamos implementar nossa última classe, a ContaPopular, conforme o diagrama de classes:

package Modelo;

public class ContaPopular extends Conta{ @Override

public double CalcularConta() {

return (getValorPulso() * getQuantPulso()); }

}

Esta classe não tem atributos portanto declaramos apenas o método CalcularConta(). Lembrando que podemos solicitar sua implementação automática ao estender a classe

Conta.

O método nesta classe irá funcionar diferente do que na classe ContaPadrao. Aqui irá retornar a multiplicação entre as variáveis valorPulso e quantPulso que estão na classe

Conta. Isso é o polimorfismo, quando o mesmo método é usado em diferentes classes com