Slides Linguagem de Programação I

Prévia do material em texto

Linguagem de Programação I
Engenharia da Computação
UNOESC ‐ Joaçaba
Guilherme Rossetti Anzollin
guianzollin@gmail.com
1. Conceitos de linguagens de programação, a tecnologia Java e o ambiente
de desenvolvimento integrado NetBeans IDE.
2. Classes, objetos, atributos, métodos e outros conceitos básicos de OO.
3. Tipos de dados e identificadores, operadores.
4. Entrada e Saída.
5. Comandos de decisão, repetição e desvio.
6. Arrays.
7. Tratamento e lançamento de exceções.
8. Collections como estrutura de dados.
9. Interface gráfica com SWING.
Linguagem de Programação I ‐ Conteúdo
Três avaliações de A1 sendo:
1. Prova individual e sem consulta sobre o conteúdo parcial (25%).
2. Trabalho em grupo desenvolvido e apresentado em sala de aula (25%).
3. Prova individual e sem consulta abrangendo todo o conteúdo
apresentado nas aulas (50%).
O aluno que obter média de A1 maior ou igual a 7,0 estará aprovado.
O aluno que obter média de A1 maior ou igual a 4,0 e menor que 7,0
deverá prestar avaliação de A2, que será uma prova individual e sem
consulta abrangendo todo o conteúdo apresentado nas aulas.
O aluno que obter média de A1 menor que 4,0 estará reprovado.
Linguagem de Programação I ‐ Avaliação
CORMEM, T. H. [et. al], Algoritmos: teoria e prática. 2ed. Rio de Janeiro: Elsevier, 2002.
GOODRICH, M. Estruturas de dados e algoritmos em Java. 2ed. Porto Alegre: Bookman, 2002.
MANZANO & OLIVIERA. Estudo Dirigido de Algoritmos. São Paulo: Érica, 1997.
MANZANO, J. A N. G. Lógica estruturada para programação de computadores. São Paulo: Érica,
2001.
PREISS, B. R. Estruturas de Dados e Algoritmos: padrões e projetos orientados a objetos com
JAVA. Rio de Janeiro: Campus, 2002.
PUGA, S. Lógica de programação e estrutura de dados: com aplicativos em Java. São Paulo:
Pearson Education, 2004.
DEITEL, H. M.; DEITEL, P. J. Java: como programar. 6. ed. São Paulo: Pearson Prentice Hall, 2005.
Oracle Corporation. Java SE Documentation. Diponível em:
<http://www.oracle.com/technetwork/java/javase/documentation/>. Acesso em: 18 julho 2011.
Linguagem de Programação I ‐ Referências
1. Conceitos de linguagens de 
programação, a tecnologia Java 
e o ambiente de 
desenvolvimento integrado 
NetBeans IDE
Método padronizado para expressar instruções para
um computador.
Permite ao programador especificar sobre quais
dados o computador vai operar, como eles serão
armazenados e quais ações serão tomadas em cada
possível circunstância.
Uma linguagem pode ser traduzida basicamente por
interpretação ou compilação.
Linguagem de Programação
O programa vai sendo traduzido a medida que vai
sendo executado.
Geralmente mais lentas que as compiladas porém
mais flexíveis pela interação imediata com o
ambiente.
Exemplos: JavaScript, PHP, Pearl, Python.
Linguagem de Programação Interpretada
O programa todo é traduzido em um código mais
próximo da máquina e só depois executado.
Exemplos: C, Pascal, Delphi, Java (utiliza máquina
virtual para executar).
Linguagem de Programação Compilada
Linguagem de alto nível compilada (C++, Java)
Instruções de maneira abstrata usando variáveis, mais legíveis pelo programador, uma 
instrução em linguagem de alto nível pode requerer várias em linguagem de 
máquina.
Linguagem de Montagem (Assembly Language)
Instruções simbólicas para linguagem de máquina, legíveis para o programador, cada 
instrução em linguagem de montagem representa uma instrução em linguagem 
de máquina.
Linguagem de Máquina (Binário)
Instruções da maneira mais básica, em formato binário, envolvendo movimentações 
de dados para registradores.
compilador
montador
Linguagem de Programação Compilada
Linguagem de alto nível compilada (C++, Java)
X = X+Y;
Linguagem de Montagem (Assembly Language)
ADD X, Y
Representação em Linguagem de Máquina 
0011 000100 110001
Linguagem de Programação Compilada
No início dos anos 90 a Sun Microsystems iniciou um projeto (The
Green Project) para desenvolver soluções tecnológicas prevendo
a convergência dos computadores com equipamento utilizados no
dia‐a‐dia (eletrodomésticos por exemplo).
Liderado por James Gosling, o Grenn Team desenvolveu um
projeto chamado *7 (StarSeven), um equipamento com a
habilidade de controlar diversos dispositivos e aplicações. A
linguagem de programação desenvolvida para o *7 foi chamada
de Oak
Como o mercado de dispositivos não aderiu a tecnologia (não
estava pronto), a ideia foi adequada para a internet que estava
em plena ascensão
A tecnologia Java
Em 1995 foi então lançado o Java 1.0 com o objetivo de
transformar o browser que até então só renderizava HTML em
uma aplicação para realizar operações (applet). O navegador
Netscape passaria então a incorporar a tecnologia Java.
Em 2009 a Oracle adquiriu a Sun e continuou fortalecendo a
marca Java.
Atualmente Java não está somente presente na web e applet não
é a principal aplicação da tecnologia. Desde celulares e diversos
tipos de dispositivos portáteis a jogos, sistemas de navegação a
sistemas de informação empresariais, Java está em todo lugar!
A tecnologia Java
Edições do Java
• JSE ‐ Java Standard Edition ‐ inclui o ambiente de execução e as
bibliotecas básicas de desenvolvimento.
• JEE ‐ Java Enterprise Edition ‐ voltada para desenvolvimento de
aplicações corporativas incluindo bibliotecas especialmente
desenvolvidas para o acesso a servidores, a sistemas de e‐mail, a
banco de dados, entre outros recursos.
• JME ‐ Java Micro Edition ‐ voltada para desenvolvimento de
aplicativos móveis ou portáteis.
Como funciona a tecnologia Java
• Ambiente de desenvolvimento (JDK ‐ Java Development Kit)
• Ambiente de Execução (JRE ‐ Java Runtime Environment)
– Máquina Virtual (JVM – Java Virtual Machine)
– Biblioteca de classes
JRE
JDK
• Compilador
• Documentação
• Bibliotecas de
desenvolvimento
Como funciona a tecnologia Java
Outra linguagem (Delphi, C++, VB)
Windows Linux Celular
Compilador 
Código fonte
Compilador Java
Windows Linux Celular
Código fonte
MV windows MV linux MV celular
bytecode
Tecnologia Java
Executável Descrição
java Executa programas Java
javac Compila programas Java
javadoc Gera documentação pelos coment
jar Compacta em um único arquivo
javap Mostra o código de um .class
jdb Debug de programas Java
Appletviewer Visualizar applets sem navegador
Algumas ferramentas
Ciclo de Desenvolvimento em Java
.java
javac
(compilar)
java
(executar)
Programa .class
O compilador javac
• javac  <opções>  arquivo.java
• Exemplo:
– javac  Exemplo.java 
Opções do compilador javac
• ‐ classpath: Especifica o caminho para as classes / bibliotecas. 
• ‐ cp: [caminho] Especifica o caminho para as classes / bibliotecas. 
• ‐ d: [dir] Diretório para armazenar os arquivos compilados. 
• ‐ source: Localização dos fontes para serem compilados. 
• ‐ deprecation: Advertência para funções que não devem ser utilizadas. 
• ‐ g: Compila com tabelas de debug. 
• ‐ nowarn: Desativa as mensagens de warning. 
• ‐ verbose: Mostra detalhes da compilação. 
• ‐ depend: Compila todos os fontes, incluindo suas dependências. 
• ‐ target: Especifica a versão da JVM que irá executar o programa. 
• ‐ O: Otimização de código para gerar programas mais rápidos. 
• ‐ version: Informa a versão do javac. 
• ‐ help: Pequena ajuda com lista de opções. 
• ‐ X: Opções avançadas de compilação. 
• ‐ J: Passa um parâmetro fixo para o interpretador. 
O interpretador java
• java  <opções>  arquivo.class 
• java  <opções>  ‐ jar  arquivo.jar
• Exemplo:
– java  Exemplo
– java  ‐jar  Exemplo
Opções do interpretador java
• ‐ classpath: Especifica o caminho para as classes / bibliotecas.• ‐ cp: Especifica o caminho para as classes / bibliotecas. 
• ‐ verbose: Mostra detalhes da compilação. 
• ‐ version: Informa a versão do javac. 
• ‐ help: Pequena ajuda com lista de opções. 
• ‐ X: Opções avançadas de interpretação. 
• ‐ Xdebug: Permite o uso do depurador. 
• ‐ D =: Definição de propriedades com a chave nome = valor. 
Exemplo de código para teste
class Exemplo{
public static void main(String[] args){
System.out.print("Hello world");
}
}
Exemplo.java
2. Classes, objetos, atributos, 
métodos e outros conceitos 
básicos de OO
Programação Orientada a Objetos
A linguagem Java segue o paradigma de programação orientada a
objetos (POO), neste paradigma o programa se organiza na forma
de uma coleção de objetos que possuem estrutura e
comportamentos próprios, relacionando‐se entre si por
características em comum, afinal todos são objetos.
A grande diferença com o paradigma mais tradicional, de
programação estruturada ou procedural, é que neste as estruturas
de dados e rotinas são desenvolvidas de forma fracamente
acopladas.
Classes e Objetos
Uma classe é onde define‐se um objeto. Através da definição de
uma classe descreve‐se que propriedades o objeto terá (seus
atributos) e seu comportamento (métodos).
class Conta{
int numero;
String titular;
float saldo;
void sacar(){
}
void depositar(){
}
void consultarSaldo(){
}
}
Classes e Objetos
Objetos são instâncias de classes. É através deles que
(praticamente) todo o processamento ocorre em sistemas
implementados com linguagens de programação orientadas a
objetos.
class Programa{
public static void main(String[] args){
Conta conta1 = new Conta(); 
conta1.numero = 1;
conta1.titular = "Pedro";
conta1.saldo = 100;
conta1.sacar();
conta1.consultarSaldo();
} 
}
Atributos e Métodos
O conjunto de atributos descreve as propriedades da classe. Cada
atributo é identificado por um nome e tem um tipo associado.
Em uma linguagem de programação orientada a objetos pura, o
tipo seria nome de uma outra classe. Na prática, a maior parte das
linguagens de programação orientada a objetos oferecem um
grupo de tipos primitivos (int, float, char, etc...).
class Conta{
int numero; // int: tipo primitivo
String titular; // String: classe
float saldo;
...
}
Atributos e Métodos
Os métodos definem as funcionalidades da classe, ou seja, o que
será possível fazer com objetos dessa classe.
Cada método é especificado por uma assinatura, composta por um
identificador para o método (o nome do método), o tipo para o
valor de retorno e sua lista de argumentos, sendo cada argumento
identificado por seu tipo e nome.
class Conta{
...
void sacar(float valor){
this.saldo = this.saldo - valor;
}
}
Atributos e Métodos
Uma classe pode ter vários métodos com o mesmo nome mas com
assinaturas diferentes, recebendo diferentes argumentos. Isto é
conhecido como sobrecarga ou overloading.
class Conta{
...
// sem receber argumentos/parâmetros
void sacar(){
}
// recebendo o valor do saque
void sacar(float valor){
this.saldo = this.saldo - valor;
}
}
Modificadores de Acesso
Modificadores de acesso (ou de visibilidade) são aplicados a
atributos e métodos para definir se os mesmos poderão ser
acessados ou não a partir de outras classes.
• public: torna os atributos e métodos acessíveis a partir de
qualquer classe.
• private: torna os atributos e métodos acessíveis somente
dentro da própria classe.
• protected: torna os atributos e métodos acessíveis somente
dentro da própria classe e de classes derivadas da mesma
(herança).
Modificadores de Acesso
class Conta{
// atributos privados
private int numero;
private String titular;
private float saldo;
// métodos públicos
public void sacar(float valor){
this.saldo = this.saldo - valor;
}
public void depositar(float valor){
this.saldo = this.saldo + valor;
}
public void consultarSaldo(){
System.out.print(this.saldo);
}
}
Modificadores de Acesso
class Programa{
public static void main(String[] args){
Conta conta1 = new Conta(); 
// não é mais possível acessar 
// diretamente os atributos
// pois são private
conta1.numero = 1;
conta1.saldo = 100;
conta1.titular = "Pedro";
// é possível acessar os métodos 
// pois são public
conta1.consultarSaldo();
} 
}
Getters e Setters
A POO manda tornar atributos e métodos o mais privados possível
para seguir um de seus principais conceitos: o encapsulamento.
Encapsulamento significa separar o programa em partes onde só é
visível o que é necessário em cada uma das partes.
Se os atributos de uma classe devem ser privados (private) o único
meio de acessá‐los é pelos métodos da classe.
São criados então métodos para atribuir valores aos atributos (set)
e para acessar os valores dos mesmos (get).
Getters e Setters
class Conta{
private int numero;
private String titular;
private float saldo;
// Método set para o atributo número
public void setNumero(int numero){
this.numero = numero;
}
// Método get para o atributo numero
public int getNumero(){
return this.saldo;
}
...
}
class Programa{
public static void main(String[] args){
Conta conta1 = new Conta(); 
// Atribuindo o valor “1” para o 
// atributo “numero”
conta1.setNumero(1);
// Acessando o valor do
// atributo “numero” e imprimindo
System.out.print(conta1.getNumero()); 
} 
}
Getters e Setters
Construtor
Ao construir um objeto chamamos a palavra reservada new.
Sempre quando o new é chamado ele executa o construtor da
classe, que é um bloco declarado com o mesmo nome da classe
(não é um método).
Quando não é declarado um construtor em uma classe o Java cria
um construtor padrão que não recebe nenhum parâmetro e seu
corpo é vazio.
A ideia é utilizar o construtor para inicializar os atributos quando é
criado um objeto.
class Conta{
private int numero;
private String titular;
private float saldo;
// Construtor
Conta(int numero, String titular, float
saldo){
this.numero = numero;
this.titular = titular;
this.saldo = saldo;
}
...
}
Construtor
class Programa{
public static void main(String[] args){
// Construindo um objeto e já 
// passando o valor dos atributos 
Conta conta1 = new Conta(1, "Pedro", 
100); 
}
}
Construtor
Herança
Herança é um meio de relacionamento entre duas classes sendo
que uma herda os atributos e métodos da outra.
class ContaCorrente extends Conta{
private float limite;
// Construtor da subclasse
ContaCorrente(int numero, String
titular, float saldo, float limite){
// Chamando o construtor da 
// superclasse (Conta)
super(numero,titular,saldo);
// Atributo da subclasse
this.limite = limite;
}
...
}
Reescrita/Sobrescrita/Override
Quando uma classe herda um método e altera seu
comportamento.
class ContaCorrente extends Conta{
...
// Sobrescrevendo o método 
// consultarSaldo da superclasse Conta
public void consultarSaldo(){
System.out.print("Saldo da conta 
corrente:");
super.consultarSaldo();
}
}
Polimorfismo
Capacidade de um objeto ser referenciado de várias formas (poli =
muitas, morphos = formas).
class Programa{
public static void main(String[] args){
ContaCorrente conta1 = new
ContaCorrente(1, "Pedro", 100,1000); 
Conta conta2 = conta1;
conta2.consultarSaldo();
// Qual método vai ser chamado?
// O da subclasse ContaCorrente! 
} 
}
Exercício 1
Crie a classe Cliente com os atributos listados abaixo e seus
respectivos métodos getters (responsável pro retornar o valor do
atributo) e setters (responsável por atribuir um valor recebido por
parâmetro ao atributo):
• código
• nome
• endereço
• data de nascimento
Crie uma classe principalonde será instanciado um objeto da
classe Cliente atribuindo valores informados pelo usuário para
todos seus atributos e ao final imprimindo os mesmos.
Exercício 2
Crie as seguintes classes com seus devidos atributos, construtores
e métodos getters e setters:
3. Tipos primitivos, identificadores 
e operadores
Tipos primitivos e identificadores
class Programa{
public static void main(String[] args){
byte inteiro = 1;
int inteiro2 = -100;
long inteiro3 = 10000000;
double decimal = 10.001;
char caractere = 'c';
boolean boleano = true;
}
}
Tipo Identificador Atribuição
Nome Tipo Tamanho
byte Numérico inteiro 8 bits
short Numérico inteiro 16 bits
int Numérico inteiro 32 bits
long Numérico inteiro 64 bits
float Ponto flutuante 32 bits
double Ponto flutuante 64 bits
char Caractere 16 bits
boolean Booleano 8 bits
Tipos primitivos
Casting
Para que um número não inteiro (ou de maior precisão) seja
arredondado e armazenado em um número inteiro (ou de menor
precisão) é necessário que este primeiro seja moldado (casted).
class Programa{
public static void main(String[] args){
double d3 = 3.14;
// casting
int i = (int) d3;
// o código abaixo (sem o casting)
// não iria compilar 
// int i= d3;
} 
}
• Começam com uma letra, underline ou cifrão;
• Após o primeiro dígito podem conter números;
• Java é case sensitive, então existe diferença entre maiúsculo e 
minúsculo;
• Palavras reservadas  (class, int, public, this ...) não podem ser 
identificadores.
Identificadores
Aritméticos unários
Operador Nome Uso
++ Incremento id++;
‐‐ Decremento id‐‐;
‐ Negativo ‐id;
+ Positivo +id;
Operadores
Aritméticos sobre duas variáveis
Operador Nome Uso
+ Adição id1 + id2 ;
‐ Subtração id1 ‐ id2 ;
* Multiplicação id1 * id2 ;
/ Divisão id1 / id2 ;
% Resto id1 % id2 ;
Operadores
Relacionais e Lógicos
Operador Nome Uso
> Maior id1 > id2 ;
< Menor id1 < id2 ;
>= Maior ou igual id1 >= id2 ;
<= Menor ou igual id1 <= id2 ;
== Igual id1 == id2 ;
!= Diferente id1 != id2 ;
! Não lógico (NOT) !id1 ;
&& E lógico (AND) id1 && id2 ;
|| OU lógico (OR) id1 || id2 ;
instanceof Instância de Obj instanceof Classe
Operadores
Exercício 3
Criar a classe Calculo implementando os seguintes métodos para
calcular as operações aritméticas básicas:
• soma –recebendo dois valores e retornando a soma;
• subtrai ‐ recebendo dois valores e retornando a diferença;
• multiplica ‐ recebendo dois valores e retornando o produto;
• divide ‐ recebendo dois valores e retornando a divisão;
• inverteSinal ‐ recebendo um valor e invertendo seu sinal.
Criar a classe Principal com o método main acessando os métodos
da classe Calculo.
4. Entrada e Saída
Entrada e Saída
Entende‐se por entrada e saída o conjunto de mecanismos
oferecidos para que um programa consiga, respectivamente, obter
e fornecer informações de dispositivos externos ao seu ambiente
de execução.
Havendo um dispositivo de entrada de dados habilitado (um
teclado por exemplo), o programa obtém dados deste dispositivo
através de uma operação leitura.
Da mesma fora, um dado pode ser enviado para um dispositivo de
saída habilitado (um monitor por exemplo) através de uma
operação escrita.
A classe System
Pertencente ao pacote java.lang, único pacote que por padrão já é
importado em todas as classes.
Dentre seus atributos existem o in, utilizado para entrada/leitura
de bytes, e o out, utilizado para saída/escrita.
class Programa{
public static void main(String[] args) 
throws Exception{
int i = System.in.read();
System.out.print(i); 
} 
}
O pacote java.io
O pacote java.io possui classes que definem o comportamento
padrão dos fluxos de entrada (InputStream) e saída
(OutputStream).
import java.io.*;
class Programa{
public static void main(String[] args) 
throws Exception{
InputStream is= System.in; 
System.out.print(is.read()); 
} 
}
O pacote java.io
Para recuperar os caracteres é necessário traduzir os bytes lidos de
um fluxo de entrada. Existe a classe InputStreamReader que
oferece tal funcionalidade. Além de utilizar InputStreamReader
para manipular o byte lidos pode‐se usar também a classe
BufferedReader para concatenar os caracteres e formar uma string
através do método readLine.
import java.io.*;
class Programa{
public static void main(String[] args) throws
Exception{
InputStream is = System.in;
InputStreamReader isr = new InputStreamReader(is);
BufferedReader br = new BufferedReader(isr); 
System.out.print(br.readLine());
} 
}
O pacote java.io
Para ler bytes de um arquivo, por exemplo, utiliza‐se uma classe
filha de InputStream chamada FileInputStream para construir o
objeto ao invés do atributo System.in.
import java.io.*;
class Programa{
public static void main(String[] args) throws
Exception{
InputStream is = new FileInputStream( 
"c:\\arquivo.txt");
InputStreamReader isr = new InputStreamReader(is);
BufferedReader br = new BufferedReader(isr); 
System.out.print(br.readLine());
} 
}
O pacote java.io
Realizando o processo inverso para escrever em um arquivo.
Utilizando BufferedWriter (ao invés de BufferedReader),
OutputStreamWriter (ao invés de InputStreamReader) e
OutputStream (ao invés de InputStream).
import java.io.*;
class Programa{
public static void main(String[] args) throws
Exception{
OutputStream os = new FileOutputStream(
"c:\\saida.txt");
OutputStreamWriter osw = new OutputStreamWriter(os);
BufferedWriter bw = new BufferedWriter(osw);
bw.write("teste de saída/escrita");
bw.close();
} 
}
A classe Scanner
A partir do Java 5 pode‐se utilizar a classe Scanner do pacote
java.util para entrada/leitura. Esta classe possui métodos
específicos para ler cada tipo de dados.
import java.util.*;
class Programa{
public static void main(String[] args){
Scanner s = new Scanner(System.in);
String x = s.next();
int y = s.nextInt();
float z = s.nextFloat();
System.out.println(x+y);
System.out.println(y+z);
} 
}
Exercício 4
Criar a classe Contato (ao lado).
Criar uma classe principal onde é
instanciado um objeto da classe
Contato e setados para os atributos
valores informados pelo usuário.
Ao final as informações do objeto
devem ser salvas em um arquivo
chamado contato.txt.
5. Comandos de decisão, 
repetição e desvio.
Comandos de Decisão
O comando if / else.
class Programa{
public static void main(String[] args){
int var = 1;
if(var > 0){
System.out.print("var é maior que 0");
}
else{
System.out.print("var é menor ou igual a 0");
} 
} 
}
Comandos de Decisão
O comando switch / case.
class Programa{
public static void main(String[] args){
int var = 1;
switch(var){
case 1:
System.out.print("var é igual a 1");
break;
case 2:
System.out.print("var é igual a 2");
break;
default: 
System.out.print("var é diferente de 1 e 2");
} 
} 
}
Comandos de Repetição
O comando while.
class Programa{
public static void main(String[] args){
int var = 1;
while(var < 10){
System.out.println(var);
var++;
}
} 
}
Comandos de Repetição
O comando do / while.
class Programa{
public static void main(String[] args){
int var = 1;
do{
System.out.println(var);
var++;
}while(var < 1);
} 
}
Comandos de Repetição
O comando for.
class Programa{
public static void main(String[] args){
for(int i=0 ; i<10 ; i++){
System.out.println(i);
}
} 
}
Comandos de Desvio
O comando break.
class Programa{
public static void main(String[] args){
for(int i=0 ; i<10 ; i++){
if( i == 5 ) 
break;
System.out.println(i);
}
} 
}Comandos de Desvio
O comando continue.
class Programa{
public static void main(String[] args){
for(int i=0 ; i<10 ; i++){
if( i == 5 ) 
continue;
System.out.println(i);
}
} 
}
Exercício 5
Criar a classe Pessoa (abaixo).
Exercício 5
O método situacao() deve calcular o IMC conforme a fórmula
abaixo:
IMC =  peso / (altura)²
O retorno do método deve ser uma string informando:
• Abaixo do peso: Se o IMC estiver abaixo de 19,1 para o sexo 
feminino e abaixo de 20,7 para o sexo masculino.
• Peso ideal: Se o IMC estiver entre 19,1 e 25,8 para o sexo 
feminino e entre 20,7 e 26,4 para o sexo masculino.
• Acima do peso: Demais situações.
Exercício 6
Criar a classe Calculo (abaixo).
Criar uma classe principal onde é instanciado um objeto da classe
Calculo e perguntado ao usuário (em forma de um menu de opções)
qual dos quatro métodos ele deseja chamar. Escolhido o método
deve‐se perguntar também quais os parâmetros para sua chamada.
.
6. Arrays
Arrays
Arrays são objetos que armazenam uma coleção de
elementos. Tais elementos podem ser variáveis de tipos primitivos
ou objetos.
class Programa{
public static void main(String[] args){
// declara um array de inteiros e aloca memória 
// para 2 inteiros
int[] meuArray = new int[2];
meuArray[0] = 100; // inicializa a 1ª posição
meuArray[1] = 200; // inicializa a 2ª posição
System.out.println("Posição 0: " + meuArray[0]);
System.out.println("Posição 1: " + meuArray[1]);
} 
}
Arrays
Os índices de um array variam de 0 até n‐1, sendo n o tamanho
dado na criação do array.
Ao tentar acessar uma posição fora desse alcance ocorre um erro.
class Programa{
public static void main(String[] args){
// declara um array de inteiros com 2 posições
int[] meuArray = new int[2];
// tenta atribuir um valor para a 3º posição
meuArray[2] = 100;
} 
}
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException …
Arrays
Quando é criado um array de uma classe, nele só ficam guardadas
referências.
Considere a classe abaixo.
public class Conta{
private double saldo;
public Conta(double saldo) {
this.saldo = saldo;
}
public double getSaldo() {
return saldo;
}
}
Arrays
Criando um array para objetos da classe Conta.
class Programa{
public static void main(String[] args){
// array para referenciar 3 objetos de Conta
Conta[] contas = new Conta[3]; 
// criando um objeto de Conta e atribuindo a 
// 2ª posição do array
Conta conta1 = new Conta(1000.00);
contas[1] = conta1;
System.out.print(contas[1].getSaldo());
} 
}
Arrays
Foi criado um array de 3 posições sendo que somente uma delas
(a segunda) está referenciando um objeto.
null
null
contas
conta1
Conta
saldo
1000.00
Um array de tipos primitivos guarda valores, um array de objetos 
guarda referências.
Arrays
Percorrendo um array.
class Programa{
public static void main(String[] args){
int[] numeros= new int[10];
// atribuindo valores para as posições do array
for (int i=0 ; i<10 ; i++){
numeros[i] = i* 10;
}
// lendo valores das posições do array
for (int i=0 ; i<numeros.length ; i++){
System.out.println(numeros[i]);
}
} 
}
Arrays
Percorrendo um array com duas dimensões.
class Programa{
public static void main(String[] args){
int[][] matriz = new int[5][5];
for(int i=0 ; i<5 ; i++){
for(int j=0 ; j<5 ; j++){
matriz[i][j] = i+j;
System.out.println(
"matriz["+i+"]["+j+"]: "+matriz[i][j]);
}
}
} 
}
Arrays
Percorrendo um array com duas dimensões.
matriz[0][0]
0 + 0 = 0
matriz[0][1]
0 + 1 = 1
matriz[0][2]
0 + 2 = 2
matriz[0][3]
0 + 3 = 3
matriz[0][4]
0 + 4 = 4
matriz[1][0]
1 + 0 = 1
matriz[1][1]
1 + 1 = 2
matriz[1][2]
1 + 2 = 3
matriz[1][3]
1 + 3 = 4
matriz[1][4]
1 + 4 = 5
matriz[2][0]
2 + 0 = 2
matriz[2][1]
2 + 1 = 3
matriz[2][2]
2 + 2 = 4
matriz[2][3]
2 + 3 = 5
matriz[2][4]
2 + 4 = 6
matriz[3][0]
3 + 0 = 3
matriz[3][1]
3 + 1 = 4
matriz[3][2]
3 + 2 = 5
matriz[3][3]
3 + 3 = 6
matriz[3][4]
3 + 4 = 7
matriz[4][0]
4 + 0 = 4
matriz[4][1]
4 + 1 = 5
matriz[4][2]
4 + 2 = 6
matriz[4][3]
4 + 3 = 7
matriz[4][4]
4 + 4 = 8
Exercício 7
Crie uma classe principal onde será declarado um array de objetos
da classe Conta (do exemplo anterior) sendo que o tamanho deste
array deve ser informado pelo usuário.
Para cada posição do array deve ser referenciado um objeto da
Classe conta e o valor do atributo saldo de cada objeto deve ser
informado pelo usuário.
Ao final, o programa deve imprimir cada posição do array e o valor
do atributo saldo do objeto referente a cada posição.
7. Tratamento e lançamento de 
exceções
Erros ou situações anormais que não podem ser verificadas na
compilação do programa.
Quando ocorre uma exceção e a mesma não está sendo tratada no
código fonte o programa é abortado/encerrado.
A maioria das classes utilizadas para o tratamento de exceções são
encontradas no pacote java.lang.
Exceções
• Exception: Para qualquer tipo de exceção;
• ArithmeticException: Erros em processamento aritmético;
• NumberFormatException: Conversão inadequada de uma
string para um numérico;
• ClassNotFoundException: Classe não encontrada durante a
execução do programa;
• IndexOutOfBounds: Tentativa de acessar um elemento além
do limite de uma estrutura/array.
Exemplo de classes para o tratamento de 
exceções
• IOException: Erros em operações de Entrada e Saída, pacote
java.io;
• FileNotFoundException: Arquivo não encontrado, pacote java.io;
• EOFException : Fim de arquivo encontrado;
Exemplo de classes para o tratamento de 
exceções
Problemas provocados por código mal escrito ou mal testado,
acontecem em tempo de execução do programa:
• Uma divisão por zero
• Acesso a uma posição inválida de um array
O compilador java NÃO EXIGE que tais exceções sejam tratadas no
código.
Vindas de java.lang.RuntimeException, por exemplo,
IndexOutOfBoundsException, ArithmeticException.
Exceções de Tempo de Execução –
Runtime Exceptions / Unchecked
Problemas que não dependem da lógica do programa, por
exemplo:
• Um arquivo não encontrado
• Uma impressora que parou de responder
• A rede que caiu
O compilador java EXIGE que tais exceções sejam tratadas no
código.
Vindas de java.lang.Exception, por exemplo,
ClassNotFoundException, FileNotFoundException , IOException.
Exceções Verificadas – Checked Exceptions
Problemas causados pela máquina virtual do JAVA:
• Não é mais possível criar um objeto porque não há mais
memória disponível
Em 99% dos casos não devem ser tratados. Caso aconteça o
programa deve ser mesmo encerrado e alternativas devem ser
bucadas para solução do problema.
Vindas de java.lang.Error, por exemplo, OutOfMemoryError.
Erros – Errors
Tratamento da exceção no próprio método em que ela pode
ocorrer.
• try : tenta executar os comandos que podem gerar a
exceção;
• catch : decide o que fazer se uma determinada exceção
ocorrer (tratamento) ;
• finally : decide o que fazer se a exceção que ocorrer não
estiver sendo tratada em nenhum catch.
Tratamento try / catch
Exemplo sem tratamento de exceção
Exception in thread "main" java.lang.ArithmeticException: / by 
zero
public void imprimeDivisao(){
int x = 2;
int y = 0;
System.out.print( x/y );
}
Tratamento try / catch
Exemplo com tratamento de exceção
public void imprimeDivisao(){
int x = 2;
int y = 0;
try{
System.out.print( x/y );
}
catch(java.lang.ArithmeticException e){
System.out.print("Ocorreu uma divisão por zero"); 
}
}
Tratamento try / catch
O comando throws indica que o tratamento da exceção deve
ocorrer no método que chamar aquele em que ela pode
acontecer.Tratamento throws
import java.io.*;
public class Entrada{
public String lerDados() throws IOException{
InputStream is = System.in;
InputStreamReader isr = new InputStreamReader(is);
BufferedReader br = new BufferedReader(isr); 
return br.readLine();
}
}
Tratando a exceção com try / cacth na chamada do método.
Tratamento throws
class Programa{
public static void main(String[] args){
Entrada entrada = new Entrada();
String retorno = new String("");
try{
retorno = entrada.lerDados();
}
catch(java.io.IOException e){
System.out.print("Ocorreu um problema na 
entrada de dados.");
}
} 
}
Retorna a mensagem padrão da exceção ocorrida.
O método getMessage()
class Programa{
public static void main(String[] args){
Entrada entrada = new Entrada();
String retorno = new String("");
try{
retorno = entrada.lerDados();
}
catch(java.io.IOException e){
System.out.print("Ocorreu um problema na 
entrada de dados: "+e.getMessage());
}
} 
}
Através do comando throw (diferente de throws) pode‐se lançar
uma exceção a partir de uma determinada situação.
class Pessoa{
public String nome;
public void setNome(String nome){
if(nome.equals("")){
throw new IllegalArgumentException("O nome
não pode ser em branco.");
}
this.nome = nome;
}
}
Lançamento de exceções
Tratando a exceção que será lançada.
class Programa{
public static void main(String[] args){
Pessoa pessoa = new Pessoa();
try{
pessoa.setNome("");
}
catch(IllegalArgumentException e){
System.out.print(e.getMessage());
}
} 
}
Lançamento de exceções
Criar a classe Divisao com os métodos divisao1 e divisao2, ambos
recebendo dois valores e retornando o resultado da divisão porém
com a seguinte diferença:
• divisao1 tratará a exceção usando throws, assim quando for
chamado deverá ser usado try / catch;
• divisao2 tratará a exceção usando throw e informando uma
mensagem personalizada de erro;
Criar a classe Principal solicitando que o usuário entre com dois
números (utilizando BufferedReader / InputStreamReader) e
calculando a divisão usando os métodos da classe Divisao. Simular a
divisão por zero.
Exercício 8
8. Collections como estrutura de 
dados
Porquê não utilizar somente arrays para criar estruturas de
dados?
– Não podemos redimensionar um array;
– Não podemos buscar diretamente um elemento se não
soubermos seu índice;
– Apesar de sabermos o tamanho do array (size) não podemos
saber quantas posições do array já foram populadas sem criar
métodos auxiliares.
Collections como estrutura de dados
O Collections Framework (java.util.Collection) é um conjunto de
classes e interfaces para representarem estruturas de dados mais
avançadas.
Collections como estrutura de dados
Collection
Map
Set List Queue
Interface genérica que não possui implementação, possui métodos
comuns a todas as coleções.
– int size()
– boolean isEmpty()
– boolean contains (Object elemento)
– boolean add (Object elemento)
– boolean remove (Object elemento)
– boolean containsAll (Collection c)
– boolean addAll (Collection c)
– boolean removeAll (Collection c)
Collection
Conceito de conjunto, não permite duplicidade.
Implementações: HashSet, TreeSet.
import java.util.*;
public class Exemplo{
public static void main(String args[]) {
Set<String> set = new HashSet<String>();
set.add("B");
set.add("A");
set.add("C");
System.out.println(set);
set.add("A");
System.out.println(set);
}
}
Interface Set
Garantindo a ordem de inserção: LinkedHashSet.
Interface Set
import java.util.*;
public class Exemplo{
public static void main(String args[]) {
Set<String> set = new LinkedHashSet<String>();
set.add("B");
set.add("A");
set.add("C");
System.out.println(set);
set.add("A");
System.out.println(set);
}
}
Ordenação crescente/alfabética : TreeSet.
Interface Set
import java.util.*;
public class Exemplo{
public static void main(String args[]) {
Set<String> set = new TreeSet<String>();
set.add("B");
set.add("A");
set.add("C");
System.out.println(set);
set.add("A");
System.out.println(set);
}
}
Removendo elemento: remove(elemento).
Interface Set
import java.util.*;
public class Exemplo{
public static void main(String args[]) {
Set<String> set = new TreeSet<String>();
set.add("B");
set.add("A");
set.add("C");
System.out.println(set);
set.remove("A");
System.out.println(set);
}
}
Conceito de lista, permite duplicidade.
Implementações: ArrayList (não é um array), LinkedList.
import java.util.*;
public class Exemplo{
public static void main(String args[]) {
List<String> lista = new ArrayList<String>();
lista.add("B");
lista.add("A");
lista.add("C");
System.out.println(lista);
lista.add("A");
System.out.println(lista);
}
}
Interface List
Removendo um elemento – remove(elemento).
import java.util.*;
public class Exemplo{
public static void main(String args[]) {
List<String> lista = new ArrayList<String>();
lista.add("B");
lista.add("A");
lista.add("C");
System.out.println(lista);
lista.remove("A");
System.out.println(lista);
}
}
Interface List
Acessando um elemento – get(indice).
import java.util.*;
public class Exemplo{
public static void main(String args[]) {
List<String> lista = new ArrayList<String>();
lista.add("B");
lista.add("A");
lista.add("C");
System.out.println(lista);
System.out.println("Elemento 0:"+lista.get(0));
System.out.println("Elemento 1:"+lista.get(1));
}
}
Interface List
Conceito de fila, permite duplicidade
Sem parâmetros, remove/acessa sempre o primeiro elemento
import java.util.*;
public class Exemplo{
public static void main(String args[]) {
Queue<String> lista = new LinkedList<String>();
lista.add("B");
lista.add("A");
lista.add("C");;
System.out.println(lista);
lista.remove();
System.out.println(lista);
System.out.println(lista.element());
}
}
Interface Queue
Conceito de chave‐valor.
Implementações: HashMap, TreeMap.
import java.util.*;
public class Exemplo{
public static void main(String[] args) {
Map map = new HashMap();
map.put(1,"A");
map.put(3,"C");
map.put(2,"B");
map.put(4,"D");
System.out.println(map);
}
}
Interface Map
Garantindo a ordem de inserção: LinkedHashMap.
Interface Map
import java.util.*;
public class Exemplo{
public static void main(String[] args) {
Map map = new LinkedHashMap();
map.put(1,"A");
map.put(3,"C");
map.put(2,"B");
map.put(4,"D");
System.out.println(map);
}
}
Ordenação crescente: TreeMap.
Interface Map
import java.util.*;
public class Exemplo{
public static void main(String[] args) {
Map map = new TreeMap();
map.put(1,"A");
map.put(3,"C");
map.put(2,"B");
map.put(4,"D");
System.out.println(map);
}
}
Removendo elemento pela chave – remove(chave).
import java.util.*;
public class Exemplo{
public static void main(String[] args) {
Map map = new TreeMap();
map.put(1,"A");
map.put(3,"C");
map.put(2,"B");
map.put(4,"D");
System.out.println(map);
map.remove(2);
System.out.println(map);
}
}
Interface Map
Acessando elemento pela chave – get(chave).
import java.util.*;
public class Exemplo{
public static void main(String[] args) {
Map map = new TreeMap();
map.put(1,"A");
map.put(3,"C");
map.put(2,"B");
map.put(4,"D");
System.out.println(map);
System.out.println("Elemento 1:"+map.get(1));
System.out.println("Elemento 2:"+map.get(2));
}
}
Interface Map
Verificando existência de elemento pela chave – containsKey(chave).
import java.util.*;
public class Exemplo{
public static void main(String[] args) {
Map map = new TreeMap();
map.put(1,"A");
map.put(3,"C");
map.put(2,"B");
map.put(4,"D");System.out.println(map);
System.out.println(map.containsKey(1));
System.out.println(map.containsKey(5));
}
}
Interface Map
Verificando existência de elemento pelo valor – containsValue(chave).
import java.util.*;
public class Exemplo{
public static void main(String[] args) {
Map map = new TreeMap();
map.put(1,"A");
map.put(3,"C");
map.put(2,"B");
map.put(4,"D");
System.out.println(map);
System.out.println(map.containsValue("A"));
System.out.println(map.containsValue("X"));
}
}
Interface Map
Criar a classe Exercicio6 criando o seguinte menu:
>> MENU
>>
>> 1 – Incluir registro
>> 2 – Consultar registro
>> 3 – Remover registro
>> 4 – Listar todos os registros
>> 5 - Sair
>>
>> Digite a Opção:
UsarMap armazenando a chave e o nome do registro.
Exercício 9
Descrição das opções do menu:
– Incluir registro: perguntar ao usuário a chave e o nome do 
registro e incluir no map.
– Consultar registro: perguntar ao usuário a chave e imprimir o 
nome do registro, se existir.
– Remover registro: perguntar ao usuário a chave e remover 
registro do map, se existir.
– Listar todos os registros: imprimir todos os registros do map.
– Sair: sair do programa.
Exercício 9
9. Interface gráfica com SWING
SWING é um conjunto de classes (ou framework) implementado para
fornecer componentes de interface gráfica (janelas, botões, imagens,
áreas de texto, etc.)
Interface gráfica com SWING
Criando uma janela (JFrame)
import javax.swing.*;
public class MeuJFrame extends JFrame {
public MeuJFrame(){
// Título do JFrame
this.setTitle("Título");
// Fronteiras (posição X e Y, largura e altura)
this.setBounds(0,0,500,500);
// Ação padrão ao fechar o JFrame
this.setDefaultCloseOperation(EXIT_ON_CLOSE);
// Definição do tipo de layout
this.getContentPane().setLayout(null); 
}
}
Interface gráfica com SWING
Criando uma janela (JFrame)
class Exemplo{
public static void main(String[] args){
MeuJFrame obj = new MeuJFrame();
obj.setVisible(true); 
}
}
Interface gráfica com SWING
Adicionando um rótulo de texto (JLabel)
import javax.swing.*;
public class MeuJFrame extends JFrame {
private JLabel rotulo;
public MeuJFrame(){
...
// Construindo o rótulo de texto
rotulo = new JLabel();
// Setando a descrição do botão
rotulo.setText("Texto"); 
// Fronteiras (posição X e Y, largura e altura)
rotulo.setBounds(10, 10, 100, 30);
// Adicionando rótulo ao JFrame
this.add(rotulo); 
}
}
Interface gráfica com SWING
Adicionando um campo de texto (JTextField)
import javax.swing.*;
public class MeuJFrame extends JFrame {
private JTextField campo;
public MeuJFrame(){
...
// Construindo o campo de texto
campo = new JTextField();
// Fronteiras (posição X e Y, largura e altura)
campo.setBounds(10, 50, 100, 30);
// Adicionando campo ao JFrame
this.add(campo);
}
}
Interface gráfica com SWING
Adicionando um botão (JButton)
import javax.swing.*;
public class MeuJFrame extends JFrame {
private JButton botao; 
public MeuJFrame(){
...
// Construindo o botão
botao = new JButton();
// Setando a descrição do botão
botao.setText("botão"); 
// Fronteiras (posição X e Y, largura e altura)
botao.setBounds(10, 100, 100, 50);
// Adicionando botão ao JFrame
this.add(botao); 
}
}
Interface gráfica com SWING
Criar o seguinte JFrame com seus devidos componentes
Exercício 10
Como os eventos funcionam:
– Todo sistema operacional que suporta interface gráfica monitora
eventos (cliques, movimentos do mouse, teclas pressionadas, etc.)
– Quando um evento acontece o sistema operacional informa ao
programa
– O programa decide o que fazer com o evento de acordo com o que
foi programado
Interface gráfica com SWING ‐ Eventos
São os eventos que controlam todas as interações do usuário com o
programa (cliques, texto digitado, movimentos do mouse, etc.)
Para se trabalhar com eventos no Java a partir dos componentes
SWING podemos utilizar funcionalidades do pacote java.awt.event.
import java.awt.event.*;
Interface gráfica com SWING ‐ Eventos
Cada componente da interface gráfica (janela, botão, campo de texto,
etc.) conta com interfaces para ouvir (listen) quando um evento é
gerado.
Categoria Evento Interface
Janelas Abrir, fechar, minimizar WindowListener
Botões, menus, etc. Pressionar ou selecionar ActionListener
Mouse
Cliques MouseListener
Arrastar ou soltar o clique MouseMotionListener
Teclado Pressionar teclas KeyListener
Foco dos componentes Mudança de foco (tab/enter) FocusListener
Interface gráfica com SWING ‐ Eventos
Cada interface tem métodos associados para tratar os diferentes
eventos.
Interface Método Evento
WindowListener
void windowOpened(WindowEvent e) Quando uma janela é aberta
void windowClosed(WindowEvent e) Quando uma janela é fechada
ActionListener void actionPerformed(ActionEvent e) Quando uma ação ocorre (botão pressionado, item selecionado)
MouseListener
voidmouseClicked(MouseEvent e) Quando o mouse é clicado sobre o componente
voidmouseEntered(MouseEvent e) Quando o mouse entra em um componente
KeyListener void keyPressed(KeyEvent e) Quando uma tecla é pressionada
Interface gráfica com SWING ‐ Eventos
Eventos do pacote java.awt.event:
java.awt.event
java.awt.event.ActionEvent
java.awt.event.AdjustmentEvent
java.awt.event.ComponentEvent
java.awt.event.FocusEvent
java.awt.event.ItemEvent
java.awt.event.KeyEvent
java.awt.event.MouseEvent
java.awt.event.TextEvent
java.awt.event.WindowEvent
Interface gráfica com SWING ‐ Eventos
import javax.swing.*;
import java.awt.event.*;
public class MeuJFrame extends JFrame {
private JButton botao; 
private JTextField campo;
public MeuJFrame(){
this.setTitle("Título");
this.setBounds(0,0,500,500);
this.setDefaultCloseOperation(EXIT_ON_CLOSE);
this.getContentPane().setLayout(null);
...
Interface gráfica com SWING ‐ Eventos
...
botao = new JButton();
botao.setText("botão"); 
botao.setBounds(10, 100, 100, 50);
this.add(botao);
campo = new JTextField();
campo.setBounds(10, 50, 100, 30);
this.add(campo); 
// Adicionando um evento action ao botão
botao.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent evt){
botao.setText(campo.getText());
}
});
} // construtor
} // classe
Interface gráfica com SWING ‐ Eventos
Para o JFrame criado no exercício 10 implementar os eventos
de todos os botões responsáveis por jogar no campo de texto
o valor do botão pressionado.
Exercício 11