ALL IN ONE

Prévia do material em texto

- -1
LINGUAGEM DE PROGRAMAÇÃO
INTRODUÇÃO À LINGUAGEM DE 
PROGRAMAÇÃO JAVA
- -2
Olá!
Ao final desta aula, você será capaz de:
1 - Identificar a importância das linguagens de programação;
2 - Identificar as características da linguagem de programação java;
3 - Conhecer os tipos de programas java;
4 - Identificar os requisitos necessários para se programar;
5 - Construir um ambiente de programação para a linguagem java;
6 - Desenvolver pequenos programas com estruturas básicas.
1 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.
- -3
2 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 (Empresa fabricante deSun Microsystems 
computadores. semkondutores e softwares com sede em Santa Clara. Califórnia EUA. Em abril de 2079, a Oracle
Corporation comprou a Microsystems, transformando a indústria de Tecnologia da informa*.).
Linguagem de Alto desempenho, suporta multithreading, compilação just-in-time e utilização de código nativo.
É uma linguagem que é compilada para um “ ”, que é interpretada por uma máquina virtual – (Javabytecode JVM 
virtual Machine - É um programa que carrega e interpreta aplicativos Java, convertendo os bytecoies em códigos
executáveis de máquina.).
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.
- -4
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.
- -5
3 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.
•
•
•
•
- -6
4 Funcionamento de um Programa Java
 Editor: É 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.
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 programador 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 JIT, conhecido como compilador Java HotSpot, traduz os bytecodes
para a linguagem de máquina do computador subjacente.
•
•
•
•
- -7
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.
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.
5 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.
6 Entendendo as siglas dos Ambientes Java
J2SE
Java2 Standard Edition – Fornece as principais e enfoca o desenvolvimento de aplicações na arquiteturaAPIs* 
Cliente – Servidor. Não permite distribuição de objetos nem oferece suporte a tecnologias para Internet.
 API* - Application Programing Interface (Interface de Programação de Aplicações).
J2EE
Java2 Enterprise Edition – Fornece um conjunto de para o desenvolvimento corporativo e enfoca naAPIs
integração entre sistemas. Disponibiliza alta distribuição de objetos e oferece total suporte a tecnologias para
Internet.
J2ME
Java2 Micro Edition – Fornece as para o desenvolvimento de aplicações para computação móvel, emAPIs
pequenos dispositivos ou tecnologias embarcadas.
•
•
•
- -8
7 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 serviets: 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.
JavaBeans: São componentes de software escritos em Java que podem ser manipulados visualmente com a 
ajuda de uma ferramenta de desenvolvimento.
8 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:
https://www.oracle.com/java/technologies/javase-downloads.html
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.
Para instalar, clique no arquivo baixado e siga as instruções do site para efetuar a correta instalação.
No link abaixo, existe um artigo que auxilia o usuário na instalação do J2SE no Windows 2000/XP
https://www.oracle.com/java/technologies/javase-downloads.html
https://www.oracle.com/java/technologies/javase-downloads.html
https://www.oracle.com/java/technologies/javase-downloads.html
https://www.oracle.com/java/technologies/javase-downloads.html
https://www.oracle.com/java/technologies/javase-downloads.html
- -9
9 Escrevendo e Executando o Primeiro Programa
1. Abra o bloco de notas e digite o código.
2. 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.
3. 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.
- -10
4. 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.
5. Para executar este código, temos que chamar a máquina virtual. Para isso, basta:
java PrimeiroPrograma
- -11
6. Observe que não há necessidade de colocar a extensão neste passo.
Parabéns, você conseguiu executar seu primeiro programa!
O que vem na próxima aula
Na próxima aula, você irá estudar os seguintes assuntos:
• Tema: Manipulação de Tipos;
• Strings;
• Vetores;
Saiba mais
Para saber mais sobre os tópicos estudados nesta aula, pesquise na internet sites, vídeos e
artigos relacionados ao conteúdo visto. Se ainda tiver alguma dúvida, fale com seu professor
online utilizando os recursos disponíveis no ambiente de aprendizagem.
Para esta aula sugiro as seguintes tarefas:
Leitura do capítulo 2: Introdução a aplicativos Java, do livro Java Como Programar 4ª edição.
Resolução dos exercícios de 2.7 até 2.35 do capítulo 2 do livro Java Como Programar.
Visitar os seguintes sites:
https://www.java.com/pt_BR/
https://www.oracle.com/java/technologies/
https://www.eclipse.org
http://www.netbeans.org
• Para baixar o Java, baixar a máquina virtual, tutoriais e possibilidades•
• Para baixar IDE’s:
• Eclipse
•
•
• NetBeans•
•
•
•
https://www.java.com/pt_BR/
https://www.oracle.com/java/technologies/
https://www.eclipse.org/
http://www.netbeans.org/
- -12
• Vetores;
• Conversão simples de tipos;
• Utilizando os dispositivos de entrada e saída;
• Caixas de Diálogo.
CONCLUSÃO
Nesta aula, você:
• Compreendeu a importância das linguagens de programação;
• Conheceu o ambiente de programa java;
• Se familiarizou com os diversos tipos de plataformas java;
• Entendeu o funcionamento de um ambiente java;
• Aprendeu a montar um ambiente de programação e testes para a linguagem de programação java.
•
•
•
•
•
•
•
•
•
- -1
LINGUAGEM DE PROGRAMAÇÃO
TIPOS DE DADOS E ESTRUTURAS BÁSICAS 
DE PROGRAMAÇÃO
- -2
Olá!
Ao final desta aula, você será capaz de:
1. Identificar os tipos de dados primários;
2. Utilizar tipos de dados primitivos, variáveis simples;
3. Aplicar as estruturas de decisão em java;
4. Aplicar as estruturas de repetição em java;
5. Desenvolver, ler e interpretar pequenos programas java, com estruturas básicas e seus tipos de dados.
1 As convenções do Java
A linguagem de programação Java é “ ”. Existem várias convenções utilizadas. São elas:Case Sensitive*
• 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.
Case Sensitive*: Sensível ao tamanho: em computação significa que um programa ou um compilador faz a
diferenciação entre letras maiúsculas e minúsculas, ou seja, Maiúscula é diferente de maiúscula. O sistema
operacional Linux é case sensitIve bem corno as linguagens C, Java, C Sharp entre outras.
2 Comentários em Java
Existem três formas de se inserir comentários:
1.// Comentário 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).
•
•
•
•
- -3
3 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.
4 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
5 Operadores Aritméticos e Relacionais
Operadores Aritméticos
- -4
Operadores relacionados
Fique ligado
O operador ! é chamado de not ou negado.
- -5
6 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.
Desvia o fluxo natural do programa de acordo com o resultado de um teste lógico.
if (expressão booleana) comandol 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 comandol é 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.
Desvios de fluxo
Existem dois tipos de desvios de fluxo Break Continue;
break; O comando termina a execução de um loop sem executar o resto dos comando e força a saída do laço.
- -6
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.
Estruturas de repetição ou laço
1- while(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 nolaç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 comandos}
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.
7 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.
- -7
8 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.
9 Conversão Entre Tipos 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.
- -8
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/7 é 3.57
O que vem na próxima aula
Na próxima aula, você estudará os seguintes assuntos:
• Tema: Introdução as interfaces gráficas;
• Apresentação do pacote Swing;
• Criação de interfaces bem simples;
• Utilização de uma IDE para o auxílio da programação;
• Caixas de Diálogo.
CONCLUSÃO
Nesta aula, você:
• Identificou os tipos de dados primários;
• Identificou as estruturas de decisão e repetição em java;
• Manipulou vetores e strings;
• Aprendeu a converter tipos de dados;
• Desenvolveu e executou pequenos programas.
•
•
•
•
•
•
•
•
•
•
- -1
LINGUAGEM DE PROGRAMAÇÃO
INTRODUÇÃO ÀS INTERFACES GRÁFICAS
- -2
Olá!
Ao final desta aula, você será capaz de:
1. Identificar e utilizar ides;
2. Utilizar netbeans;
3. Criar interfaces básicas, realizando operações simples;
4. Entender a hierarquia do pacote swing.
1 Introdução às 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 (Rapid Application Development - Desenvolvimento Rapido de Aplicativos)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.
- -3
2 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 idéia 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 é 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 idéia de reutilização de componentes, que era a base do Java.
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
- -4
Links:
Para fazer o Download da IDE, basta ir ao endereço: https://netbeans.org
3 Utilizando o NetBeans
Para utilizar o NetBeans, é necessário criar um projeto, e, para isto, siga os passos a seguir:
1º Passo: No menu Arquivo, clique em Novo projeto. 
https://netbeans.org/
https://netbeans.org
- -5
O programa irá conduzir em um assistente de criação de projetos. O usuário deverá escolher o tipo de projeto, o
nome, o ambiente em que será executado e todas as informações necessárias para a execução do projeto.
Faremos uma criação guiada para dar segurança ao aluno nesta tarefa.
Na caixa de diálogo do novo projeto, escolhemos um aplicativo Java.
2° Passo: Digite em Nome do Projeto um nome para seu projeto (ex.: ProjAula3) e aperte em Finalizar.
3º Passo: É aberta então a tela do NetBeans onde será criado o arquivo.java (arquivos fontes). 
- -6
4º Passo: Note que, na janela pertencente à aba Main.java, está o método: 
public static main(String[] args){
//TODO code application logic here
}
Este é o método inicial, então escrevemos alguns comandos de maneira a realizar a primeira execução de um
programa em Java.
5º Passo: Agora digite o código abaixo no método main. 
public static main(String[] args){
//TODO code application logic here
int num1=2;
int num2=8;
int soma;
soma = num1+num2;
System.out.printf(“A soma é %d\n”, soma);
}
6º Passo: Com o código fonte digitado, vamos executar o projeto principal. Para isso, podemos utilizar a tecla de
atalho – F6, ou apertar no botão executar.
7º Passo: Note na janela saída, na parte inferior da tela, a execução do projeto e a apresentação do resultado de
modo semelhante ao que ocorria quando executávamos no terminal da console.
- -7
Agora você está apto a executar um programa nesta IDE, basta explorar mais a ferramenta para tirar o máximo
de proveito de seus recursos e facilidades.
4 Introdução a Concepção de Interfaces Gráficas
Muitosdos 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 - Graphical User Interface) 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.
- -8
5 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: (pacote do núcleo) e (pacote dejava.awt javax.swing
extensão). Os dois pacotes definem componentes com peculiaridades distintas e que serão discutidas a seguir.
Componentes 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):
- -9
6 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 adicioandos 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);
- -10
f.setVisible(true);
}
}
Componentes Básicos
public class TestaFrm01 {
public static void main(String []args){
Frm01 tela = new Frm01();
tela.criaTela();
}
}
A saída deste programa é:
O método setDefaultCloseOperation() também pode ser executado com outras constantes como argumento:
Inserindo componentes na tela
http://estaciodocente.webaula.com.br/cursos/gon266/docs/03LDP_doc01.pdf
O que vem na próxima aula
Na próxima aula, você estudará os seguintes assuntos:
• Tema: Princípios da Orientação a Objetos;
• Classes e Objetos;
• Principais características da OO utilizando Atributos e Métodos.
•
•
•
http://estaciodocente.webaula.com.br/cursos/gon266/docs/03LDP_doc01.pdf
http://estaciodocente.webaula.com.br/cursos/gon266/docs/03LDP_doc01.pdf
- -11
• Principais características da OO utilizando Atributos e Métodos.
CONCLUSÃO
Nesta aula, você:
• Identificou a importância das ides;
• Utilizou uma IDE chamada netbeans;
• Manipulou interfaces gráficas;
• Desenvolveu e executou pequenos programas com interfaces gráficas e dentro de uma IDE.
•
•
•
•
•
- -1
LINGUAGEM DE PROGRAMAÇÃO
PRINCÍPIOS DA ORIENTAÇÃO A OBJETOS
- -2
Olá!
Ao final desta aula, você será capaz de:
1. Identificar os conceitos básicos da Orientação a Objetos;
2. Criar e manipular classes e objetos em Java;
3. Utilizar interfaces gráficas interagindo com objetos e classes previamente definidos;
4. Implementar classes e instanciar objetos em Java.
1 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.
- -3
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.
2 Abstração
Extrair tudo que for essencial e mais nada para o escopo do sistema;
É 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 princípio que devemos considerar a
essência de cada objeto e não pensar em todos os detalhes de implementação.
3 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) {
- -4
// 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.
4 Encapsulamento
Mecanismo utilizado em orientação a objetos para obter segurança, modularidade e autonomiados 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 ).
- -5
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 acesso 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, como mostrado na tabela.
5 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:
Os métodos da classe, geralmente agrupados por funcionalidade.
Os construtores de objetos dessa classe.
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.
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.
6 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
- -6
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.
7 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;
- -7
Nome deve ser um identificador válido da linguagem Java;
Valor default é opcional; se presente, especifica um valor inicial paia a variável.
8 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 stat; 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 ao 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.
Métodos
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 co-existir em uma mesma classe desde que a lista de argumentos seja distinta,
usando o mecanismo de sobrecarga.
•
•
•
•
- -8
Neste exemplo, definimos a classe Ponto2D com dois atributos e dois métodos. Os atributos são, x e y enquanto
os métodos são:
Ponto2D - Construtor Distância - método que calcula a distância entre o ponto e um outro dado.
O que vem na próxima aula
Na próxima aula, você estudará os seguintes assuntos:
• Tema: Herança;
• Apresentar os conceitos de Herança;
• Criar e manipular classes e objetos que se relacionem através de herança;
• Sobrecarga de métodos.
CONCLUSÃO
Nesta aula, você:
• Identificou o que é programação orientada à objetos;
• Identificou classes e objetos;
• Aprendeu a manipular classes e objetos em java;
• Desenvolveu e executou pequenos programas com orientação a objetos.
•
•
•
•
•
•
•
•
- -1
LINGUAGEM DE PROGRAMAÇÃO
HERANÇA
- -2
Olá!
Ao final desta aula, você será capaz de:
1. Apresentar os conceitos de herança;
2. Criar e manipular classes e objetos que se relacionem através de herança;
3. Sobrecarga de métodos;
4. Utilizar interfaces gráficas, interagindo com objetos e classes previamente definidos;
5. Explorar o conceito de herança, sobrecarga de métodos, em exemplos e exercícios.
1 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 super classe 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.
Abaixo, 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.
Meios de Transporte
•
•
•
- -3
2 Terminologias
Estender - Criar uma 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.
3 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étodos abstratos.•
- -4
• A classe abstrata não implementa os métodos 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. Osmé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.
3.1 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 corno 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 superciasse ele não precisa ter
implementação alguma.
Exemplo:
•
•
- -5
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
- -6
PorComissao: Valor fixo + comissão* vendas
PorItem: valor por produção * quantidade produzida
- -7
PorHora: valor por hora * total de horas trabalhadas
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().
- -8
4 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).
O que vem na próxima aula
Na próxima aula, você irá estudar os seguintes assuntos:
• Tema: Encapsulamento e Associações;
• Apresentar os conceitos de Encapsulamento e Associações;
• Criar e manipular atributos encapsulados;
• Criação dos métodos Get’s e Set’s;
• Criar e manipular classes e objetos que se relacionem através de Associações.
•
•
•
Fique ligado
Clique no link a seguir para entender melhor: http://estaciodocente.webaula.com.br/cursos
/gon266/docs/05LDP_doc01.pdf
•
•
•
•
•
http://estaciodocente.webaula.com.br/cursos/gon266/docs/05LDP_doc01.pdf
http://estaciodocente.webaula.com.br/cursos/gon266/docs/05LDP_doc01.pdf
- -9
CONCLUSÃO
Nesta aula, você:
• Identificou o conceito de herança em orientação a objetos;
• Criou e manipulou classes e objetos através da herança;
• Utilizou interfaces gráficas, interagindo com objetos e classes, previamente definidos;
• Identificou os conceitos de sobrecarga de métodos;
• Desenvolveu e executou pequenos programas com orientação a objetos.
•
•
•
•
•
- -1
LINGUAGEM DE PROGRAMAÇÃO
ENCAPSULAMENTO E ASSOCIAÇÕES DE 
CLASSES
- -2
Olá!
Ao final desta aula, você será capaz de:
1. Apresentar os conceitos de encapsulamento e associações de classes;
2. Criar e manipular classes e objetos, com seus atributos encapsulados, e que se relacionem através de
associações;
3. Utilizar interfaces gráficas interagindo com objetos e classes previamente definidos;
4. Explorar o conceito de encapsulamento e associações de classes, em exemplos e exercícios.
1 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.
2 Modificadores de visibilidade
Um modificador de acesso determina como será a visibilidade de uma classe, método ou atributo a partir de
outras classes.
- -3
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 re-escrita. 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.
Exemplos
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;
- -4
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 ());
}
}
3 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.
- -5
4 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 (Unified Modeling Language Linguagem de naodelagem unificada), quando estamos modelando oUML
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.
Saiba mais
Clique aqui para entender melhor:
http://estaciodocente.webaula.com.br/cursos/gon266/docs/06LDP_doc01.pdf
http://estaciodocente.webaula.com.br/cursos/gon266/docs/06LDP_doc01.pdf- -6
5 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.
Exemplos: http://estaciodocente.webaula.com.br/cursos/gon266/docs/06LDP_doc02.pdf
http://estaciodocente.webaula.com.br/cursos/gon266/docs/06LDP_doc02.pdf
http://estaciodocente.webaula.com.br/cursos/gon266/docs/06LDP_doc02.pdf
- -7
O que vem na próxima aula
• Tema: Interfaces;
• Apresentar o pacote de Interfaces Swing;
• Criar e manipular pequenos programas com a biblioteca;
• Criar e manipular classes e objetos que se relacionem com as Interfaces.
CONCLUSÃO
Nesta aula, você:
• Identificou o conceito de encapsulamento em orientação a objetos;
• Criou e manipulou classes e objetos com atributos encapsulados;
• Associou classes e manipulou objetos associados;
• Exercitou exemplos;
• Desenvolveu e executou pequenos programas com orientação a objetos.
•
•
•
•
•
•
•
•
•
- -1
LINGUAGEM DE PROGRAMAÇÃO
INTERFACES E POLIMORFISMO
- -2
Olá!
Ao final desta aula, você será capaz de:
1. Explorar o pacote swing para desenvolver interfaces em java;
2. Criar e manipular menus;
3. Utilizar interfaces gráficas, interagindo com objetos e classes previamente definidos;
4. Apresentar o conceito de polimorfismo, utilizar classes abstratas;
5. Aplicar as interfaces, criando menus e os conceitos de polimorfismo em exemplos e exercícios.
1 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 (Graphical User
Interface). Elas são:
• java.awt: Abstract Window Toolkit (classes básicas);
• javax.swing: Swing Componets – Fornece um conjunto de components 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.
•
•
- -3
2 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.
3 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,
•
•
•
- -4
• 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.
4 Botões
É 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).
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
- -5
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 no argumento o valor true. Quando o
- -6
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 no 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 pelos 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, JTextArea 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)
- -7
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 Unha quando o texto alcançar a borda da JTextArea. Porém, as palavras podem ficar "quebradas",
com caracteres em uma Unha e outros na próxima, sem nenhum compromisso com as normas gramaticais. Uma
maneira de sanar paliativamente esse problema é invocaro método setWrapStyleWord (boolean), o qual
determina que a mudança de linha seja definida pelas palavras.
JScrollPane
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.
Acro Pane
- -8
É possível configurar o comportamento do JScrollPane para um objeto com os métodos setVerticalScrollBarPolicy
(int) e seti-lorizontalScrollBarPolicy(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 às interações feitas pelo mouse e pelo teclado (setas, PgDn, PgUp, Nome 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 setInvert(boolean), com um argumento true.
JComboBox
- -9
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 ItemEvents, assim como as
JCheckBoxes.
5 Menus
Os menus talvez sejam 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 ú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 JIntemalFrame e faz-se isso, usando-se o método setJMenuBar(JMenuBar). 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.
- -10
Clique no link a seguir e veja um passo a passo para montagem de um menu em barras em Java:
http://estaciodocente.webaula.com.br/cursos/gon266/docs/07LDP_doc01.pdf
6 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 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.
http://estaciodocente.webaula.com.br/cursos/gon266/docs/07LDP_doc01.pdf
http://estaciodocente.webaula.com.br/cursos/gon266/docs/07LDP_doc01.pdf
- -11
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 re-escritas.
O que vem na próxima aula
Na próxima aula, você estudará os seguintes assuntos:
• Tema: Listeners e Adapters;
• Apresentar o conceito de Listeners;
• Apresentar o conceito de Adapters;
• Criar e manipular pequenos programas estes conceitos;
• Criar e manipular classes e objetos que se relacionem com as Interfaces.
•
•
•
•
•
- -12
CONCLUSÃO
Nesta aula, você:
• Explorou o pacote swing, desenvolvendo interfaces em java;
• Criou e manipulou menus;
• Utilizou interfaces gráficas interagindo com objetos e classes previamente definidos;
• Identificou o conceito de polimorfismo, utilizou classes abstratas;
• Aplicou os conhecimentos, construindo exemplos de interfaces, criando menus;
• Desenvolveu e executou pequenos programas com orientação a objetos, com o pacote swing associadas 
a objetos.
•
•
•
•
•
•
- -1
LINGUAGEM DE PROGRAMAÇÃO
LISTENERS E ADAPTERS
- -2
Olá!
Ao final desta aula, você será capaz de:
1. Apresentar os conceitos de listener e os tratamentos de eventos;
2. Apresentar os adapters que implementam as interfaces de eventos;
3. Utilizar interfaces gráficas, interagindo, com objetos e classes previamente definidos, com listeners e adapter;
4. Explorar o conceito de tratamento de eventos em exemplos e exercícios.
1 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.
- -3
2 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 aos componentes existem, no Java, um conjunto de
interfaces chamadas listeners. Um listener é uma interface que especifica os métodos que umaaplicaçã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:
- -4
ActionEvent - 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.
 ActionListener - 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.
3 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.
4 Classe JOptionPane
Estrutura básica:
•
•
•
•
•
•
•
- -5
5 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);
}
}
- -6
6 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){
•
•
•
•
- -7
int resp = JOptionPane.showConfirmDialog(janela,
"Você já estudou para as provas?", "Escolha uma opção",JOptionPane.OK_CANCEL_OPTION);
}
}
7 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);
}
}
•
•
- -8
O que vem na próxima aula
Na próxima aula, você estudará os seguintes assuntos:
• Tema: Tratamento de Exceção;
• Apresentar o conceito de tratamento de exceção;
• O comando try catch;
• Throw.
CONCLUSÃO
Nesta aula, você:
• Identificou os conceitos de listeners e os tratamentos de eventos;
• Identificou os conceitos de adapters;
• Criou e manipulou interfaces gráficas com objetos e classes efetuando o tratamento de eventos;
• Associou classes e manipulou objetos associados;
• Desenvolveu e executou pequenos programas com orientação a objetos e tratamento de eventos.
•
•
•
•
•
•
•
•
•
- -1
LINGUAGEM DE PROGRAMAÇÃO
TRATAMENTO DE EXCEÇÃO
- -2
Olá!
Ao final desta aula, você será capaz de:
1. Apresentar os conceitos de Exceção e os seus tratamentos;
2. Apresentar as estruturas de try – catch;
3. Apresentar a estrutura Throw;
4. Utilizar interfaces gráficas interagindo com objetos e classes previamente definidos com tratamento de
exceção;
5. Explorar o conceito de tratamento de exceção em exemplos e exercícios.
1 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.
2 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() {
- -3
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.
Saiba mais
Clique no link a seguir e saiba mais sobre o mecanismo de exceções: http://estaciodocente.
webaula.com.br/cursos/gon266/docs/09LP_doc01.pdf
http://estaciodocente.webaula.com.br/cursos/gon266/docs/09LP_doc01.pdf
http://estaciodocente.webaula.com.br/cursos/gon266/docs/09LP_doc01.pdf
- -4
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:
Veremos mais adiante que para certas classes de exceção essa declaração é obrigatória, enquanto que para
outrasé opcional.
3 Capturando e tratando exceções
os blocos try { }, catch(){ }, e finally { }
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:
try {
<comandos>
}
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.
- -5
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.
Clique no link a seguir e veja um link completo: http://estaciodocente.webaula.com.br/cursos/gon266/docs
/09LP_doc02.pdf
4 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 {
..............
http://estaciodocente.webaula.com.br/cursos/gon266/docs/09LP_doc02.pdf
http://estaciodocente.webaula.com.br/cursos/gon266/docs/09LP_doc02.pdf
http://estaciodocente.webaula.com.br/cursos/gon266/docs/09LP_doc02.pdf
- -6
}
Essa cláusula é facultativa para o caso de exceções não-verificadas.
5 Construtores
A classe java.lang.Exception, e todas as suas subclasses, têm pelo menos dois construtores da forma:
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
- -7
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.
Quando o fluxo de controle chega ao comando byicatch/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 catou executado) ou se o bloco try terminou de forma excepcional.
- -8
O que vem na próxima aula
Na próxima aula, você estudará os seguintes assuntos:
• Tema: Manipulação de Modelo de classes em Interfaces Gráficas;
• Criar objetos baseados em classes básicas do modelo;
• Manipular os conteúdos das classes através das interfaces;
• Exercitar todos os conhecimentos adquiridos no curso.
CONCLUSÃO
Nesta aula, você:
• Identificou os conceitos de tratamentos de exceções;
• Criou e manipulou interfaces gráficas com objetos e classes efetuando o tratamento de exceções;
• Associou classes e manipulou objetos associados;
• Desenvolveu e executou pequenos programas com orientação a objetos e tratamento de exceções.
•
•
•
•
•
•
•
•
- -1
LINGUAGEM DE PROGRAMAÇÃO
MANIPULAÇÃO DE MODELO DE CLASSES 
EM INTERFACES GRÁFICAS
- -2
Olá!
Ao final desta aula, você será capaz de:
1. Implementar interfaces gráficas para controlar objetos do modelo;
2. Utilizar tratamento de exceção;
3. Utilizar tratamento de eventos;
4. Utilizar interfaces gráficas interagindo com objetos e classes previamente definidos;
5. Explorar todos os conceitos abordados no curso em exemplos e exercícios.
1 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 classes do negócio. Neste exemplo, só iremos aplicar todos os