Esta é uma pré-visualização de arquivo. Entre para ver o arquivo original
Linguagem de Programação
Aula 1: Introdução à Linguagem de Programação
Java
Introdução Às Linguagens De Programação
Linguagem de Programação:
Conjunto de regras sintáticas e semânticas, utilizados para se estabelecer
comunicação entre o programador e o computador.
São usadas para se escrever programas ou softwares.
Métodos de implementação de Linguagens de Programação:
É a forma como uma linguagem de programação se comunica (é entendida e
executada) com o computador.
O computador possui uma linguagem de máquina de nível baixo que oferece
operações primitivas.
O software de sistema deve criar uma interface com os programas de nível
mais alto.
O sistema operacional e as implementações de linguagens são dispostos em
camadas sobre a interface de linguagem de máquina de um computador.
Introdução ao Java
Linguagem de programação orientada a objetos desenvolvida por um time de
programadores, liderados por Patrick Naughton, Mike Sheridan e James
Gosling, na empresa Sun Microsystems.
Linguagem de Alto desempenho, suporta multithreading, compilação just-in-
time e utilização de código nativo.
É uma linguagem que é compilada para um “bytecode”, que é interpretada
por uma máquina virtual – JVM.
Bytecode
É a compilação de um programa escrito em Java, com o objetivo de ser
interpretado pela máquina virtual Java - JVM.
Principais características:
Portabilidade
O Java pode ser executado em qualquer plataforma ou equipamento
que possua um interpretador Java e que tenha sido especialmente
compilado para o sistema a ser utilizado.
Orientada a Objetos
Contém a sintaxe similar a linguagem C/C++, mas é baseada no modelo
Simula67.
Segurança
Pode ser executado via rede, com restrições de execução, além de
proteger o sistema do cliente contra possíveis ataques não
intencionais.
Por que estudar Java?
Orientação a Objetos: totalmente 00 - permitindo herança e reutilização de
código de forma dinâmica e estática.
Dinamismo: permite ser aumentado durante a execução.
Facilidade: Derivada do C/C++ - Bem familiar. O ambiente retira do
programador a responsabilidade de gerenciar a memória e os ponteiros.
Utilizações e Aplicações do Java:
Desenvolvimento de aplicativos corporativos de grande porte.
Desenvolvimento de aplicativos Web.
Fornecimento de aplicativos para dispositivos voltados para o consumo
popular (celulares, pagers, PDAS etc).
Muitos outros propósitos.
Editor
E a escrita ou desenvolvimento do programa -código fonte. Se faz necessário
um editor de texto simples como o bloco de notas do Windows ou vi do Linux.
Existem os ambientes de desenvolvimento integrado (IDE - Integrated
Development Enviroment) que fornecem muitas ferramentas de suporte ao
processo de desenvolvimento de software em Java e outras Linguagens.
NetBeans.
Eclipse.
JCreator.
BLueJ.
Compilador
O compilador Java converte o código-fonte Java em bytecodes, que
representam as tarefas a serem realizadas durante a fase de execução. Os
bytecodes são executados pela Java Virtual Machine (JVM) uma parte do JDK
e a base da plataforma Java.
A máquina virtual Java (VM virtual machine) é um aplicativo de software que
simula um computador, mas oculta o sistema operacional e o hardware
subjacentes dos programas que interagem com a VM.
Carregador
Todo programa deve ser colocado na memória antes de poder executar, O
carregador de classe transfere os arquivos .class contendo os bytecodes do
programa para a memória principal. O carregador de classe também carrega
qualquer arquivo class fornecido pelo Java que seu programa utiliza. Os
arquivos .cLass podem ser carregados a partir de um disco em seu sistema ou
em uma rede.
Verificador
Enquanto as classes são carregadas, o verificador de bytecode examina os
códigos para assegurar que eles são válidos e não violam restrições de
segurança do Java. O Java impõe uma forte segurança para certificar-se de
que os programas Java que chegam pela rede não danifiquem os arquivos do
sistema.
Interpretador
Execução
A JVM executa o programa interpretando o bytecodes gerado na fase de
compilação.
Com isso, sequências de ações especificadas pelo programado são, enfim,
executadas.
Atualmente, as JVM utilizam uma combinação de interpretação e de
compilação just-in-time (JIT). Nesse processo, a JVM analisa os bytecodes à
medida que eles são interpretados.
Procurando hot spots (pontos ativos) – parte dos bytecodes, que são
executadas com frequência. Para essas partes, um compilador MT, conhecido
como compilador Java HotSpot, traduz os bytecodes para a linguagem de
máquina do computador subjacente.
Ambiente De Programação Em Java
O ambiente de desenvolvimento de software Java, Java SDK (antigamente,
JDK), é formado, essencialmente, por um conjunto de aplicativos que permite,
entre outras tarefas, realizar a compilação e a execução de programas
escritos na linguagem Java. Este ambiente pode ser baixado gratuitamente a
partir do site da Sun Microsystems http://java.sun.com.
As ferramentas básicas do kit de desenvolvimento Java são:
O compilador Java, javac.
O interpretador de aplicações Java (máquina virtual), java.
O interpretador de Applets Java, appletviewer.
Java2 Standard Edition – Fornece as principais APIs e enfoca o
desenvolvimento de aplicações na arquitetura Cliente – Servidor. Não permite
distribuição de objetos nem oferece suporte a tecnologias para Internet.
Java2 Enterprise Edition – Fornece um conjunto de APIs para o
desenvolvimento corporativo e enfoca na integração entre sistemas.
Disponibiliza alta distribuição de objetos e oferece total suporte a tecnologias
para Internet.
Java2 Micro Edition – Fornece as APIs para o desenvolvimento de aplicações
para computação móvel, em pequenos dispositivos ou tecnologias
embarcadas.
Tipos De Programas Java
Stand-Alone – Aplicações baseadas na J2SE que tem total acesso aos recursos
do sistema, memória, disco, rede, dispositivos, etc.
Java Applets - Pequenas aplicações que não têm acesso aos recursos de
hardware, necessitando de um navegador com suporte a J2SE para serem
executados.
Java Servlets - Programas desenvolvidos para serem executados em
servidores Web, baseados na J2EE, comumente usados para gerar conteúdos
dinâmicos para websites.
Java Midlets - Pequenas aplicações, extremamente seguras e construídas
para serem executadas dentro do J2ME.
Java Beans - São componentes de software escritos em Java que podem ser
manipulados visualmente com a ajuda de uma ferramenta de
desenvolvimento.
Construindo um Ambiente para Programação em Java
Para desenvolver programas em Java, precisamos obter o Kit de
Desenvolvimento Java, que é gratuito e disponível para download no seguinte
endereço:
http://java.sun.com/javase/downloads/index.jsp
Neste link, a Sun disponibiliza uma série de kit’s para cada perfil. Sugerimos o
JDK – JRE.
É necessário, ainda, que o usuário escolha a plataforma (o computador e
sistema operacional) onde o kit será instalado.
Escrevendo E Executando O Primeiro Programa
Abra o bloco de notas e digite o código
public class PrimeiroPrograma{
public static void main(String args[]){
System.out.println(“Bem vindo ao Mundo Java”);
}
}
Em Java, uma classe pública deve ser salva em um arquivo com o mesmo
nome, com a extensão .java. Como nossa classe se chama PrimeiroPrograma,
devemos salvar este arquivo como PrimeiroPrograma.java. Muita atenção
com a caixa da letra, pois o Java faz diferença entre letras maiúsculas e
minúsculas.
Abra o prompt do DOS. Para compilar o código, iremos usar uma ferramenta
SDK, o compilador javac. Isso faz com que o bytecode seja gerado. Este
processo
faz com que o arquivo PrimeiroPrograma.class seja gerado.
Observe na figura abaixo que estamos na pasta onde salvamos o nosso
arquivo PrimeiroPrograma.java. O comando javac foi executado, nenhum erro
foi encontrado e foi gerado o arquivo PrimeiroPrograma.class.
Para executar este código, temos que chamar a máquina virtual. Para isso,
basta:
java PrimeiroPrograma
Observe que não há necessidade de colocar a extensão neste passo.
Não é um ambiente de desenvolvimento de software Java.
JVM
Escolha a opção que não é uma característica do Java.
Linguagem de programação estruturada
Aula 2: Tipos de Dados e Estruturas Básicas de
Programação
As convenções do Java
A linguagem de programação Java é “Case Sensitive”. Existem várias
convenções utilizadas. São elas:
Nomes de variáveis e métodos começam com letras minúsculas.
Nomes de classes iniciam com letras maiúsculas.
Nomes composto: utilizar letras maiúsculas para as iniciais das
palavras.
Letras maiúsculas para as constantes.
Comentários em Java
Existem três formas de se inserir comentários :
1. // - Comentários em uma linha;
2. /* */ - Comentário em uma ou mais linhas;
3. /** */ - Documento Comentários
Quando o comentário tipo 3 é colocado imediatamente acima da
declaração (de uma função ou variável), indica que o comentário
poderá ser incluído automaticamente em uma página HTML
(gerado pelo comando javadoc gerador de documentação do
Java)
Tipos de Dados em Java
O Java é uma linguagem de programação fortemente tipada, ou melhor,
necessita que todas as variáveis tenham um tipo declarado. Existem 8 tipos
primitivos. Seis deles são numéricos, um é o caractere e o último é o
booleano.
Declarando E Atribuindo Valores A Variáveis
A declaração de variáveis em Java exige que o tipo da variável seja declarado.
Você inicia a declaração, indicando o tipo da variável e o nome desejado,
como nos exemplos a seguir:
int x, y; //declarando duas variáveis inteiras
x = 6; //atribuindo valores a variáveis
y = 1000;
float f = 3,141516f; //ponto flutuante
double w = 3,2310834; //ponto flutuante de dupla precisão
char ch = ‘a’; //Caractere
final int MAX = 9; Define a constante MAX com o valor de 9
Operadores Aritméticos e Relacionais
Dica:
O operador ! é chamado de not ou negado.
Operadores Aritméticos
Operadores Relacionados
Estruturas Básicas De Programação
Os comandos da linguagem permitem controlar o fluxo do programa e
expressões condicionais.
Blocos
Conjunto de linhas de códigos situadas entre um abre e um fecha chaves( {} ).
É permitido criar blocos dentro de blocos.
{ //início de bloco
...
/*bloco de comandos*/
...
} //fim de bloco
Escopo das variáveis
Escopo de uma variável indica em que parte do código ou bloco de comandos
do programa que podemos utilizar ou enxergar a variável. Existem variáveis
locais e variáveis globais. O escopo define também quando a variável será
criada e destruída da memória. As locais estão visíveis apenas dentro do bloco
enquanto as globais estão disponíveis em qualquer bloco do programa.
Observação: escopo é diferente de visibilidade, o qual se aplica as variáveis de
classe e tem a ver com a utilização destas fora da classe.
Comando Condicional
Desvia o fluxo natural do programa de acordo com o resultado de um teste
lógico.
if (expressão booleana)
comando1 ou (bloco de comandos1}
else
comando2 ou (bloco de comandos2}
Quando o programa encontra um comando if, a expressão booleana é
avaliada. Caso a expressão seja verdadeira, o comando1 é executado e o
comando 2 não. Caso a expressão seja falsa, o comando2 é executado e não o
comando 1. Vale lembrar que o else é opcional.
Quando existe um conjunto de opções, podemos utilizar a estrutura switch–
case.
switch (variável)
case(valor1 ):comando1; break;
case(valor2):comando2; break;
case(valor3):comando3; break;
default:comando..genérico; break;
Nesta estrutura, o programa avalia a variável. Caso o valor seja valor1, o
comando 1 é executado; caso seja valor2, o comando 2 é executado; e assim
sucessivamente... Caso não seja encontrado o valor, o comando genérico é
executado.
Desvio de Fluxo
Existem dois tipos de desvios de fluxo.
Break
O comando termina a execução de um loop sem executar o resto
dos comandos e torça a saída do laço.
Continue;
O comando termina a execução de um laço sem executar o resto
dos comandos, voltando para o início do laço, para uma nova
iteração.
Estrutura de Repetição ou Laço
1. white(expressão)
Comando ou {bloco de comandos}
Enquanto a expressão for verdadeira, o comando será executado.
Quando a expressão for falsa, o programa segue para o seu caminho
normal.
2. Do
Comando ou {bloco de comandos}
while(expressão);
Faz o comando, enquanto a expressão for verdadeira. Quando a
expressão for falsa, o programa segue para o seu caminho normal. A
grande diferença entre o do-while e o while é que no Laço do-while, o
programa executa pelo menos uma vez o comando do Laço.
3. for(inicialização; expressão; incremento)
comando ou {bloco de comando}
O comando for executa o laço enquanto a expressão for verdadeira, só
que pode ser controlada por um contador. Esta expressão permite que
o usuário inicialize e incremente o contador no controle do laço.
Manipulando Com Strings
Java é uma linguagem totalmente orientada a objetos. Então, todos os valores
utilizados são objetos descritos por classes. Os tipos primitivos de dados
permitem que possamos criar todos os tipos de objetos necessários para se
implementar qualquer sistema. Um dos objetos mais utilizados é o String
(com S maiúsculo porque, como vimos nas convenções, String é uma classe).
String é uma sequência de caracteres.
Ex.:
String um = “Curso”;
String dois = “Java”;
ATENÇÃO
Objetos da classe String não devem ser comparados usando os operadores
relacionais, porque são objetos. Existem métodos especiais para executar tais
funções. O objeto String em Java possui mais de 50 métodos diferentes.
Manipulando Com Vetores
Vetores são estruturas utilizadas para armazenar um conjunto de dados do
mesmo tipo. Esses podem ser de qualquer tipo, desde variáveis primitivas até
objetos complexos. A sua alocação na memória é sempre contínua.
int[] vetor= new int[l00]; // aloca uma área de memória contínua com 100
posições para armazenar 100 inteiros.
int[] pares = {0, 2, 4, 6, 8, 10};
Vetores podem ter várias dimensões.
Matrizes ou vetores bidimensionais.
São vetores bidimensionais. Muito usado na matemática.
int[][] matriz = new int[3][4];
Conversão Entre Tipos De Dados
Quando trabalhamos com expressões, o resultado de uma expressão pode ser
de um tipo diferente dos seus operandos. Ou ainda, temos dois tipos de
dados diferentes e queremos efetuar uma operação. Não é possível efetuar
comparações ou operações com tipos diferentes. Para resolver este
problema, podemos converter os tipos de dados.
Existem, basicamente, dois tipos de conversões de dados. A conversão
implícita e a explícita de dados.
Implícita
O primeiro caso ocorre sem a necessidade do programador
interferir. Os valores são convertidos automaticamente. Isso
ocorre na conversão de inteiro para real, de números para strings
ou com o uso de operadores unários.
Ex.:
double x;
int i = 20;
x = i; // x recebe um valor inteiro
System.out.print(“i= ” + x); /* O valor de x é convertido para string
e concatenado com a outra string para ser apresentada na tela */
Explícita
O segundo caso, o programador controla a conversão
informando
qual tipo será utilizado, através de um operador unário.
Ex.:
float eventos = 25.7;
float dias = 7.2;
x = (int) (eventos / dias); // O resultado é o inteiro 3, pois 25/3 é
3.57
Exercícios
1. Com o seu ambiente de programação Java, escreva o programa
abaixo no bloco de notas, salve em uma pasta de trabalho. No
prompt de comando, vá até a pasta de trabalho e compile
(utilizando o javac) seu programa.
Execute o programa (utiliza java <nome da classe>) e veja o
resultado.
Além disso, faça as alterações abaixo e veja o resultado:
Apresente o valor da variável d;
Apresente o conteúdo da variável c;
Apresente a soma inteira de i e d;
Apresente o conteúdo da variável b;
Apresente o texto “positivo" caso a variável b seja true e ‘falso" caso
contrário.
2. Execute o programa, veja o resultado apresentado e explique o por
quê do resultado apresentado no Fórum.
3. Faça um programa em Java para mostrar todos os números pares
existentes de 1 até 500.
O programa abaixo converte um inteiro em um byte. Qual o resultado
apresentado como saída? Marque a opção correta.
public class TesteConvByte{
public static void main(String args[]){
int l=300;
byte b;
b=(byte) l;
System.out.println("O valor de b é "+b);
}
}
44.
Aula 3: Introdução as interfaces gráficas
Introdução As Ides
IDE, do inglês Integrated Development Enviroment ou Ambiente Integrado de
Desenvolvimento, é um software que engloba características e ferramentas
para o desenvolvimento de programas.
As IDEs facilitam a técnica de RAD que tem como principal objetivo a maior
produtividade de seus desenvolvedores.
Existem várias IDEs disponíveis. Abaixo, a lista de algumas IDEs
RAD- Rapid Application Development – Desenvolvimento Rápido de
Aplicativos.
Conhecendo a IDE NetBeans
O NetBeans é uma IDE gratuita e de código aberto, totalmente escrito em
Java para desenvolvedores de software na linguagem Java, C/C++, PHP,
Groovy, Ruby e muito mais. Por ser escrito em Java, é multi-plataforma, ou
melhor, funciona em vários ambientes como Windows, Linux, Solaris e
MacOS. O NetBeans IDE oferece aos desenvolvedores ferramentas
necessárias para criar aplicativos profissionais de desktop, empresariais, Web
e móveis.
Com projeto iniciado em 1996 por dois estudantes tchecos, teve como
primeiro nome Xelfi, em alusão ao Delphi, porém foi totalmente desenvolvido
em Java.
Em 1999, o projeto já havia evoluído para uma IDE proprietário, com o nome
de NetBeans DeveloperX2, nome este que veio da ideia de reutilização de
componentes, que era a base do Java.
Nessa época, a empresa Sun Microsystems havia desistido de sua IDE Java
Workshop e, procurando por novas iniciativas, adquiriu o projeto NetBeans
DeveloperX2 ,incorporando-o a sua linha de softwares.
Por alguns meses, a Sun mudou o nome do projeto para Forte for Java e o
manteve por um bom tempo como software proprietário, porém, em junho
de 2000, a Sun disponibilizou o código fonte do IDE NetBeans tornando-o uma
plataforma OpenSource. Desde então, a comunidade de desenvolvedores que
utilizam e contribuem com o projeto não parou de crescer, tornando-se uma
das IDE´s mais populares atualmente.
O NetBeans é considerado a melhor IDE para desenvolvedores iniciantes,
pois, facilita o processo de programação, compilação e execução dos
programas. Este sistema cria um ambiente completo de teste. O único
problema é que para montar todo este ambiente, esta IDE exige uma
configuração de hardware um pouco melhor, principalmente a quantidade de
memória.
Existem várias opções de download. A partir desta aula, iremos utilizar o
NetBeans 6.9.1
Introdução A Concepção De Interfaces Gráficas
Muitos dos programas conhecidos interagem com os usuários através da
troca de informações. O meio pelo qual a parte humana solicita ao programa
a execução de tarefas, alguma resposta, ou qualquer comunicação entre as
partes é feito pela Interface. Muitas vezes confundida com o programa em si.
A interface gráfica com o usuário (GUI) fornece a um programa um conjunto
consistente de componentes intuitivos, familiarizando o usuário com as
diversas funções e diminuindo o tempo de aprendizado da nova ferramenta.
As GUIs são construídas a partir de componentes GUI, que são objetos com o
qual o usuário interage através dos dispositivos de entrada, ou seja, o mouse,
o teclado, a voz, etc.
Imagine que construir interfaces consiste em colar adesivos em uma tela de
vidro ou colocar componentes em um contêiner de componentes. Antes de
tudo, é necessário possuir uma tela, que será representada pelos contêineres.
Também dispor de adesivos de diversos tamanhos que podem ser distribuídos
e anexados livremente pela superfície do vidro. Tais adesivos elementares
serão os painéis. Além disso, dispor de adesivos mais elaborados que já estão
pré-definidos com figuras de botões, rótulos, etc. Estes podem ser colados
diretamente no vidro, ou sobre os outros adesivos rudimentares (painéis), tal
qual é a nossa vontade, embora se limitando à capacidade do espaço físico
disponível. Na imagem você pode ver alguns dos componentes que
estudaremos mais a frente.
Criação de Interfaces Gráficas
Em Java, as classes necessárias para criação de componentes gráficos, bem
como para fornecer-lhes funcionalidade, estão agrupadas em dois grandes
pacotes: java.awt (pacote do núcleo) e javax.swing (pacote de extensão). Os
dois pacotes definem componentes com peculiaridades distintas e que serão
discutidas a seguir.
Componente Swing
O pacote javax.swing foi criado em 1997 e inclui os componentes GUI que se
tornaram padrão em Java a partir da versão 1.2 da plataforma Java 2. A
maioria dos componentes Swing é escrita, manipulada e exibida
completamente em Java, estes são conhecidos como componentes Java
puros. Isso oferece a eles um maior nível de portabilidade e flexibilidade. Os
nomes de tais componentes recebem um “J”, como, por exemplo: JLabel,
JButton, JFrame, JPanel, etc. Tal peculiaridade se justifica para diferenciar
esses componentes dos que serão mencionados logo adiante. Os
componentes Swing fornecem funcionalidade e aparência uniforme em todas
as plataforma, sendo denominada de aparência de metal.
O Swing também fornece flexibilidade para personalizar a aparência e o
comportamento dos componentes de acordo com o modo particular de cada
plataforma, ou mesmo alterá-los enquanto o programa está sendo executado.
As opções são a personalização com o estilo do Microsoft Windows, do Apple
Macintosh ou do Motif (UNIX).
metal look-and-feel
Componentes Básicos
O esquema a seguir mostra a maioria das classes que compõem o Java Swing
e mostra também a relação entre as classes AWT (claro) e as classes Swing
(escuro):
Painéis
São áreas que comportam outros componentes, inclusive outros painéis. Em
outras palavras, são elementos que fazem a intermediação entre um
container e os demais GUI anexados. São criados com a classe JPanel, que é
derivada da classe Container. A classe JPanel não tem painel de conteúdo
como JFrames, assim, os elementos devem ser diretamente adicionados ao
objeto painel. Além de agregar um conjunto de componentes GUI para fins de
layout, pode-se criar áreas dedicadas de desenho e áreas que recebem
eventos do mouse.
Criando O Primeiro Formulário
Componentes Swing
import javax.swing.*;
public class Frm01
{
public void criaTela()
{
JFrame f= new JFrame();
f.setSize(290,100);
f.setTitle("Cadastro");
f.setLocation(10,10);
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
f.setVisible(true);
}
}
Componentes
Básicos
public class TestaFrm01 {
public static void main(String []args){
Frm01 tela = new Frm01();
tela.criaTela();
}
}
O método setDefaultCloseOperation()também pode ser executado
com outras constantes como argumento:
DISPOSE_ON_CLOSE - Destrói a janela
HIDE_ON_CLOSE - Apenas fecha a janela
DO_NOTHING_ON_CLOSE - Desabilita opção
EXIT_ON_CLOSE - Encerra a aplicação
Inserindo Componentes na Tela
import javax.swing.*;
public class Frm02
{
public void criaTela()
{
//criando o Frame
JFrame f= new JFrame();
f.setSize(300,100);
f.setTitle("Cadastro de Categorias");
f.setLocation(150,200);
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
//criando o Painel
JPanel pl = new JPanel();
pl.setLayout(null);// gerenciador de Layout
//Criando os componentes:
//Label
JLabel meuLabel = new JLabel("Código");
meuLabel.setBounds(10, 10, 60, 20);
// Campo de Texto
JTextField meuCampoTexto = new JTextField(" ");
meuCampoTexto.setBounds(80, 10, 60, 20);
// Botão
JButton meuBotao = new JButton("NomeBotão");
meuBotao.setBounds(150, 10, 100, 20);
//colando os componentes no Painel
pl.add(meuLabel);
pl.add(meuCampoTexto);
pl.add(meuBotao);
//colando o painel no frame
f.add(pl);
f.setVisible(true);
}
}
Saída do programa:
Contêineres, painéis e botões são componentes:
GUI
Aula 4: Princípios da Orientação a Objetos
Introdução Classes e Objetos
Todo sistema orientado a objetos pode ser definido como um conjunto de
objetos que trocam mensagens entre si. Então, quando programamos em
Java, que é uma linguagem de programação orientada a objetos, estamos
escrevendo ou definindo um conjunto de objetos que trocam mensagens.
Bom, mas o que é um Objeto? O que é uma classe? O que é mensagens?
As classes definem a estrutura e o comportamento de um tipo de objeto.
Observe a figura abaixo:
A classe Árvore define um arcabouço de qualquer tipo de árvore. Uma árvore
real será um objeto com estrutura a estrutura definida pela classe, mas os
valores de cada árvore serão únicas.
Classes
Um protótipo que define os atributos e os métodos comuns a todos os
objetos de um determinado tipo e da própria classe, com a finalidade de
servir de molde para a criação de objetos.
Objetos
São a representação de uma entidade do mundo real, que tem
identificador único, propriedades embutidas e a habilidade de interagir
com outros objetos e consigo mesmo. Um objeto é uma instância de uma
classe. A classe descreve todas as características e funcionalidades de um
objeto. Modelamos os objetos através das classes.
Abstração
Extrair tudo que for essencial e mais nada para o escopo do sistema;
E o processo de filtragem de detalhes sem importância do objeto real,
para que apenas as características apropriadas que o descrevam e que
tenham relevância para o sistema permaneçam;
Conceito aplicado a criação de software baseado em objetos, partindo
do principio que devemos considerar a essência de cada objeto e não
pensar em todos os detalhes de implementação.
Classes e Objetos em Java
Um programa Java é uma coleção de objetos que são descritos por um
conjunto de arquivos-texto, onde são definidas as classes. Pelo menos uma
destas classes é “public” e contém o método main(), que possui esta forma
específica:
public static void main(String [] args) {
// aqui o programador insere os comandos
}
Como vimos nas aulas anteriores todos os programas feitos tinham esta
estrutura. E o nome da classe era o nome do arquivo. Então, podemos
concluir que uma classe em Java é construída dentro de um arquivo texto
com o mesmo nome da classe e extensão .java.
javac Oi.java
java Oi
Nos comandos acima, o compilador Java compila o arquivo texto Oi.java,
gerando o bytecode. A máquina virtual interpreta a classe Oi, quando o
comando java Oi é executado.
Lembro que a classe que contém o método main() é chamada de classe
principal.
Encapsulamento
Mecanismo utilizado em orientação a objetos para obter segurança,
modularidade e autonomia dos objetos;
Implementamos através da definição de visibilidade privada dos
atributos;
Então, devemos sempre definir os atributos de uma classe como
privados;
Este mecanismo protege o acesso direto aos dados do objeto;
Permite acesso através dos métodos públicos;
É a disponibilização de uma interface pública, com granularidade controlada,
para manipular os estados e executar as operações de um objeto (* acesso
permitido).
Em outras palavras, os atributos e métodos de um objeto podem ser
escondidos de outros objetos por uma interface pública de métodos, de
modo a impedir acessos indevidos.
Para definir diferentes níveis de encapsulamento, faz-se uso do conjunto de
modificadores de acesso disponíveis no Java para os membros de classe, com
mostrado na tabela.
Definindo uma Classe em Java
Construindo uma classe:
[modif] class NomeDaClasse {
// corpo da classe...
}
A primeira linha é um comando que inicia a declaração da classe. Após a
palavra-chave class, segue-se o nome da classe, que deve ser um identificador
válido para a linguagem. O modificador modif é opcional; se presente, pode
ser uma combinação de public e abstract ou final. A definição da classe,
propriamente dita, está entre as chaves { e } que delimitam blocos na
linguagem Java. Este corpo da classe, usualmente obedece à seguinte
sequência de definição:
As variáveis de classe (definidas como static), ordenadas segundo sua
visibilidade: iniciando pelas public, seguidos pelas protected, pelas com
visibilidade padrão (sem modificador) e finalmente pelas private.
Os atributos (ou variáveis de instância) dos objetos dessa classe,
seguindo a mesma ordenação segundo a visibilidade definida para as
variáveis de classe.
Os construtores de objetos dessa classe.
Os métodos da classe, geralmente agrupados por funcionalidade.
Criando Objetos em Java
Toda classe possui atributos e métodos. Em especial, toda classe tem um
construtor, que é um método responsável pela instanciação do objeto. Este
processo faz com que o objeto seja criado com as características desejadas.
Para que um objeto exista em memória, ele precisa ter memória alocada, um
endereço definido. O construtor é o responsável por isso.
A criação de um objeto se dá através da aplicação do operador new.
ClasseNome objeto = new ClasseNome();
O método a direita do operador new é o construtor da classe ClasseNome.
Podemos instanciar quantos objetos forem necessários. Contanto que
guardemos a referência para o objeto em questão. A referência é como
poderemos acessar aquele objeto.
Caso um objeto não tenha mais nenhuma referência para ele, o coletor de
lixo (garbage collector - GC) elimina o objeto, liberando a memória.
Atributos
Eles representam as características de um objeto. Devem ser privados, para
manter o encapsulamento. A definição de atributos de uma classe Java reflete
de forma quase direta a informação que estaria contida na representação da
classe em um diagrama UML. Para tanto, a sintaxe utilizada para definir um
atributo de um objeto é:
[modificador] tipo nome [ = default];
Onde:
Modificador é opcional, especificando a visibilidade diferente da padrão
(public, protected ou private);
Tipo deve ser um dos tipos primitivos da Linguagem Java ou o nome de
uma classe;
Nome deve ser um identificador válido da linguagem Java;
Valor default é
opcional; se presente, especifica um valor inicial para a
variável.
Métodos
Os métodos representam as funcionalidades que os objetos podem
desempenhar. São essencialmente procedimentos que podem manipular
atributos de objetos para os quais o método foi definido. Além dos atributos
de objetos, métodos podem definir e manipular variáveis locais; também
podem receber parâmetros por valor através da lista de argumentos. A forma
genérica para a definição de um método em uma classe é:
[modificador] tipo nome(argumentos) {
corpo do método
}
Onde:
O modificador (opcional) é uma combinação de: public, protected ou
private; abstract ou final; e static;
O tipo é um indicador do valor de retorno, sendo void, se o método não
tiver um valor de retorno;
O nome do método deve ser um identificado válido na Linguagem java;
Os argumentos são representados por uma Lista de parâmetros
separados por vírgulas onde, para cada parâmetro, é indicado primeiro
o tipo e depois (separado por espaço) o nome.
Uma boa prática de programação é manter a funcionalidade de um método
simples, desempenhando uma única tarefa. O nome do método deve refletir
de modo adequado a tarefa realizada. Se a funcionalidade do método for
simples, será fácil encontrar um nome adequado para o método.
Como ocorre para a definição de atributos, a definição de métodos reflete de
forma quase direta a informação que estaria presente em um diagrama de
classes UML, a não ser por uma diferença vital: o corpo do método.
Métodos de mesmo nome podem coexistir em uma mesma classe desde que
a lista de argumentos seja distinta, usando o mecanismo de sobrecarga.
Um atributo encapsulado deve ter o seguinte modificador:
Private.
Em Orientação a Objetos, um objeto é:
Uma instância de uma classe.
Aula 5: Herança
Herança
Significa a capacidade de incorporar as características e as funcionalidades de
uma classe. Assim como a herança de todas as operações e dados, você pode
especializar métodos da superclasse e especificar novas operações e dados,
para refinar, especializar, substituir ou estender a funcionalidade da classe
progenitora.
Uma classe define um conjunto de dados - Atributos - e um conjunto de
métodos.
Todos os objetos de uma classe mantêm o mesmo conjunto de atributos
e métodos.
Através do mecanismo de herança, tendo definido uma classe base é
possível criar classes derivadas que:
Herdam os atributos e métodos da classe base,
Definem novos atributos e métodos,
Podem redefinir os métodos herdados.
Ao lado, podemos ver que a classe “Meios de Transportes” é uma classe
genérica. Já as classes Terrestres, representam as características dos Meios de
Transportes mais as peculiaridades dos veículos terrestres. Os meios Aéreos,
também são meios de transportes, mas suas peculiaridades são diferentes
dos outros tipos de meios de transportes, assim como os Marítimos.
Terminologias
Estender
Criar urna nova classe que herda todo o conteúdo da classe existente.
Superclasse
Uma classe progenitora ou base.
Subclasse
Uma classe filha que herda ou estende uma superclasse.
Classe Abstrata
Uma classe abstrata em Java define atributos e métodos.
Numa classe abstrata, um método pode ser definido com o modificador
“abstract”. Nesse caso:
A classe abstrata não implementa os método abstratos.
As classes derivadas devem implementar os métodos abstratos.
Uma classe abstrata é utilizada quando deseja-se fornecer uma interface
comum a diversos membros de uma hierarquia de classes. Os métodos
declarados na classe abstrata serão implementados em suas subclasses,
através de polimorfismo.
Imagine uma classe que no seu sistema, a uma funcionalidade existente em
todas as subclasses quer ser apresentada na superclasse. Este método é
definido na superclasse como Abstract. Nas subclasses, estes métodos serão
implementados, cada um com a sua peculiaridade.
Notas importantes sobre Métodos e Classes Abstratas
1. Como visto anteriormente, subclasses podem redefinir (sobrepor) um
método de sua superclasse.
2. Para Indicar que um método de uma classe deve necessariamente ser
redefinido em cada uma de suas subclasses, devemos usar o
modificador abstract.
3. Uma classe, que contém um ou mais métodos abstratos, deve ser
declarada explicitamente como abstrata. Essa classe, no entanto, pode
ter construtores e métodos concretos (não abstratos).
4. Se uma classe é declarada como abstract, não podem ser criados
objetos desta classe.
5. Se uma subclasse é derivada de uma superclasse que contém um
método abstrato e se esse método abstrato não for redefinido na
subclasse, esse método permanece abstract na subclasse. Com isso, a
subclasse deverá ser declarada explicitamente como abstract.
6. Declarar um método como abstrato é uma forma de obrigar o
programador a redefinir esse método em todas as subclasses para as
quais se deseja criar objetos.
7. Como um método abstrato deve ser redefinido nas subclasses, na
superclasse ele não precisa ter implementação alguma.
Vamos imaginar a seguinte hierarquia de classes:
onde Chefe, PorComissao, PorItem e PorHora são classes finais.
Todas essas subclasses vão precisar redefinir o método ganha(). Como se
tratam de tipos diferentes de empregado, cada um ganha de uma forma:
Chefe: salário fixo e predefinido
PorComissao: valor fixo + comissão * vendas
PorItem: valor por produção * quantidade produzida
PorHora: valor por hora * total de horas trabalhada
Declarando o método como abstrato na superclasse, garante-se que nas 4
subclasses haverá a implementação do método ganha() para cada tipo de
empregado (do contrário, objetos destas classes não poderão ser criados).
Para testar esta implementação, precisamos de uma classe para que tenha o
main().
Polimorfismo
É a capacidade que os métodos de mesmo nome têm de efetuarem tarefas
diferentes.
O mesmo método com várias formas.
Acontece de duas maneiras em Java: quando os métodos são definidos em
função da classe que os utiliza (sobreposição), ou dos diferentes conjuntos de
argumentos definidos para cada método (sobrecarga).
Uso do “this”
Chamada para outro construtor da mesma classe. É um excelente artifício
para combinar código dos construtores.
Exemplo
public class Cliente ()
{
private String nome; //campo de instância
private int numConta; //campo de instancia
public Cliente(String n, int c) //Construtor da Classe Cliente
{
nome = n;
numConta = c;
}
}
Definindo vários construtores para a Classe Cliente:
public class Cliente ()
{
private String nome; //campo de instância
private int numConta; //campo de instância
public Cliente(String n) //Construtor 1 da Classe Cliente
{
this(n, 0) //Chama o Construtor 2 da própria classe
}
public Cliente(String n, int c) //Construtor 2 da Classe Cliente
{
nome = n;
numConta = c;
}
public int getNumConta ()
{
return numConta;
}
public void setNumConta (int numero)
{
numConta = numero;
}
}
Uso do “super”
O comando super sempre se refere a uma superclasse. Todo método
construtor de uma subclasse precisa também chamar um construtor para os
campos de dados da superclasse, caso existam campos de instância também
na superclasse.
Se a superclasse tiver um construtor, então as subclasses precisam usar super
para passar os parâmetros, a fim de utilizar este construtor da superclasse.
Exemplo (com a classe cliente)
public class ClienteOuro extends Cliente
{
private double limiteChequeEspecial; //Atributo da Classe
public ClienteOuro (String
n, int c, double limite)
{
super(n, c ); //precisa ser o primeiro comando do
método
limiteChequeEspecial = limite;
}
}
A superclasse pode ser entendida como:
Uma Classe progenitora ou base.
Podemos entender como Herança:
Capacidade de incorporar os dados e métodos de uma classe previamente
definida.
Aula 6: Encapsulamento e Associações de Classes
Encapsulamento
Mecanismo utilizado na Programação Orientada a Objetos, que visa obter
segurança, modularidade e autonomia para os objetos;
Conseguido, através da definição de visibilidade privada dos atributos,
ganhando-se, assim, autonomia, para definir o que o mundo externo a classe
poderá visualizar e acessar, normalmente através de métodos públicos.
Conclusão:
Sempre defina os atributos de uma classe como privados, a não ser que tenha
uma boa justificativa para isso.
O Encapsulamento protege os atributos de acesso direto e permite apenas
acesso através de métodos públicos.
Modificadores de Visibilidade
Um modificador de acesso determina como será a visibilidade de uma classe,
método ou atributo a partir de outras classes.
Modificadores de Acesso
Abstract
Um método abstrato não implementa nenhuma funcionalidade,
somente assina o método e faz com que a primeira subclasse concreta
seja obrigada a implementar. Uma classe que possui um método
abstrato deve ser obrigatoriamente abstrata, como vimos na aula
passada.
Final
Pode ser aplicado em classes, métodos e atributos. Indica que esta é a
última atribuição ou definição da estrutura. Não será permitida uma
nova reescrita. Para uma classe, não há herança em classes final. Um
método não pode ser sobrescrito; e um atributo é considerado uma
constante.
Sem Encapsulamento
class NaoEncapsulado {
//implicitamentamente há modificador de acesso, mas não é o mais restritivo
int semProteção;
}
public class TesteNaoEncapsulado {
public static void main(String[] args) {
NãoEncapsulado ne = new NãoEncapsulado();
//ne é uma instância de NãoEncapsulado
ne.semProtecao = 10; //acesso direto ao atributo
System.out.println("Valor sem proteção: " + ne.semProteção);
//acesso direto aos atributos
}
}
Com Encapsulamento
class Encapsulado {
//private é um modificador de acesso de restrição máxima
private int comProteção;
public void setComProteção(int comProteção) {
this.comProteção= comProteção;
}
public int getComProteção () {
return this.comProteção;
}
}
public class TesteEncapsulado {
public static void main(String[] args) {
Encapsulado e = new Encapsulado();
// O Objeto "e" é uma instância de Encapsulado
e.comProteção = 10;
//deve-se acessar o atributos de forma indireta, encapsulada
e.setComProteção (10);
System.out.println("Valor com proteção: " + e.getComProteção ());
}
}
Métodos Get’s e Set’s
Como vimos, é preciso criar um mecanismo para acessar os campos private de
uma classe. Para isso, é comum fornecer métodos públicos para acessar as
informações encapsuladas. Estes métodos são chamados de set e get. O
método set atribui valores ao atributo, enquanto que o método get obtém
seus valores.
A composição do nome destes métodos é sempre com o nome set + <nome
atributo> ou get + <nome atributo>.
Abaixo vemos um exemplo de atributo que não permite alteração, logo seus
atributos são privados e só foi disponibilizado os métodos get’s.
Exercício
1. A partir da classe Automovel.java apresentada abaixo, encapsule
seus métodos e crie mecanismos públicos para acessar estas
características.
2. Crie mais um atributo na classe do tipo boolean – estadoMotor
3. Crie métodos ligarMotor() e desligarMotor(), atualizando o valor
de estadoMotor.
Automóvel.java
public class Automóvel {
String modelo, cor;
int ano;
}
Associação de Classes
É um vínculo que permite que objetos de uma ou mais classes se relacionem.
Através destes vínculos, é possível que um objeto troque mensagens ou
chame os métodos de outros objetos.
Na UML, quando estamos modelando o diagrama de classes, temos a
Associação, a Composição e a Agregação, como tipos de Associações.
As Associações têm acoplamento fraco.
As Composições têm acoplamento forte.
A Agregação faz parte de.
Na implementação, não há diferença entre as abordagens, o que as distingue
são os controles adicionados pelo desenvolvedor.
Unified Modeling Language – Linguagem de modelagem unificada.
public class Avião {
Motor motor = new Motor(); // composição - O Avião é composto
de Motor
public void adiciona(Passageiro p){ // isto é agregação
p.embarque(this);
}
public void remove(Passageiro p){
p.desembarque(this)
}
// isto é uma associação
public void setControladorVoo (ControladorVoo controlador);
public ControladorVoo getControladorVoo ();
}
public class Passageiro {
Avião Avião
public void embarque(Avião Avião){
if (this. Avião ==null){
throw new IllegalStateException("O
passageiro já embarcou. Remova-o
antes de o incluir em outro");
}
this. Avião = Avião
}
public void desembarque(Avião Avião){
if (aviao.equals(this.aviao)){
this.aviao = null;
}
}
}
Em resumo, a associação representada pela ligação de duas classes no
modelo, inclui um novo atributo na classe. A navegabilidade indica que classe
enxerga a outra.
Composição
Tipo de associação onde uma nova classe usa classes existentes como
atributos;
Relacionamento “tem um”.
Ex.:
Uma conta tem um dono (cliente),
Um cliente tem um nome (string);
class Aleatorio {
int numero;
Aleatorio(int max) {
numero = new Random().nextInt(max);
}
}
public class NumeroAleatorio {
private String nome;
private Aleatorio valor;
NumeroAleatorio(String nome, int valor) {
this.nome = nome;
this.valor = new Aleatorio(valor);
}
public static void main(String[] args) {
NumeroAleatorio n;
n = new NumeroAleatorio("Número secreto", 50);
}
}
Podemos ter as seguintes multiplicidades de associações:
1 para 1
1 para *
* para *
Onde * equivale a muitos.
Exercício de Fixação
Faça um programa em Java, para adivinhar um número entre 1 e 100. O
programa deverá sortear um número aleatório entre 1 e 100 e armazenar em
na classe Jogo. Construa uma classe Jogar que instancia o objeto jogo do tipo
Jogo. Este objeto jogar fará a interface entre o usuário e o objeto jogo. Toda
vez que o jogador envia um número para ser avaliado, o jogo avalia se:
A- o jogador acertou – é enviada uma mensagem de congratulações e é
informado o número de tentativas gastas.
B- o número informado é maior que o sorteado – o sistema envia mensagem
para o usuário que o número é maior, incrementa o número de tentativas e
solicita um novo número.
C- o número informado é menor que o sorteado – o sistema envia mensagem
para o usuário que o número é menor, incrementa o número de tentativas e
solicita um novo número.
O jogo termina quando o jogador acerta. Neste momento o sistema irá
perguntar se deseja jogar novamente.
Os métodos Get’s e Set’s são fundamentais para:
Prover acesso aos dados encapsulados.
Aula 7: Interfaces e
Polimorfismo
As interfaces gráficas em Java
O Java fornece uma infinidade de funcionalidades para prover comunicação
humano-computado, ou melhor, para desenvolver interfaces. São fornecidas
duas bibliotecas para desenvolver um GUI. Elas são:
java.awt : Abstract Window Toolkit (classes básicas);
javax.swing : Swing Componets – Fornece um conjunto de componentes
alternativos, mais funcionais que os conjuntos fornecidos pela java.awt.
Essas bibliotecas são fornecidas pelo JFC (Java Foundation Classes).
Na imagem podemos ver a hierarquia das classes das bibliotecas gráficas.
Componentes atômicos
São elementos ou componentes que não permitem conter outros elementos.
Podemos citar, dentre outros, botões, labels, textFields, sliders, check boxes,
scrollbars, etc.
JLabel
São rótulos estáticos que, geralmente, apresentam funcionalidades de outros
componentes GUI, como por exemplo, campos de texto, ícones etc. Também,
serve para apresentar um pequeno texto. As instruções são mostradas por
meio de uma linha de texto: somente leitura, uma imagem ou ambas. O
construtor mais elaborado é JLabel (String, Icon, int). Os argumentos
representam o rótulo a ser exibido, um ícone e o alinhamento,
respectivamente. Também, é possível a exibição de ícones em muito dos
componentes Swing. Para JLabels, basta especificar um arquivo com extensão
png, gif ou jpg no segundo argumento do construtor do JLabel, ou utilizar o
método setIcon(Icon), o arquivo da imagem algumNome.xxx deve encontrar-
se no mesmo diretório do programa, ou especifica-se corretamente a
estrutura de diretórios até ele.
As constantes SwingConstants, que definem o posicionamento de vários
componentes GUI e aqui, são apropriadas ao terceiro argumento,
determinam a locação do ícone em relação ao texto. São elas:
SwingConstants.NORTH,
SwingConstants.SOUTH,
SwingConstants.EAST,
SwingConstants.WEST,
SwingConstants.TOP,
SwingConstants.BOTTOM,
SwingConstants.CENTER,
SwingConstants.HORIZONTAL,
SwingConstants.VERTICAL,
SwingConstants.LEADING,
SwingConstants.TRAILING,
SwingConstants.NORTH EAST,
SwingConstants.NORTH WEST,
SwingConstants.SOUTH WEST,
SwingConstants.SOUTH EAST,
SwingConstants.RIGHT,
SwingConstants.LEFT
Exercício:
Utilizando o NetBeans, crie um projeto como um novo aplicativo Java. Dentro
desse aplicativo, crie um novo formulário JFrame. Dê o nome de
Aula7Swing.java.
Coloque um JLabel no frame e coloque o nome desejado que apareça.
Execute o arquivo para ver o resultado.
Botão
É um componente que tem o comportamento semelhante ao de um botão
real, quer dizer, ao clicarmos ou apertarmos o botão, uma ação é executada.
Um programa Java pode utilizar vários tipos de botões, incluindo botões de
comando, caixas de marcação, botões de alternância e botões de opção. Para
se criar algum desses tipos de botões, deve-se instanciar uma das muitas
classes que descendem da classe AbstractButton, a qual define muito dos
recursos que são comuns aos botões do Swing. Esse comportamento
semelhante ao mundo real ajuda aos usuários na compreensão da interface.
Jbutton
É um dos componentes mais familiares e intuitivos ao usuário. Os botões de
comando são criados com a classe JButton e seu pressionamento,
geralmente, dispara a ação especificada em seu rótulo, que também suporta
a exibição de pequenas imagens. Ao pressionar o botão, é gerado um evento
ActionEvent que, juntamente com outros eventos, executam algum comando
desejado. Estudaremos a fundo este comportamento na próxima aula aula 8).
JCheckbox
A classe JCheckBox dá suporte à criação de botões com caixa de marcação,
sendo que qualquer número de itens pode se selecionado. Quando um item é
selecionado, um ItemEvent é gerado. O mesmo pode ser tratado por um
objeto que implemente a interface ItemListener. A classe que fornece as
funcionalidades para este objeto deve definir o método itemStateChanged,
mas isto será visto na próxima aula (aula 8).
JRadioButton
Os botões de opção, que são definidos na classe JRadioButton, assemelham-
se às caixas de marcação no que concerne aos seus estados (selecionado ou
não selecionado). Entretanto, costumeiramente são usados em grupo no qual
apenas um botão de opção pode ser marcado, forçando os demais botões ao
estado não-selecionado.
JTextField
Compreende a área de uma única Linha que suporta a inserção ou exibição de
texto. Pode-se definir se o texto pode ser manipulado com o método
setEditable(boolean), utilizando rio argumento o valor true. Quando o usuário
digita os dados em uma JTexField e pressiona Enter, ocorre um evento de
ação. Esse evento é processado pelo ouvinte de evento registrado que pode
usar os dados que estão no JTexField rio momento em que o evento ocorre.
Esses procedimentos serão mais bem abordados na aula 8.
JPasswordField
É uma subclasse de JTextField e acrescenta vários métodos específicos para o
processamento de senhas. Sua aparência e comportamento quase nada
diferem de uma JTextField, a não ser quando o texto é digitado, pois, o
mesmo fica ocultado petos asteriscos. Tal procedimento se justifica para
ocultar os caracteres inseridos, dado que esse campo contém uma senha.
JTextArea
É uma área dimensionável que permite que múltiplas Linhas de texto sejam
editadas com a mesma fonte. Essa classe é herdada de JTextComponent, que
define métodos comuns para JTextField, iTextArea e outros elementos GUI
baseados em texto.
As JTextAreas não têm eventos de ação como os objetos da classe JTextField,
cujo pressionamento de Enter gera um evento. Então, utiliza-se um outro
componente GUI (geralmente um botão) para gerar um evento externo que
sinaliza quando o texto de uma JTextArea deve ser processado. Pode-se
configurar um texto com setText (String) ou acrescentar texto com o método
append (String). Para evitar que um longo texto digitado fique incluso em
somente uma linha, usa-se o método setLineWrap (boolean), que define a
quebra da Linha quando o texto alcançar a borda da JTextArea. Porém, as
palavras podem ficar “quebradas”, com caracteres em uma linha e outros na
próxima, sem nenhum compromisso com as normas gramaticais. Uma
maneira de sanar paliativamente esse problema é invocar o método
setWrapStyleWord (boolean), o qual determina que a mudança de Linha seja
definida pelas palavras.
JScrolIPane
Objetos dessa classe fornecem a capacidade de rolagem a componentes da
classe JComponent, quando estes necessitam de mais espaço para exibir
dados. JscrollPane (Component, int, int) é o construtor mais elaborado e
recebe um componente (JTextArea por exemplo) como primeiro argumento,
definindo qual será o cliente do JScrollPane, ou seja, para que membro será
fornecido as barras de rolagem. Os dois próximos argumentos definem o
comportamento da barra vertical e da horizontal, respectivamente. Para isso,
pode-se fazer uso das constantes definidas na interface ScrollPaneConstants,
que é implementada por JScrollPane.
Veja elas:
JScrollPane.VERTICAL SCROLLBAR AS NEEDED
JScrollPane.HORIZONTAL SCROLLBAR AS NEEDED Indicam que as
barras de rolagem devem aparecer somente
quando necessário.
JScrollPane.VERTICAL SCROLLBAR ALWAYS
JScrollPane.HORIZONTAL SCROLLBAR ALWAYS Indicam que as
barras de rolagem devem aparecer sempre.
JScrollPane.VERTICAL SCROLLBAR NEVER
JScrollPane.HORIZONTAL SCROLLBAR NEVER Indicam que as barras
de rolagem nunca devem aparecer.
É possível configurar o comportamento do JScrollPane para um objeto com os
métodos set VerticalScrollBarPolicy(int) e setHorizontalScroltBarpolicy(int),
valendo-se das mesmas constantes como argumentos.
JSlider
É um marcador que desliza entre um intervalo de valores inteiros, podendo
selecionar qualquer valor de marca de
medida em que o marcador repouse.
Uma das inúmeras utilidades desse controle deslizante é restringir os valores
de entrada em um aplicativo, evitando que o usuário informe valores que
causem erros. Os JSlider comportam a exibição de marcas de medidas
principais, secundárias e rótulos de medida. A aderência às marcas (snap to
ticks) possibilita ao marcador aderir à marca mais próxima, quando este
situar-se entre dois valores. Esse componente responde as interações feitas
pelo mouse e pelo teclado (setas, PgDn, Pgup, Home e End). Sua orientação
pode ser horizontal, na qual o valor mínimo está situado na extrema
esquerda, ou vertical, na qual o valor mínimo está situado na extremidade
inferior. As posições de valor mínimo e máximo podem ser invertidas,
valendo-se do método setlnvert(boolean), com um argumento true.
JComboBox
Assemelha-se a um botão, porém, quando clicado, abre uma Lista de
possíveis valores ou opções. Mais precisamente é uma caixa de combinação
que permite ao usuário fazer uma seleção a partir de uma Lista de itens.
Atende-se para que a Lista da caixa de combinação, quando aberta, não
ultrapasse os Limites da janela da aplicação. Também é possível digitar nas
Linhas de uma caixa de combinação. Elas são implementadas com a classe
JComboBox, herdada de JComponent. Tais caixas de combinação geram Item
Events, assim como as JCheckBoxes.
Menus
Os menus talvez seja os componentes que mais aparecem nas ferramentas
computacionais. Geralmente, eles são encontrados no topo da janela da
aplicação, de onde dão suporte à organização e agrupamento de funções
afins em um mesmo contexto visual, o que facilita muito a localização e
entendimento por parte do usuário, já que a estrutura de cada menu está
delineada pelas características dos itens.
Os menus que são instanciados a partir da classe JMenu são anexados a uma
barra de menus com o método add(JMenu) de JMenuBar, sendo que
instâncias dessa instâncias dessa última classe comportam-se como
containers para menus.
A classe JMenuBar fornece os métodos necessários ao gerenciamento da
barra onde os menus são anexados.
A ordenação dos mesmos depende da ordem em que foram adicionados
sendo que são "empilhados” horizontalmente da esquerda para a direita.
Evidentemente, só pode-se anexar menus a janelas da classe JApplet, JDialog,
JFrame e JlntemaIFrame e faz-se isso, usando-se o método
setJMenuBar(JMenuBa). A classe JMenultem capacita a criação de itens de
menu que, por sua vez, devem ser anexados a um menu. Pode-se usar um
item de menu para executar alguma ação ou para gerir o acionamento de um
submenu, o qual fornece mais itens que estão relacionados por alguma
característica comum.
Passo a passo para montagem de um menu em barras em Java:
1. Instancie um JMenuBar. Ele é o responsável pela estrutura do menu.
2. Adicione tantos JMenu’s quantos forem necessários para as opções.
a. Dentro de cada JMenu, coloque o JMenuItem, que é o responsável pela
opção a ser escolhida.
Trecho do código para montar a barra de menus apresentada, na figura
acima:
jMenuBar1.setName("jMenuBar1"); // NOI18N
jMenu1.setText("Arquivo")); // Aba Arquivo da barra de opções
jMenu1.setName("jMenu1"); // NOI18N
jMenuItem1.setText("Abrir")); // Opção Abrir do menu
jMenuItem1.setName("jMenuItem1"); // NOI18N
jMenu1.add(jMenuItem1);
jMenuItem2.setText("Editar")); // Opção Editar do menu
jMenuItem2.setName("jMenuItem2"); // NOI18N
jMenu1.add(jMenuItem2);
jMenuItem3.setText("Salvar")); // Opção Ajuda do menu
jMenuItem3.setName("jMenuItem3"); // NOI18N
jMenu1.add(jMenuItem3);
jMenuBar1.add(jMenu1); //Inclui o menu Arquivoo na barra de menus
jMenu2.setText("Ajuda")); // Aba Ajuda da barra de opções
jMenu2.setName("jMenu2"); // NOI18N
jMenuItem4.setText("Ajuda")); // Opção Ajuda do menu
jMenuItem4.setName("jMenuItem4"); // NOI18N
jMenu2.add(jMenuItem4);
jMenuItem6.setText("Pesquisa")); // Opção Pesquisa do menu
jMenuItem6.setName("jMenuItem6"); // NOI18N
jMenu2.add(jMenuItem6);
jMenuItem5.setText("Sobre")); // Opção Sobre do menu
jMenuItem5.setName("jMenuItem5"); // NOI18N
jMenu2.add(jMenuItem5);
jMenuBar1.add(jMenu2); //Inclui o menu Ajuda na barra de menus
jMenu3.setText("Sair")); // Aba Sair da barra de opções
jMenu3.setName("jMenu3"); // NOI18N
jMenu3.add(jMenuItem7);
jMenuBar1.add(jMenu3); //Inclui o menu Sair na barra de menus
Criando telas Polimórficas
Para aplicar os conceitos de classe abstrata, criação de telas, herança e
polimorfismo, iremos fazer uma classe genérica de cadastro que possa ser
utilizada para várias classes de negócio.
Para este sistema funcionar, precisamos construir uma tela de cadastro com
uma barra de menus. Esta tela se liga a TelaCad.
Dependendo da opção escolhida no menu, a tela de cadastro terá o
comportamento de cadastro de Clube ou cadastro de Sócio.
Isso é uma aplicação de polimorfismo.
As telas acima são herdadas de telaCad. Mas, cada uma contém um painel
que determina as peculiaridades de cada cadastro.
Todas as funcionalidades comuns são descritas em TelaCad, enquanto que as
necessidades particulares são reescritas.
Quantas bibliotecas de GUI existem em Java:
Duas: AWT e Swing.
O Componente JLabel serve para:
Apresentar uma etiqueta com um texto.
O JCheckBox é um componente que serve para:
Entrada de dados com múltiplas alternativas;
Aula 8: Listeners e Adapters
Eventos
Evento é um acontecimento relevante no meio externo ao sistema relevante.
Pode ser considerado como o resultado da interação do usuário com algum
componente GUI. Mover o mouse, clicá-lo, digitar num campo de texto,
selecionar um item de menu, fechar uma janela, clicar num botão etc. são
interações que enviam eventos para o programa, normalmente realizando
serviços.
Eventos também podem ser gerados em resposta a modificações do
ambiente. Em outras palavras, definem-se eventos GUI como mensagens
(chamadas a métodos) que indicam que o usuário do programa interagiu com
um dos componentes GUI.
Um sistema orientado a objetos é definido como um conjunto de objetos
interagindo ou trocando mensagens. Os eventos representam as ações dos
atores nesse processo ou alguma resposta a uma mudança de estado.
Tratamento de Eventos
Quase todos os componentes propagam eventos. Esses eventos devem ser
tratados em algum ponto do código da aplicação. Os eventos nunca são
tratados no próprio componente (dado que não se tem acesso ao código do
componente). Para ligar o código do tratamento de eventos ao componentes
existem, no Java, um conjunto de interfaces chamadas listeners. Um listener é
uma interface que especifica os métodos que uma aplicação deve ter para ser
notificada da ocorrência de um determinado evento. Os componentes que
geram eventos permitem que sejam adicionados ou removidos listeners em
qualquer altura.
O modelo de eventos do Java funciona da seguinte forma:
O componente que produz eventos possui métodos especiais do tipo
addXXListener(XXListener) que permite adicionar ou remover listeners. XX
representa o nome do evento. O método addXXListener recebe, por
parâmetro, o objeto que implementa a interface XXListener.
A implementação do método addXXListener no componente apenas adiciona
o objeto, passado por parâmetro a uma lista interna. Sempre que ocorrer um
evento (exp.: botão pressionado), o componente percorre a lista e invoca,
para cada elemento, o método definido na interface XXListener.
No exemplo seguinte é construída uma GUI simples com um botão e uma
caixa de texto. Sempre que o botão é pressionado a aplicação deve escrever
na caixa de texto um número inteiro aleatório. Para processar os eventos, é
necessário analisar
os eventos que o botão produz. É preciso saber que,
sempre que um botão é pressionado, é criado um evento do tipo ActionEvent.
Para adicionar listeners, a classe que representa o botão (JButton) possui um
método chamado addActionListener, que recebe por parâmetro um objeto
que implemente a interface ActionListener. Na API, vê-se que a interface
ActionListener especifica um método chamado actionPerformed.
Resumindo:
Action Event Evento gerado pelo botão, quando pressionado. Sempre que o
botão for pressionado, este irá percorrer a sua Lista interna de listeners,
chamando para cada um o método actionPerformed.
Action listener Interface que especifica os objetos que tratam eventos do tipo
ActionEvent. Existem várias soluções possíveis para tratar o evento:
Recorrendo à própria classe (GUI) A aplicação gráfica tem de
implementar os Listeners necessários.
Recorrendo a classes Locais É criada uma classe Local que
implementa os listeners necessários.
Recorrendo a classes internas É criada uma classe dentro da GUI. A
classe interna implementa os listeners necessários.
Recorrendo a classes anônimas Criam-se classes anônimas que
implementem os listeners dos eventos a tratar. As classes
anônimas são classes internas especiais.
Diálogos Pré-definidos
O Swing oferece um conjunto de diálogos simples, pré-definidos, para uso em
interações breves com o usuário:
Mensagens de erro, de alerta.
Obtenção de uma confirmação.
Entrada de um único campo de texto.
Classe JOptionPane
Estrutura básica:
MessageDialog
Exibe uma mensagem e aguarda OK do usuário:
Exemplo de MessageDialog:
import java.awt.Component;
import javax.swing.*;
package exemplos;
/**
*
* @author Prof. Eduardo Pareto
*/
public class Janela {
private static Component janela;
public static void main(String[] args){
JOptionPane.showMessageDialog(
janela, "Cuidado com as Provas!","Linguagem de
Programação",JOptionPane.WARNING_MESSAGE);
}
}
ConfirmDialog
Exibe uma mensagem e obtém uma confirmação (YES/NO, OK/CANCEL)
Conjuntos de botões de opção(optionType):
JOptionPane.DEFAULT_OPTION
JOptionPane.YES_NO_OPTION
JOptionPane.YES_NO_CANCEL_OPTION
JOptionPane.OK_CANCEL_OPTION
Exemplo de ConfirmDialog:
import java.awt.Component;
import javax.swing.*;
package exemplos;
/**
*
* @author Prof. Eduardo Pareto
*/
public class Janela {
private static Component janela;
public static void main(String[] args){
int resp = JOptionPane.showConfirmDialog(janela,
"Você já estudou para as provas?", "Escolha uma
opção",JOptionPane.OK_CANCEL_OPTION);
}
}
InputDialog
Exibe uma mensagem e obtém um valor de entrada do usuário:
Campo texto editável
Combo box
Exemplo de InputDialog:
import java.awt.Component;
import javax.swing.*;
package exemplos;
/**
*
* @author Prof. Eduardo Pareto
*/
public class Janela {
private static Component janela;
public static void main(String[] args){
String nome = JOptionPane.showInputDialog(janela,
"Qual é o seu número de Matrícula",
"Linguagem de Programação",JOptionPane.QUESTION_MESSAGE);
}
}
Aula 9: Tratamento de Exceção
Exceção
Uma exceção é uma ocorrência que altera o fluxo normal da execução de um
programa. Esta ocorrência deve ser tratada para evitar que o programa
encerre seu funcionamento.
Existem diversos tipos de exceção. Erro na entrada de dados, erro na conexão
com o banco de dados, erro na leitura de arquivos, erro de uma operação
matemática. Sempre que o computador executa um código que gera uma
exceção, ou o Sistema Operacional irá terminar seu programa ou o seu
programa deverá fazer o tratamento para esta exceção.
Um método pode detectar uma falha, mas não estar apto a resolver sua
causa, devendo repassar essa função a quem saiba. Se o tratamento de falhas
for introduzido ao longo do fluxo normal de código, pode-se estar
comprometendo muito a inteligibilidade do código.
Exceções em Java
Diz-se que uma exceção é Lançada para sinalizar alguma falha. O Lançamento
de uma exceção causa uma interrupção abrupta do trecho de código que a
gerou. O controle da execução volta para o primeiro trecho de código (na
pilha de chamadas) apto a tratar a exceção lançada.
O uso de exceções permite separar a detecção da ocorrência de uma situação
excepcional do seu tratamento, ao se programar um método em Java. Na
forma antiga de se programar, era comum embutir as ações a tomar em cada
teste de erro.
Por exemplo, uma função hipotética f() ficava assim:
void f() {
if (<teste da condição de erro 1>) {
<comandos que determinam o que fazer se o erro 1 ocorreu>
}
else if (<teste da condição de erro 2>) {
<comandos que determinam o que fazer se o erro 2 ocorreu>
}
else ....<testando e tratando outros possíveis erros>
else {
<comandos para processar a função em condições normais>
}
}
Esta forma de programar prejudica o bom design das aplicações. Se um
método for usado em aplicações diferentes, o mesmo erro sempre será
tratado da mesma maneira. Isso limita a flexibilidade de lidar com situações
de exceção. Se for necessário alterar o procedimento a seguir no caso de um
determinado erro, o método na forma acima terá que ser alterado. Isso
introduz riscos e obrigará a re-testar todo o método, inclusive as partes que já
estavam funcionando corretamente.
Como funciona o mecanismo de exceções:
Uma exceção em Java é um objeto da classe java.lang.Exception, ou de uma
de suas subclasses. Como todo objeto, a exceção é capaz de armazenar dados
nas suas variáveis de instância. Quando um erro ou situação anormal é
encontrado durante a execução de um método, um objeto exceção é
construído, e diversos dados sobre essa ocorrência são registrados nos
campos desse objeto. Nesse momento, o método onde ocorreu a exceção
aborta, e o controle da execução retorna ao método que o chamou. Além
disso, por um mecanismo especial, o objeto exceção que foi construído é
também enviado ao método chamador.
Diz-se que o método onde ocorreu o erro "lança" a exceção para o método
que o chamou.
Suponha um método qualquer (por exemplo, main()) que chama um método
g():
public static void main (String[ ] args) {
......
......
g();
......
......
}
Suponha também que, de dentro de g(), o método f() seja chamado:
public void g() {
......
......
f();
......
......
}
Vamos admitir que no método f() podem ocorrer diversos erros ou situações
excepcionais. Usando exceções, o método f() poderia ser escrito da forma
abaixo. O comando throw é que se encarrega de lançar a exceção para o
método chamador:
public void f() {
if (<teste da condição de erro A>) {
//constrói uma exceção da classe ExcecaoA e lança para
quem chamou f()
throw new ExcecaoA(....lista de argumentos...);
else if (<teste da condição de erro B>) {
//constrói uma exceção da classe ExcecaoB e lança para
quem chamou f()
throw new ExcecaoB(....lista de argumentos...);
}
else ....<testando outros possíveis erros e procedendo de forma
similar>
else {
<comandos para processar f() em condições normais sem erro>
}
}
Agora o método f() não precisa mais determinar o que fazer quando cada
caso de erro ocorrer. Ele precisa apenas detectar que o caso de erro ocorreu.
A partir daí, ele constrói, e "lança" para o método g() que o chamou, um
objeto especial da classe Exception (ou de alguma subclasse). Ao construir
esse objeto, o método f() insere nele as informações que permitirão entender
qual erro ocorreu, e qual era o estado da aplicação
no momento do erro. Esse
objeto poderá ser "capturado" pelo método g(), e "tratado" lá, ou mesmo ser
novamente lançado por g() para ser capturado e tratado por quem o chamou,
no caso o main().
Vamos supor que exceções geradas por f(), do tipo ExcecaoA, devam ser
capturadas e tratadas pelo método main(), e exceções do tipo ExcecaoB
devam ser capturadas e tratadas no método g(). Nesse caso, os métodos
main() e g() devem ser escritos da seguinte forma:
public static void main (String[] args) {
......
try{
g();
}
catch(ExcecaoA exa){
....comandos para examinar a exceção referenciada por exa...
....comandos para tratar o erro A...
....................................
}
......
}
public void g() throws ExcecaoA {
......
......
try{
f();
}
catch(ExcecaoB exb){
....comandos para examinar a exceção referenciada por exb...
....comandos para tratar o erro B...
....................................
}
......
......
}
Note que exceções do tipo B que ocorram em f() jamais chegam a main(), pois
são sempre capturadas em g(). Mas as exceções do tipo A lançadas por f() não
são capturadas em g(), e são por ele re-lançadas para main(), onde são
finalmente capturadas e tratadas.
O programador tem agora mais flexibilidade para escolher em que ponto da
aplicação os erros serão tratados, e de que forma. Apenas no caso de o
próprio main() não capturar a exceção é que ocorrerá o encerramento
anormal do programa (que irá "abortar"), sendo seguido da impressão na
console de um relatório mostrando a sequência de chamadas que originou o
erro (essa sequência é chamada de stack trace). Nos demais casos, o
programa nunca aborta, mas os erros são capturados e tratados
adequadamente.
Informando o compilador que o método poderá Lançar uma ou mais
exceções.
No final do cabeçalho de um método que poderá lançar exceções, coloca-se a
informação:
throws <lista das classes de exceção que o método poderá lançar>
Por exemplo:
public void f() throws NumberFormatException,
IOException{
.....
}
Veremos mais adiante que para certas classes de exceção essa declaração é
obrigatória, enquanto que para outras é opcional.
Capturando e tratando exceções
Quando programamos um método em Java, e dentro desse método existem
comandos ou chamadas de métodos onde podem ocorrer uma ou mais
exceções, os comandos devem ser colocados dentro de um bloco try, que tem
a forma:
No caso de ocorrer uma exceção no bloco try, ela será lançada, os demais
comandos do bloco serão suspensos, e o controle passará para o primeiro
bloco catch que tenha um parâmetro de tipo compatível com a exceção
lançada. Pode haver zero, um ou mais blocos catch após um bloco try. Os
blocos catch e finally são opcionais, mas não é permitido haver apenas o
bloco try sem pelo menos um bloco catch ou um bloco finally associado.
O bloco finally será sempre executado após o bloco try terminar normalmete,
ou após os blocos catch executarem, mesmo que a saída desses blocos seja
causada pelo lançamento de outra exceção não tratada, ou por comando
return. O bloco finally somente não será executado se ocorrer uma chamada
para terminar a JVM, com System.exit(0).
Comandos após o bloco finally serão executados se não houver os casos
citados acima. Tipicamente, o bloco finally conterá comandos de liberação de
recursos alocados no bloco try (abertura de arquivos, de banco de dados, etc).
Se esses comandos ficassem no final do bloco try, poderiam nunca ser
executados em caso de lançamento de exceção.
Por exemplo:
public void g() {
try{
f();
}
catch (NumberFormatException nfe){
<comandos para tratar a exceção>
}
catch (Exception e){
<comandos para tratar a exceção>
}
}
Suponha que ao executar, o método f() lance uma exceção do tipo
NumberFormatException. Ela será capturada pelo primeiro bloco catch acima.
Se lançar outro tipo de exceção, ela será capturada pelo segundo bloco catch.
public class Classe1 {
public int valor;
public Classe1 (int n){
valor = n;
}
public void f(int x) throws Exception, NumberFormatException,
ArithmeticException{
if (x< 0)
throw new NumberFormatException("Erro-Argumento
negativo: "+ x);
if (x<= valor)
throw new NumberFormatException("Erro-Argumento
deve ser maior que " + valor);
if (x > 10000)
throw new Exception("Erro-Argumento muito grande: "+
x);
System.out.println (x/(valor-100));//
}
}
public class TesteExcecoes {
public static void main(String[] args) {
Classe1 c1 = new Classe1(100);
try{
// c1.f(200);
// c1.f(-20);
// c1.f(20000);
c1.f(700);
}
catch(NumberFormatException nf){
System.out.println(nf);
}
catch(ArithmeticException ar){
System.out.println(ar);
}
catch(Exception e){
System.out.println(e);
}
finally{
System.out.println("Terminou o método f()");
}
}
}
A linguagem Java tem três classes notáveis: (i)String, (ii)Object e
(iii)Throwable. A classe String é a única classe que têm literais (representação
de constantes). A classe Object é a única que não estende nenhuma classe em
sua definição. A classe Throwable é a única classe cujas instâncias diretas ou
indiretas podem ser usadas para serem lançadas. A classe Throwable é pré-
definida na linguagem Java, juntamente com várias outras classes definindo
um grande número de categorias de erro. Os programadores Java, por
convenção, caso queiram criar novas exceções devem estender a classe
Exception que é uma subclasse de Throwable.
Duas classes descendentes da classe Throwable podem ser consideradas
especiais: a classe Error e a classe RuntimeException. A linguagem Java não
obriga o programador a tratar os lançamentos de exceção envolvendo
instâncias da classe Error, da classe RuntimeException e das classes delas
derivadas, todos os outros lançamentos de exceção devem ser tratados pelo
programador.
A Máquina Virtual Java lança referências para instâncias de maneira implícita
utilizando as classes pré-definidas. O programador pode utilizar o comando
throw de forma explícita. Quando o fluxo de controle atinge o comando
throw <expressão>, a expressão é avaliada. Esta expressão corresponde, em
geral à criação de um objeto e resulta numa referência, p. ex. throw new
ErroDoTipoX();. A partir daí o fluxo de controle será desviado para uma
cláusula catch apropriada de algum comando try-catch. O fluxo de controle
segue a cadeia dinâmica dos Registros de ativação das invocações dos
métodos, ou seja a execução de um método pode terminar (i) por que o fluxo
de controle atingiu o final do método (return implícito, somente no caso de
métodos do tipo void!), (ii) porque o fluxo de controle atingiu um comando
return, ou (iii) porque foi executado um throw implícito ou explícito que não
foi capturado por um comando try-catch daquele método. A procura por um
try-catch apropriado é propagada até o ponto em que há um retorno para o
método main, neste caso a execução do programa será finalizada, com
mensagem de erro provida pela MVJ dizendo que uma exceção foi lançada
sem que fosse apanhada.
Exceções verificadas e não-verificadas:
A linguagem Java admite dois tipos de exceção: As não verificadas
(unchecked, em inglês) são instâncias de subclasses de RuntimeException. O
compilador não verifica se existe possibilidade de serem lançadas, e não exige
que os métodos onde possam ocorrer façam qualquer tratamento. Elas
representam erros ou defeitos na lógica do programa que podem causar
problemas irrecuperáveis em tempo de execução (run time).
Por outro lado, instâncias de Exception, ou de qualquer outra de suas
subclasses, são verificadas (checked) como, p.ex, IOException,
ClassNotFoundException
e CloneNotSupportedException. Elas representam
erros que podem ocorrer em tempo de execução, mas que não dependem da
lógica do programa, em geral defeitos nos dispositivos de entrada ou saída
(arquivos, rede, etc).
O compilador exige que um método onde possam ocorrer exceções
verificadas faça uma de duas coisas: ou utilize blocos try-catch-finally para
capturar e tratar essas exceções, ou declare que pode lançar essas exceções
para o método chamador, colocando uma cláusula "throws" no seu
cabeçalho, como por exemplo:
public void M() throws IOException, CloneNotSupportedException {
..............
}
Essa cláusula é facultativa para o caso de exceções não-verificadas.
A classe java.lang.Exception, e todas as suas subclasses, têm pelo menos dois
construtores da forma:
<nome da classe de Exceção> (String <mensagem de erro>)
<nome da classe de Exceção> ()
A mensagem de erro é sempre retornada pelo método toString(). Toda
exceção também aceita a mensagem printStackTrace(), que imprime na
stream apontada por System.err um stack trace. O stack trace é um relatório
detalhado da seqüência de chamadas a métodos que antecederam o
lançamento da exceção.
Para lançar uma exceção que seja instância das classes de verificação
obrigatória a linguagem obriga o programador a declarar no cabeçalho do
método quais as classes de exceção podem ter instâncias lançadas. Portanto,
o formato completo do cabeçalho de definição de um método é:
<modificadores> <tipo> <nome>(<parametros>) throws <classes>
static void m() throws ErroDoTipoX, ErroDoTipoY, ErroDoTipoZ{ .
..
throw new ErroDoTipoX();
...
throw new ErroDoTipoY();
...
throw new ErroDoTipoZ();
}
Se o programador quiser estender a classe que contém o método m() da tela
anterior e se o programador quiser sobrepor o método m() então o novo
método terá de declarar o lançamento de instâncias das mesmas classes. Isso
garante que um código que trabalha com a classe base trabalhará também
com as classes derivadas.
A figura abaixo ilustra o relacionamento entre as exceções checked e
nonchecked e a hierarquia de classes com raiz na classe Throwable. Os
retângulos com nomes representam classes e os triângulos representam
hierarquias de classes com classe “raiz” identificada pelo retângulo da ponta
superior do triângulo. Na hierarquia de classes predefinida em Java a classe
Throwable tem somente duas classes filhas (Error e Exception), mas um
programador Java pode definir outras hierarquias a partir da Throwable
(embora isso não seja recomendável).
As classes e hierarquias cujo lançamento de instâncias seja de verificação
obrigatória são identificadas na cor cinza.Todas as instâncias diretas e
indiretas da classe Error e da classe RuntimeException são de verificação
opcional. Todas as instâncias diretas e indiretas da classe Throwable, que não
sejam as instâncias diretas e indiretas das classes Error e RuntimeException,
são de verificação obrigatória.
A sintaxe básica do comando try/catch (na verdade try/catch/finally!):
try{
<comandos que podem ou não lançar exceções>
} catch(ExcecaoTipo1 parâmetro){
<tratamento da instância da classe ExcecaoTipo1>
} catch(ExcecaoTipo2 parâmetro){
<tratamento da instância da classe ExcecaoTipo2>
} ...
} finally{
<estes comandos serão executados com ou sem lançamento de exceção>
}
Quando o fluxo de controle chega ao comando try/catch/finally o fluxo de
controle passa a percorrer o bloco try. Se uma instância de classe de exceção
é lançada cada cláusula catch é examinada e o parâmetro da cláusula catch
mais adequada recebe a referência da instância lançada e o fluxo de controle
passa a percorrer o bloco da cláusula catch Nenhuma outra cláusula catch é
executada? Se nenhuma cláusula catch for adequada o lançamento da
exceção será verificado por comandos try externos. O bloco da cláusula finally
é opcional, mas se estiver presente será sempre executado não importando
se o bloco try terminou a execução de forma normal (e não houve bloco catch
executado) ou se o bloco try terminou de forma excepcional.
Aula 10: Manipulação de modelo de classes em
Interfaces Gráficas
Entendendo o problema real
Quando estamos aprendendo uma linguagem de programação, muitas vezes
não conseguimos ver a aplicação prática do que estamos aprendendo. Além
da matéria ser difícil, não conseguimos ver a aplicação deste conteúdo no
mercado de trabalho.
Nesta aula, iremos construir um exemplo real, com as classes da camada da
interface conversando ou trocando mensagens com as classe do negócio.
Neste exemplo, só iremos aplicar todos os conhecimentos adquiridos nas
nossas aulas. Para ser uma aplicação completa e passível de ser consumida no
mercado a conexão com o banco de dados, para persistir os objetos
envolvidos.
O problema proposto
Queremos controlar um clube recreativo. Neste clube, devemos gerenciar as
atividades oferecidas e seus associados. Para isso, temos o seguinte diagrama
de classes das classes do negócio:
Na imagem, podemos ver as Classes Atividade, Sócio e Alocação. Iremos
trabalhar apenas com as classes Atividade e Sócio.
Para a camada de Interface, teremos o seguinte diagrama de classes:
Agora, olhando o problema todo, temos o seguinte diagrama:
Nosso problema agora é implementar este diagrama em Java. Para simplificar
um pouco nosso trabalho, não iremos trabalhar com a classe Alocação.
JavaBean
É uma arquitetura de componente definida na Java 2 Plataform, Standard
Edition (J2SE), usado para definir os componentes do modelo do software em
Java. São classes simples com características definidas, que visam a
interoperabilidade do código
Características
Um bean é uma classe definida como um bloco, que têm sua estrutura
facilmente portável e sua estrutura é muito simples. O foco é construir
pequenos componentes com apenas as funções básicas.
Definição
Um Java Bean é um componente de software reutilizável, que pode ser
manipulado visualmente por uma ferramenta de desenvolvimento”
Para isso, um Bean tem que ter as seguintes características:
Nome da Classe.
Atributos da Classe privados.
Construtor vazio.
Métodos Get’s e Set’s para todos os atributos.
Criando as classes do negócio
Utilizando o NetBeans, criar um novo projeto Java, com o nome de
ClubeRecreativo.
Arquivo -> Novo Projeto -> Java -> Aplicativo Java
Aperte o botão Próximo.
Uma nova caixa de diálogo irá se abrir para definir o nome e local do seu
projeto.
Como podemos ver ao lado, definimos o nome do Projeto e o local onde os
arquivos ficarão armazenados no seu computador.
Preencher o nome do projeto com ClubeRecreativo e apertar o botão
Finalizar.
Caso tenha feito alguma coisa errada, você pode clicar no botão voltar para
corrigir.
Agora com o nosso projeto criado, vamos criar as duas classes apresentadas
acima, Atividade e Socio.
Clicar com o botão direito do mouse no nome do nosso projeto. Escolher
Novo -> Classe Java.
O nome da classe será Atividade e vamos colocar esta classe dentro do pacote
negocio.
Basta clicar em finalizar para que a estrutura da classe seja criada.
Como iremos criar um Bean, iremos definir os atributos e os métodos Get’s e
Set’s padrão, bem como seu construtor vazio.
Construindo as classes de interface
As telas que iremos criar aqui tem a mesma estrutura da criada na aula 7.
Inicialmente, vamos construir a tela principal. Para este sistema funcionar,
precisamos construir uma tela de cadastro com uma barra de menus. Esta
tela se liga a TelaCad. Dependendo da opção escolhida no menu, a tela de
cadastro terá o comportamento de cadastro de Atividade ou cadastro de
Sócio. Isso é uma aplicação de polimorfismo.
Vamos criar a TelaPrinc.
Clicar com o botão direito no nome do projeto e criar
um novo Formulário JFrame. A caixa de diálogo irá abrir. Coloque o nome da
classe e no nome do pacote, vamos colocar Visao. Vamos colocar todas as
classes da camada de interface no pacote Visao.
Agora, vamos programar a barra de menu. Utilizar a Palete de Menus Swing
para clicar e arrastar um componente Barra de Menu para o Projeto. A barra
de menu com as opções File e Edit irá aparecer. Observe que estas duas
opções são 2 objetos jMenu fornecidos automaticamente. Para colocar as
opções, temos que os itens de menu (Item de Menu).
Editar os nomes das opções para aparecer Cadastro e Sair. Clicando em cima
dos nomes, a edição é aberta e trocamos o nome. Outra opção é a de ir na
propriedade, buscar a propriedade text para o novo nome.
Vamos programar o evento de saída, para fechar a janela e terminar o
programa. Insira um Item de Menu na opção Sair. Coloque o nome Sair neste
item. Nas propriedades de evento, programe o actionPerformed para este
item. Clique nas três pontos para que a opção do nome do método de
tratamento do evento seja aberta. Coloque o nome do método e coloque o
código no método criado.
....
private void jMenuItem1ActionPerformed(java.awt.event.ActionEvent evt) {
if(javax.swing.JOptionPane.showConfirmDialog(null,"Confirma Saída?",
"ATENÇÃO", javax.swing.JOptionPane.YES_NO_OPTION )==0){
System.exit(0);
}
}
...
Este código cria uma caixa de diálogo para confirmar a saída. Caso aperte na
opção YES, o sistema termina sem erros - normalmente.
Vamos agora fazer o mesmo procedimento para o cadastro. Neste menu,
teremos duas opções: Atividade e Socio. Criar dois itens com estas opções.
Colocar o Item de Menu;
Renomear a opção;
Clicar na opção e programar o evento;
Escolher Eventos na Paleta;
Clicar nos 3 pontos do actionPerformed;
Nomear o método de tratamento do evento;
TrataCadastraSocio
TrataCadastraAtividade
Para continuar, precisamos das telas de cadastro prontas. Vamos trabalhar
nestas telas.
Integrando as telas de cadastro com as classes
Para implementar a integração, vemos que a TelaCad precisa estar associada
as classes Atividade e Socio. Para isso, criaremos estes atributos na classe
genérica.
Trabalhando com a Atividade, basta efetuar a programação dos tratamentos
de eventos da TelaCadClube, para criação, alteração, exclusão e consulta. As
alterações no código estão apresentadas abaixo.
@Override
void trataAltera() {
if (atividade==null)
atividade = new Atividade();
atividade.setCodAtv(corpo.getAtv());
atividade.setDescricao(corpo.getNome());
}
@Override
void trataConsulta() {
if (atividade==null)
corpo.setNome("Atividade não cadastrada");
else {
corpo.setAtv(atividade.getCodAtv());
corpo.setNome(atividade.getDescricao());
}
}
@Override
void trataExclui() {
if(javax.swing.JOptionPane.showConfirmDialog(null,"Confirma
Exclusão?", "ATENÇÃO", javax.swing.JOptionPane.YES_NO_OPTION )==0){
atividade=null;
corpo.setAtv(0);
corpo.setNome("");
}
}
@Override
void trataInclui() {
if (atividade==null)
atividade = new Atividade();
atividade.setCodAtv(corpo.getAtv());
atividade.setDescricao(corpo.getNome());
}
A programação da outra tela com a outra classe é análoga e iremos deixar
para que você pratique.
Como exercício, faça o tratamento da exceção para que se o usuário entre
com um valor inteiro nos campos Matrícula e CodAtv, seja apresentado uma
mensagem para que o usuário possa editar e corrigir a digitação. Só como
orientação, este tratamento deverá ser feito nas funções de tratamento do
JPanel, tanto para Atividade quanto para Sócio.Mais conteúdos dessa disciplina
try...catch - JavaScript | MDN- henriquieta - Resumo
- Mapa Mental - Programação
- Mapa Mental - Desafios UX Mobile
- Desafios e Benefícios da Telemedicina
- Desafios e Benefícios da Telemedicina
- Desafios e Benefícios da Telemedicina
- Mapa Mental - Princípios SOLID
- Mapa Mental - Princípios SOLID
- Mapa Mental - Princípios SOLID
- Mapa Mental - Princípios SOLID
- Avaliação em Programação
- Disco Rigido
- San Giorgio Maggiore at Dusk - Claude Monet
