Esta é uma pré-visualização de arquivo. Entre para ver o arquivo original
Programação Orientada a Objetos II
(Linguagem Java)
A partir de trechos meus [Jane Tavares A. da Silva - JTAS] e de trechos das
apostilas do Prof. Adriano Caminha [AC], Prof. Francisco Santos [FS]. e da Profa.
Letícia Winkler [LK].
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
1
Bibliografia
Bibliografia básica:
1. DEITEL, H. M.; DEITEL, P. J. Java: Como Programar. 6ª Edição. São Paulo:
Pearson Prentice Hall, 2005.
2. HORSTMANN, Cay; CORNELL, Gary. Core Java 2 – Volume I: Fundamentos.
São Paulo: Pearson Makron Books, 2001.
Bibliografia complementar:
1. CAMARÃO, Carlos; Figueiredo, Lucília. Programação de computadores em
Java. Rio de Janeiro: LTC, 2003
2. HORSTMANN, Cay S. Big Java. Porto Alegre ; Bookman, 2004.
AVISO: Este material não pretende substituir nenhuma outra apostila, e muito menos
qualquer livro.
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
2
1. Introdução
1.1. Paradigmas das linguagens de programação [FS]
A maioria das linguagens de programação são extensas e complexas e
normalmente integram várias idéias. No entanto, cada linguagem baseia-se,
normalmente, numa idéia central, ou paradigma.
Existem 4 paradigmas (principais) de programação:
o Paradigma Imperativo: Baseado em comandos e procedimentos.
Ex.: Pascal, C, Fortran.
o Paradigma OO: Baseado em objetos e classes.
Ex.: Java, Smalltalk, Simula, C++.
o Paradigma Funcional: Baseado em funções.
Ex.: Lisp, ML, Scheme, Haskell.
o Paradigma Lógico: Baseado na lógica de predicados (fatos e regras)
Ex.: Prolog.
Obs: Linguagens de Marcação (HTML) ≠ Linguagens de Programação.
Linguagens de Marcação não especificam computações, elas apenas
descrevem a aparência geral de documentos.
1.2. Fundamentos básicos de programação em Java [FS]
Programação Estruturada x Programação Orientada a Objetos - POO
A principal diferença entre o enfoque tradicional da análise estruturada e o
enfoque da O.O. está na forma pela qual dados e procedimentos se comunicam.
Análise Estruturada
Ênfase nos procedimentos
Comunicação através de passagem de dados (parâmetros)
Programa = execução de procedimentos cuja tarefa é a manipulação de
dados
Análise Orientada a Objetos (AOO)
Dados e procedimentos fazem parte de um só elemento básico (objeto ou
classe)
Dados e procedimentos encapsulados em um só elemento.
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
3
NOTE :
Programação Estruturada
DADOS + FUNÇÕES
Programação Orientada a Objetos (POO)
Atributos
(dados)
+
Métodos
(funções)
1.3.Vantagens e características da linguagem Java [JTAS]
Java como uma linguagem de programação:
Desenvolvida na década de 90 por James Gosling da Sun
Microsystems
Orientada a Objetos
Independente de plataforma (portável) : Não há aspectos ―dependentes
da implementação‖. Por exemplo: Os tipos primitivos têm tamanhos
determinados .
Uso de recursos de rede
Segurança : Para ser usada em ambientes de rede/distribuídos.
Mecanismos para sistemas livres de vírus e adulterações, pacotes para
criptografia 128 bits, etc. (Não se pode provar que é 100% segura, mas
é certamente a linguagem mais segura até hoje por causa destes
mecanismos)
Simples (sintaxe similar a C/C++)
Internacionalização (UNICODE)
Distribuída e multitarefa : Os programas podem utilizar recursos na
Internet com a mesma facilidade que acessam arquivos locais. Lidam
com TCP/IP, HTTP, FTP.
Carga dinâmica de código : Java foi projetada para se adaptar a um
ambiente em evolução. As bibliotecas podem adicionar livremente
novos métodos e variáveis a qualquer instante (mesmo em execução).
Desalocação automática de memória (garbage collection)
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
4
Java possui 3 tipos de programas, levando em conta como e quando eles são
executados:
Applications: programas stand-alone que englobam todos os recursos
de acesso ao Sistema Operacional. Semelhantes aos programas
convencionais.
Applets: programas que são carregados através de uma rede TCP/IP
de um servidor remoto e são executados localmente pela JVM no
escopo de um browser. A JVM impõe uma série de restrições aos
applets por questões de segurança.
Servlets: programas que são executados remotamente em um servidor
Web através de um servlet container. São usados para gerar conteúdo
dinamicamente.
1.4. Conceitos Básicos em O.O. [FS]
Objeto entidade composta por dados (atributos/características) e
procedimentos para manipulação desses dados(métodos)
Classe objetos com características semelhantes são agrupados em uma
classe. Dados e procedimentos associados a uma classe são chamados de
membros da classe.
Ex. Sistema para informatização de uma loja comercial.
Classe: Funcionário
Objeto: José da Silva
atributos: nome, endereço,data de admissão, salário base, etc.
métodos (procedimentos): calcular salário liquido, mostrar dados, etc.
1.5. Alguns conceitos ERRADOS Sobre JAVA [AC]
- Java é uma extensão do HTML.
- Java é fácil de aprender: 1.500 classes e interfaces, sendo necessário
conhecer muitas delas para se construir programas profissionais.
- Java é um ambiente fácil de programação: existem ambientes gráficos de
programação, mas o melhor caminho para se aprender é um editor simples
como o bloco de notas.
- Java é interpretada, ou seja, lenta para aplicações sérias: isto pode ser
resolvido com o uso de compiladores JIT (Just In Time) que compilam na
primeira vez que a aplicação é usada. Não importa que C++ seja mais rápida,
Java é mais fácil de programar e é portável.
- Todos os programas Java executam dentro de uma página Web.
- Os applets Java são um grande risco à segurança: nenhuma linguagem é
100% segura, mas as falhas estão sendo corrigidas e o risco é muito menor
que o encontrado em controles ActiveX.
- Javascript é a versão mais simples da Java: Javascript foi inventada pela
Netscape e apenas utiliza uma sintaxe parecida com a de Java, nada mais
tem a ver com Java.
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
5
1.6. A Plataforma Java – Características : [JTAS]
O termo plataforma normalmente é usada para designar um conjunto
Hardware + Sistema Operacional.
A plataforma Java é definida apenas em software e possui dois componentes:
Máquina Virtual Java (JVM)
Conjunto de bibliotecas que disponibilizam funções comuns (API Java)
Diferentemente das linguagens convencionais, que são compiladas para código
nativo, a linguagem Java é compilada para ―bytecode" (gerando o .class) que
é executado por uma máquina virtual (JVM – Java Virtual Machine).
Bytecodes interpretados
Código fonte
O modelo inicial (vide figura), que favorece a portabilidade do código,
através da interpretação dos bytecodes, foi praticamente substituído por
outro em que a interpretação dos bytecodes é substituída por outra
compilação (a compilação dos bytecodes), que ocorre quando o programa
é executado (compilador JIT , isto é, just-in-time). Essa mudança foi
fundamental para tornar Java uma linguagem de alto desempenho.
Obs.: compilar just-in-time : o código é compilado quando está em vias de ser
executado.
A linguagem Java representa um esforço na direção do conceito
write once, run everywhere (“escreva
uma vez, execute em todo lugar”)
Uma máquina virtual (Virtual Machine – VM) pode ser definida como ―uma
duplicata eficiente e isolada de uma máquina real‖.
A JVM é, então, uma máquina ‗imaginária‖ que é implementada através da
emulação por software usando uma máquina real.
Com a JVM existe uma camada extra entre o sistema operacional e a
aplicação, responsável por ―traduzir‖ (não é apenas isso) o que sua
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
6
aplicação deseja fazer para as respectivas chamadas do sistema
operacional no qual ela está rodando no momento. Veja a figura :
A especificação da Máquina Virtual Java fornece as especificações da
plataforma de hardware para a qual todo o código Java está compilado. Essa
especificação permite que os programas Java sejam independentes de
plataforma .
A plataforma Java é composta por 3 outras plataformas:
J2SE ou Java SE (Java Standard Edition): é a base da plataforma e
inclui o ambiente de execução e as bibliotecas comuns.
J2EE ou Java EE (Java Enterprise Edition): versão voltada para o
desenvolvimento de aplicações corporativas. Ex: Servlets
J2ME ou Java ME (Java Micro Edition): versão voltada para o
desenvolvimento de aplicações móveis ou embarcadas. Ex: celular
1.7. O Ambiente de Desenvolvimento [JTAS]
Java 2 System Development Kit (J2SDK)
Coleção de ferramentas de linha de comando para, entre outras tarefas,
compilar, executar e depurar aplicações Java
Ex: JRE, javac, javadoc, etc.
Java Runtime Environment (JRE)
Tudo o que é necessário para executar aplicações Java
Parte do J2SDK e das principais distribuições Linux, MacOS X, AIX,
Solaris, Windows 98/ME/2000
Portanto, lembre-se de baixar o JDK (java development kit, ou seja, kit de
desenvolvimento java), e não o JRE (java runtime environment, isto é, ambiente de
execução java). O JDK já vem com um JRE, porém o contrário não é verdade. O
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
7
JRE vem sem compilador e ferramentas para desenvolvimento. Acesse o site da
Sun (java.sun.com) ou até o GUJ (www.guj.com.br). Neste último, é possível achar
artigos que mostrem, em português, o passo-a-passo da instalação desejada.
1.14. Exemplo de uma Aplicação
Estrutura de uma aplicação Java: [JTAS]
Uma aplicação Java é composta de um ou mais arquivos com
extensão .java
Cada arquivo .java deve conter uma e somente uma classe pública.
O nome do arquivo .java tem que ser igual ao nome da classe pública
que ele contém. Isso acontece porque a JVM usa o nome da classe
para saber em que arquivo ela se encontra.
Cada arquivo .java quando compilado gera um arquivo com o mesmo
nome com extensão .class. Esse é o arquivo que contém o bytecode
que será executado pela JVM.
Os arquivos .java não precisam estar em um mesmo diretório. Eles
podem ser organizados em uma hierarquia de diretórios de acordo com
a finalidade de cada um. Esses diretórios são vistos pela JVM como os
diversos pacotes que compõem a aplicação.
Podemos dizer, então, que uma aplicação Java mínima é composta de
um único arquivo .java contendo uma única classe.
Um Programa Simples em JAVA [AC]
- Veremos inicialmente o mais simples programa JAVA:
package exemplo;
public class Primeiro
{
public static void main (String[] args)
{
System.out.println(“É simples !!!”);
}
}//cuidado com as aspas do MS Word! São diferentes!
- Esta mini-aplicação em Java imprime um texto na tela quando executada via
linha de comando
- Após compilar e executar este programa, nós vamos analisar suas partes
principais, que se repetem na maioria dos programas JAVA:
o A palavra-chave public é um modificador de acesso; esses
modificadores controlam o que outras partes de um programa podem
usar desse código;
o A palavra-chave class está lá porque tudo em JAVA está dentro de
uma classe; por enquanto, uma classe é um projeto preliminar para os
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
8
dados e métodos (funções) que serão parte do aplicativo; um aplicativo
pode ser composto por uma ou mais classes;
o Os nomes das classes (neste exemplo a palavra Primeiro) precisam
começar com uma letra e depois desta quaisquer combinações de
letras e dígitos; como padrão, os nomes são substantivos que iniciam
com uma maiúscula;
o Para começar a execução do programa compilado, o interpretador vai
iniciar sempre pelo método main da classe indicada; é absolutamente
necessária a presença do main (por se tratar de um aplicativo);
o As chaves, { e }, delimitam os blocos de comandos em JAVA;
o Os cabeçalhos do método main são sempre idênticos ao exemplo
acima;
o A palavra reservada static significa que o método é estático. Uma
classe que contém apenas métodos estáticos pode ser executada sem
a necessidade de instanciar a classe;
o A palavra reservada void quer dizer que o método não retorna valor,
não tem resposta para o método que o chamou;
o Neste exemplo o método main contém apenas uma instrução (ou
comando ou sentença da linguagem): a instrução utiliza o método
println do objeto System.out, para exibir uma string na console
padrão; cada chamada de println escreve uma nova linha;
o Java usa a sintaxe geral:
objeto.método(parâmetros);
o Os métodos em JAVA podem ter zero, um ou mais argumentos, até
mesmo o main, mas mesmo que o método não tenha argumentos, ele
terá que possuir parênteses vazios na sua assinatura;
o Existe também o método print em System.out, que imprime sem
quebra de linha no final.
o Comentários sobre pacote (package) :
Fica fácil notar que a palavra chave package indica qual o
pacote que contém a classe Primeiro. Um pacote pode conter
nenhum, um ou mais subpacotes e uma ou mais classes dentro
dele.
Quando não se põe a linha do pacote, temos um pacote
anônimo.
Os nomes dos pacotes devem ser formados apenas de letras
minúsculas, não importa quantas letras estejam contidas nele.
As classes do pacote padrão de bibliotecas não seguem essa
nomenclatura, que foi dada para bibliotecas de terceiros.
Unidades de Compilação
- Três elementos top-level conhecidos como compilation units, não obrigatórios,
aparecem em um arquivo Java na seguinte ordem:
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
9
o Declaração de pacote: package
o Declarações de importação: import
o Definições de class, interface ou enum
- Uma declaração de pacote serve para indicar um caminho de pastas onde
deverão estar os arquivos (.class) do pacote. Por exemplo: package
pasta1.pasta2; indica que os arquivos do pacote estão em pasta2 que
está dentro de pasta1. Falaremos de pacote mais adiante.
- Uma declaração de import serve para importar uma ou todas as classes de
um pacote. O caminho indicado no import é justamente um caminho de
pastas. Asterisco significa todos os arquivos da pasta (mas não das
subpastas).
- É preciso tomar cuidado com ambigüidade nos comandos import. Por
exemplo, ao utilizar a classe Date, se importou java.util.* e
java.sql.* (ambos contêm classes Date diferentes), certifique-se de
importar explicitamente Date do pacote desejado (por exemplo,
java.util.Date).
- Exemplo Modelo:
package org.templojava;
//nome do pacote pode ser o endereço web invertido
import java.util.SimpleDateFormat; //importa classe
import java.util.*;
//o compilador importa classes utilizadas no código
public class Exemplo
{
//codigo
}
Pesquisando na Referência da Linguagem Java
- Verifique a referência para cada nova classe que for estudada.
Acesse: http://java.sun.com/
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
10
2. Estruturas Básicas de Programação[AC]
2.1. Comentários em JAVA
- Os comentários não aparecem no executável do programa; em JAVA temos
comentários de uma linha, sinalizados com //, e temos os comentários de mais
de uma linha, entre /* e */:
// Este é um comentário de uma linha
/* Agora podemos escrever
o comentário em várias linhas.
*/
- Os comentários não podem ser aninhados em JAVA, ao contrário de outras
linguagens.
2.2. Tipos de Dados
- JAVA é fortemente tipada, ou seja, as variáveis precisam ter um tipo declarado.
- Há oito tipos primitivos de dados em JAVA: quatro tipos inteiros, dois tipos
ponto flutuante, um tipo para caracteres e outro para variáveis lógicas.
a) Inteiros [JTAS]
Tipo Tamanho
(bytes)
Faixa de valores Tipo
byte 1 -128 à 127 byte
short 2 -32768 à 32767 short
int 4 -2147483658 à 2147483657 int
long 8 -9223372036854775808 à
9223372036854775807
long
- O tipo int é o mais prático e o mais usado;
- O mais importante é que os intervalos possíveis não dependem da máquina;
b) Ponto Flutuante [JTAS]
Tipo Tamanho (bytes) Faixa de valores
Float 4 ±3.40292347E+38
(6-7 dígitos decimais significantes)
double 8 ± 1.79769313486231570E+308
(15 dígitos decimais significantes)
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
11
- O tipo double tem duas vezes a precisão do float.
- O double é usado na maioria dos casos.
- Os valores mínimos e máximos seguem os correspondentes na tabela dos
inteiros.
c) O Tipo Caracter (char)
- Apóstrofos definem valores char; por exemplo „J‟ é um caractere e “J” é uma
string contendo um único caractere. A faixa é de 0 a 216-1 (16 bits), conjunto
Unicode de caracteres.
Caracteres Especiais
Seqüência de
Controle
Significado
\b backspace (volta um caracter)
\t tab (tabulação)
\n linefeed (quebra de linha)
\r carriage return (início da linha)
\“ aspas duplas
\‟ Apóstrofos
\\ barra invertida
d) O Tipo Lógico (Boolean)
- O tipo boolean tem dois valores possíveis, false ou true. e são
armazenados em 1 byte.
2.3. Declaração de Variáveis em Java
- Declaram-se as variáveis Java colocando o tipo primeiro e depois o nome da
variável, finalizando com ponto e vírgula.
- Exemplos:
byte b;
int numerointeiro1, numerointeiro2;
long inteirolongo;
//para o valor da nossa dívida externa em centavos
char letra;
- Um identificador precisa iniciar com uma letra e ser uma seqüência de letras ou
dígitos;
- Podem ser usados símbolos como ‗_‘, ‗‘ ou qualquer outro do Unicode
(conjunto de caracteres utilizado por Java), mas não é aconselhável usar
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
12
principalmente caracteres com acento, por causa da diferença de conjuntos de
caracteres nos vários sistemas operacionais (questão de visualização correta
do símbolo).
- Comumente não são usados símbolos para nomenclatura em Java, é mais
simples usar letras e números, além de seguir as convenções para cada tipo de
identificador (classes iniciam com maiúsculas, métodos com minúsculas,
variáveis com minúsculas, constantes são escritas com maiúsculas, etc).
- Não podem ser usados espaços em nomes de variáveis ou de identificadores
quaisquer;
2.4. Atribuições e Inicializações
- Deve-se inicializar uma variável antes de utilizá-la, em geral após a sua
declaração ou na mesma instrução, exemplos:
int numero; //esta é uma declaração
numero = 5; //esta é uma atribuição
char letra = „A‟; //esta é uma inicialização
- As declarações podem aparecer em qualquer lugar do código, mas uma
variável só pode ser declarada uma vez em um bloco.
2.5. Constantes
- A palavra final denota uma constante (utilize maiúsculas nos nomes das
constantes):
final double CMPORPOL = 2.54;
Exemplo :
public class Constantes
{ final double G = 9.81;
//gravitação em metros por segundo ao quadrado
public static void main (String[] args)
{
System.out.println(G + “ metros por segundo ao quadrado é a
aceleração da gravidade.”);
System.out.println(“A constante de classe G= ” + G + “ pode
ser acessada em qualquer método da
classe.”);
}
}
2.6. Operadores Aritméticos
- Operadores aritméticos: + para adição, - para subtração, * para multiplicação e /
para divisão;
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
13
- ATENÇÃO: o operador / denota divisão inteira se os dois argumentos forem
inteiros e divisão de ponto flutuante se pelo menos um dos operandos for um
número real.
- O resto inteiro é denotado por %. Exemplos: (15 / 4) é 3, (15 % 2) é 1.
- Pode-se utilizar inicializações do tipo:
int n = 3;
int dobroN = n * 2;
- Pode-se utilizar a forma reduzida:
n += 4; //que equivale a n = n + 4;
2.7. Exponenciação
- Não há operador para exponenciação, deve-se usar o método pow da classe
Math, ou seja, Math.pow(operando, expoente).
- Para xa, temos:
double y = Math.pow (x, a);
Outros métodos da classe Math
- Math faz parte do pacote java.lang. Não é necessário importar este
pacote, nunca. Podemos usá-la diretamente, com atenção para os argumentos
de cada função. Verifique na referência de Java toda a lista de métodos de
Math.
Método Descrição Exemplo
abs (x) Valor absoluto de x Se x = -3, então abs(x) é 3.
ceil (x) Arredonda para o próximo inteiro
maior que x
Se x = 6.7, ceil(x) é 7.
Se x = -6.8, ceil(x) é –6.
floor (x) Arredonda para o próximo inteiro
menor que x
Se x = 6.7, floor(x) é 6.
Se x = -6.8, ceil(x) é –7.
max (x, y) Maior valor entre x e y max(3, 4) é 4.
min (x, y) Menor valor entre x e y min(3, 4) é 3.
sqrt (x) Raiz quadrada de x sqrt(9) é 3.
PI Valor da constante PI 3.14159265358979323846
2.8. Operadores para Incremento e Decremento
- Adicionar ou subtrair 1:
int x = 10; x++; //adiciona 1 ao valor de x, x=11
x--; //subtrai 1 do valor de x, x=10
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
14
int y = 5 + ++x; //incrementa x antes, y=16, x=11
//ou, se a posição do operador estivesse trocada:
int y = 5 + x++; //incrementa x depois, y=15, x=11
2.9. Conversões entre Tipos Numéricos
- Algumas conversões são permitidas diretamente:
o byte short int long float double
o char int long float double
- Em operações binárias, serão seguidas as seguintes regras:
o Se um dos operandos for double, o outro será convertido para
double;
o Se um dos operandos for float, o outro será convertido para float;
o Se um dos operandos for long, o outro será convertido para long;
o Mesma regra para int, short e byte.
- Ou seja, o ―maior‖ tipo sempre manda na expressão, inclusive String (que
veremos mais a frente).
- Conversões explícitas de tipo ou casts são conversões onde são permitidas
perdas de informação:
double x = 9.997;
int nx = (int) x;
- Nesta conversão, a variável nx terá o valor final 9, pois a parte fracionária será
descartada.
- Se for necessário arredondar um número de ponto flutuante para o inteiro mais
próximo, um dos métodos que pode-se usar é o método Math.round (Math é
uma classe de java.lang,
pacote padrão da linguagem):
double x = 9.997;
int nx = (int) Math.round (x);
- Nesta conversão, a variável nx terá o valor final 10. Mas fique atento, round
retorna um long, então ainda é necessário usar o cast se for preciso
armazenar em uma variável de outro tipo. É aconselhável sempre testar os
valores obtidos com conversões explícitas, a fim de garantir o resultado
desejado.
- O pacote java.lang é usado naturalmente na compilação, nunca é preciso
incluir (importar) este pacote.
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
15
2.10. Operadores Relacionais e Lógicos
- Igualdade: (3 == 7) , tem resultado false;
- Desigualdade: (3 != 7) , tem resultado true;
- Os outros operadores mais comuns ‗>‘, ‗<‘, ‗>=‘, ‗<=‘, são usados nestas formas
mesmo.
- Para o and lógico, usa-se ‗&&‘, para o ou lógico, usa-se ‗||‘. O operador de
negação é o ‗!‘.
2.11. Hierarquia de Operadores e Parênteses
- Como em todas as linguagens, é melhor usar parênteses para indicar a ordem
das operações. A tabela de hierarquia de operações em Java é:
Operadores Associatividade
[], . (ponto), () (chamada de método) ESQ para DIR
!, ~, ++, --, + (unário), - (unário) , () (cast), new DIR para ESQ
*, /, % ESQ para DIR
+, - ESQ para DIR
<, <=, >, >=, intanceOf ESQ para DIR
==, != ESQ para DIR
&& ESQ para DIR
|| ESQ para DIR
?: ESQ para DIR
=, +=, -=, *=, /=, %= DIR para ESQ
2.12. Strings
- Strings são seqüências de caracteres como ―tudo bem ?‖. Não há um tipo String
em Java, e sim uma classe predefinida chamada String, que faz parte do
pacote padrão de Java. Cada conjunto de caracteres entre aspas é uma
instância da classe String:
String e = “”; //uma string vazia
String saudacoes = “Olá”;
a) Concatenação
String uniao = ―use o sinal de + para ‖ + ―concatenar Strings‖;
b) Substrings
- Java possui um método para se obter um subconjunto de uma string, que é o
método
nomestring.substring(posicaoinicial, posicaolimite)
onde:
o posicaoinicial é a primeira posição a ser inclusa na substring
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
16
o posicaolimite a posição imediatamente posterior à última a ser
inclusa.
- Lembre-se que em JAVA conta-se a partir do 0 (zero), ou seja, a primeira
posição de uma string é a posição 0.
String saudacao = “Bem vindo”; //0=B,1=e,2=m
String s = saudacao.substring(0, 3); //s = “Bem”
//o espaço na posição 3 não é incluído
c) Edição de Strings
- Para descobrir o tamanho de uma string, usa-se o método
nomestring.length():
String saudacao = “Bem vindo”;
int tamanho = saudacao.length(); //tamanho = 9
- Para descobrir o caracter na posição n de uma string, usa-se o método
nomestring.charAt(n):
String saudacao = “Bem vindo”;
char letra3 = saudacao.charAt(2); //letra3 = m
d) Teste de Igualdade entre Strings
- Para testar se duas strings são iguais, usa-se
nomestring1.equals(nomestring2). O valor true será retornado se
forem iguais. Ex:
String saudacao = “Bem vindo”;
boolean igual = “Bem vindo”.equals(saudacao);
//igual = true
- Para testar se duas strings são iguais ignorando maiúsculas e minúsculas, usa-
se nomestring1.equalsIgnoreCase(nomestring2).
Uma classe pré-definida - Métodos da Classe java.lang.String
- A classe java.lang.String possui muitos métodos (verifique na referência
da linguagem outros métodoS também úteis). A referência da linguagem está
acessível a partir de http://java.sun.com/ ou no javadoc que foi instalado junto
com seu JDK. Seguem alguns métodos interessantes, dos quais uns já foram
especificados acima:
o charAt(int indice)
//retorna o caractere na posição especificada
o int compareTo(String outraString)
//retorna um valor negativo se a string vier antes de outraString na
//ordem do dicionário, um valor positivo se outraString vier antes e
//0 (zero) caso forem iguais
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
17
o boolean endsWith(String sufixo)
//retorna true se a string terminar com sufixo
o boolean equals(String outra)
//retorna true se a string for igual à outra
o boolean equalsIgnoreCase(String outra)
//retorna true se a string for igual à outra, ignorando maiúsculas e
//minúsculas
o String toLowerCase()
//retorna uma nova string convertendo maiúsculas para minúsculas
o String toUpperCase()
//retorna uma nova string convertendo minúsculas para maiúsculas
o String trim()
//elimina espaços iniciais e finais
2.13. Comandos de Decisão
a) Comando if
- Forma mais simples:
if (condicao) instrucao;
- Com bloco de instruções:
if (condicao)
{ instrucao1;
instrucao2;
...
}
- Forma mais simples com else:
if ( condicao ) instrucao1 else instrucao2;
- Forma com else e bloco de instruções:
if ( condicao )
{ instrucao1;
instrucao2;
...
}
else
{ instrucao1;
instrucao2;
...
}
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
18
- Exemplo Maior.java:
public class Maior
{
public static void main (String[] args)
{ int a = 5;
int b = 3;
if ( a > b )
{ System.out.println(“O maior é ” + a);
}
else
{ System.out.println(“O maior é ” + b);
}
}
}
b) Seleções Múltiplas – A Instrução switch
- A instrução if...else pode ser incômoda quando temos várias seleções com
múltiplas alternativas. Com a instrução switch pode-se testar o tipo char e
todos os inteiros menos long e não se pode usar conjuntos de valores, a não
ser que a versão do JDK instalado seja a partir da 1.5 que aceita objetos
Enumeration. (veja a referência da linguagem)
- Exemplo (trecho de código):
int opcao = 2;
switch ( opcao )
{ case 1:
System.out.println(“A opção é 1.”);
break; // fim do bloco para opcao = 1
case 2:
System.out.println(“A opção é 2.”);
break;
case 3:
System.out.println(“A opção é 3.”);
break;
default:
System.out.println(“Opção inválida.”);
break; // a cláusula default é opcional
}
- É possível ainda retirar o comando break de uma cláusula fazendo com que a
execução prossiga para os comandos da cláusula seguinte, mas isso tem que
ser feito com bastante cuidado. Nestes casos é aconselhável acrescentar um
comentário no código.
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
19
2.14. Comandos de Repetição
a) Comando for (para-faça)
- Se soubermos quantas vezes o conjunto de instruções deve ser processado, o
mais simples é usar o comando for:
for (instrucao1; expressao1; expressao2) { bloco }
- Exemplo ContagemRegressiva.java:
public class ContagemRegressiva
{
public static void main (String[] args)
{ for ( int i = 10; i > 0; i-- )
{ System.out.println(“Contagem: ” + i);
}
System.out.println(“Lançamento!”);
}
}
- É possível também criar laços for com variáveis e incrementos em ponto
flutuante, com cuidado em relação aos erros de arredondamento dos valores (a
expressão limite deve ser bem definida). Também é permitido utilizar laços com
duas variáveis de controle.
b) Comandos while (enquanto faça) e do-while (faça enquanto)
- Usados quando não sabemos quantas vezes o conjunto de instruções deve ser
processado. O while executa o corpo do laço apenas enquanto a condição for
true (verdadeira):
while
( condicao ) { bloco }
- O while executa o teste da condição antes do início do bloco. Se for preciso
executar pelo menos uma vez o bloco de comandos do laço, deve-se usar a
versão do de um laço while:
do { bloco } while ( condicao );
3. Revisão de Orientação a Objetos Básica (OO Básica) [JTAS]
Como já foi estudado, as principais características do Paradigma OO são :
identidade
abstração
classificação
encapsulamento
herança
polimorfismo
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
20
Conceitos de OO
3.1. Objeto
Um objeto é a representação computacional de um elemento ou processo do
mundo real.
Exemplos :
casa, martelo, venda, programa, carro, ...
Note que, esses objetos podem ser tanto objetos concretos (carro, livro, nota
fiscal), quanto conceitos abstratos (conta corrente, venda, pessoa jurídica). Cada
objeto possui estados e comportamentos.
Um objeto possui identidade, características e comportamento. Vejamos cada
um:
a) Identidade : Todo objeto possui uma identidade única que permite que o
sistema o selecione dentre um conjunto de objetos similares. Ou seja, a
identidade possibilita a referência aos objetos
b) Características : Uma característica descreve uma propriedade de um
objeto, ou seja, algum elemento que descreva o objeto.
Cada característica é chamada de atributo do objeto
Exemplo : Objeto moto tem as seguintes características ou atributos : cor,
marca, ano de fabricação, tipo de combustível
c) Comportamento :
Definição:
o Um comportamento representa uma ação ou resposta de um
objeto a uma ação do mundo real (AÇÃO ou REAÇÃO)
o Cada comportamento é chamado de método do objeto
Obs. : Em C++, os métodos podem ser também chamados de
funções membro.
Exemplos de comportamento para o objeto moto
o Acelerar
o Parar
o Andar
o Estacionar
Um sistema pode conter um ou inúmeros objetos ativos. Cada objeto ativo no
sistema em particular também é chamado de instância. As diferentes instâncias
possuem seu próprio estado.
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
21
Exemplo :
Objeto : Maria
Estado :
Idade : 20 anos
Altura : 1,60 m
Peso : 58 Kg
Comportamento :
andar, falar e pular
Uma segunda característica de OO é a abstração, que ―foca as
características essenciais de algum objeto, de acordo com a perspectiva do
observador.‖
Exemplo :
Se pensarmos no conceito de ―conta corrente‖ bancária e abstrairmos este
conceito, podemos identificar detalhes comuns, como o número da conta, número da
agência e saldo; e operações como débito em conta, depósito e extrato da conta.
Basicamente essas são as características de conta corrente para todos os
bancos, apesar de um ou outro banco ter uma política de descontos de taxas etc.
À medida que refinamos um objeto, mais específico ele se torna e mais
dependente do domínio da aplicação.
A terceira característica de OO é a classificação. Na Classificação, Objetos
com as mesmas características (atributos e comportamento) são agrupados em uma
classe, sendo que cada classe define um conjunto possível de objetos.
Exemplo : Objetos mesas abstrair em Classe Mesa
Classe Mesa Atributos: tamanho, forma, número de pés,
___ material
Operações : mover, limpar
3.2.Classes
A classe descreve as características e comportamento de um conjunto de
objetos :
Cada objeto possui uma única classe
O objeto possuirá os atributos e métodos definidos na classe
O objeto é chamado de instância de sua classe
A classe é o bloco básico para a construção de programas OO
Atributos : idade, altura e
peso
Métodos : andar, falar e
pular
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
22
Criação de Objetos:
A classe é responsável pela criação de seus objetos
Esta criação é realizada através de um método especial, chamado
de construtor
Em Java, usa-se new para se criar um objeto.
Eliminação de Objetos
A classe é responsável pela eliminação de seus objetos, quando eles
não podem mais ser utilizados pelo sistema
Esta eliminação é realizada por um método especial, chamado de
destrutor
Comentários :
1. Em Java não existe destrutor, mas em C++ sim.
2. Uma classe representa um conjunto de objetos que compartilham uma
mesma estrutura e um mesmo comportamento.
Destacando a terceira característica em OO, isto é, a Classificação, temos a
observar que:
Cada objeto é dito ser uma instância de uma classe
Cada instância mantém seus próprios valores de atributo (estado),
mas compartilha os nomes dos atributos e comportamento (operações) com outras
instâncias da classe.
Uma quarta característica do Paradigma OO é o encapsulamento.
Relacionando esta característica com os conceitos de classe e objeto pode-se
afirmar que :
―Uma classe encapsula atributos (nomes, tipos) e comportamentos,
ocultando os detalhes de implementação dos objetos.”
Com relação ao encapsulamento, os métodos formam uma ―cerca‖ em torno
dos atributos, que não podem (ou devem) ser manipulados diretamente. Os
atributos somente podem ser alterados ou consultados através dos métodos do
objeto. Considerando clientes de um objeto X os outros objetos que utilizam
métodos de X, os benefícios do encapsulamento são :
os clientes de um objeto podem utilizar seus métodos sem conhecer os
detalhes de sua implementação
A implementação de um objeto pode ser alterada sem o conhecimento de
seus clientes, desde que a interface visível seja mantida
Um programa OO é um conjunto de objetos que colaboram entre si para a
solução de um problema. A colaboração ocorre através de trocas de
mensagens, sendo que a troca de mensagem representa a chamada de um
método.
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
23
Controle de visibilidade
Os atributos e métodos, em termos de visibilidade, podem ser :
public acessíveis por qualquer classe
private acessíveis pela própria classe
protected Acessíveis pela própria classe ou por
seus descendentes
3.3.Herança
O compartilhamento de atributos e comportamentos entre classes baseiam-se
num relacionamento hierárquico.
Uma classe pode ser definida genericamente e então refinada (especializada)
sucessivamente em sub-classes mais específicas.
Herança Simples x Herança Múltipla
Se uma classe herda de apenas uma superclasse (classe mãe ou
base), temos uma herança simples
Se uma classe herda de diversas superclasses, temos uma herança
múltipla
Não existe herança múltipla em Java.
Exemplo : A classe Animais pode ser subdividida nas sub-classes anfíbios,
mamíferos, aves, peixes e répteis.
3.4. Polimorfismo
Uma subclasse pode redefinir um elemento herdado, o que é denominado
polimorfismo.
O polimorfismo se realiza através da recodificação de um ou mais métodos
herdados por uma subclasse. Ou seja, um mesmo comportamento pode se
apresentar de forma diferente em classes diferentes (poli = vários, morfismo =
forma).
Uma linguagem de programação orientada a objetos automaticamente escolhe
o método correto para implementar uma operação baseado no nome da
operação,
nos dados que carrega (parâmetros) e na classe implementada do
objeto (assinatura do método) . Por isto, novas classes podem ser
acrescentadas sem a modificação de todo o código existente
Mais adiante, falaremos mais de Polimorfismo.
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
24
Comentário [AC] : Ao projetar um sistema POO, começamos pela determinação das
classes e depois acrescentamos os métodos de cada classe. Uma regra para criar
as classes é procurar por substantivos no problema. Os métodos correspondem aos
verbos.
Exemplo: Num sistema de processamento de pedidos:
- Classes (substantivos): item, pedido, endereço para remessa
(endereçoRemessa), pagamento, conta, etc.
- Métodos (verbos): itens são adicionados aos pedidos, pedidos são
enviados ou cancelados, pagamentos são aplicados aos pedidos.
Cada verbo sugere um método.
- Objetos: com cada verbo, como ―adicionar‖, ―enviar‖, ―cancelar‖ e
―aplicar‖, é necessário identificar o objeto que tem a maior
responsabilidade em efetuar esta ação.
Exemplo [FC]: Apresenta uma classe Ponto com 2 atributos, e outra classe
TestaPonto que cria uma instância de um objeto da classe Ponto.
public class Ponto {
int x, y; //atributos
}
public class TestaPonto {
public static void main(String[] args) {
Ponto p;
p = new Ponto(); // Cria um objeto com new
p.x = 1; // acessa pelo . – não privado
p.y = 2;
System.out.println ("Coordenada (x,y) = (" + p.x +
"," + p.y +")");
}
}
3.5. O Vocabulário da POO – Enfatizando os conceitos [AC]
a) CLASSE
- O modelo ou a forma a partir do qual um objeto é criado. Em JAVA, toma-se
como padrão a primeira letra do nome da classe em maiúscula (como String,
System, Math etc.).
b) OBJETO
- Instância da classe; componente na memória com seus atributos e dados
próprios, que utilizam seus métodos para manipular os seus dados internos; se
comunicam entre si através de mensagens (chamadas a métodos).
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
25
- Para criar um objeto e utilizar (chamar) os seus métodos é necessário utilizar o
operador new:
Casa c1 = new Casa();
c) BIBLIOTECA PADRÃO
- Classes e pacotes para diversos propósitos tais como projetos de interface de
usuário e programação em rede.
d) CLASSE Object
- As classes em Java sempre são formadas a partir de outras classes. Uma
classe formada a partir de outra "estende" esta outra. Em Java existe uma
classe "mãe" a partir da qual todas as outras classes são naturalmente
formadas, esta é a classe Object. Todas as classes ―herdam‖ de Object.
e) ENCAPSULAMENTO
- Em POO devemos combinar dados e comportamento em um pacote fechado e
ocultar a implementação dos dados, de forma que o usuário do objeto (em geral
outro objeto) não veja como estes dados são manipulados. Dizemos que os
dados e métodos são encapsulados em objetos. É outro conceito fundamental
em POO. O encapsulamento dá aos objetos a característica de "caixa-preta".
Os objetos devem se comunicar apenas através de mensagens, ou seja, seus
dados (atributos) devem estar protegidos de outros objetos e só poderão ser
acessados através de métodos (funções).
f) VARIÁVEIS DE INSTÂNCIA
- Dados ou atributos do objeto (só existem após ser criado o objeto).
g) ESTADO DO OBJETO
- Valores atuais dos dados do objeto.
Vejamos um primeiro exemplo: Suponha que você deseja construir um
aplicativo que imprima a área das figuras geométricas ―quadrado‖ e ―triângulo
eqüilátero‖. Definiremos para o exemplo o valor dos lados como 10, para vermos a
diferença no valor das áreas calculadas. O primeiro passo é criar as classes (cujos
nomes serão: Quadrado e Triangulo, a partir das quais serão gerados os objetos
q e t no método main:
public class Quadrado
{ double lado = 0;
public double area() //método cálculo da área
{ return (lado * lado); } // Retorno com return
}
Salve como Quadrado.java mas não compile ainda. Agora, a classe Triangulo:
public class Triangulo
{ double lado = 0;
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
26
public double area()
{
return (0.433*lado*lado); }
}
Salve como Triangulo.java mas não compile ainda. Finalmente, a classe
Figuras:
public class Figuras
{ public static void main (String[] args)
{// declarando e instanciando "q"
Quadrado q = new Quadrado();
// declarando e instanciando "t"
Triangulo t = new Triangulo();
//valor do atributo lado do obj “q”
q.lado = 10;
//chamada ao método area do obj “q”
double s = q.area();
System.out.println("Área do Quadrado: "+s);
//valor do atributo lado do obj “t”
t.lado = 10;
//chamada ao método area do obj “q”
s = t.area();
System.out.println("Área do Triângulo: "+s);
}
}
Salve como Figuras.java e compile esta classe com sua ferramenta ou na
linha de comandos com javac Figuras.java. Ao compilar, você notará que
todas as classes do exemplo serão compiladas gerando os três arquivos ―.class‖.
Isto acontece porque Java reconhece quais as classes que fazem parte do sistema,
pois estão sendo chamadas pela classe principal, e as compila. Execute com java
Figuras.
3.6. Observações sobre variáveis, valores, referências e tipos[FS]
a) Variáveis, valores e referências
Variáveis são usadas em linguagens em geral para armazenar valores
Em Java, variáveis podem armazenar endereços de memória ou valores
atômicos de tamanho fixo
b) Tipos
Tipos representam um valor, uma coleção de valores ou coleção de outros
tipos. Podem ser
Tipos básicos, ou primitivos, quando representam unidades indivisíveis de
informação de tamanho fixo. Exemplo : um inteiro, um booleano ...
Tipos complexos, quando representam informações que podem ser
decompostas em tipos menores. Os tipos menores podem ser primitivos
ou outros tipos complexos. Exemplo : Um vetor, uma data ...
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
27
Em Java, tipos complexos são armazenados como objetos .
3.7. Coleta de Lixo [FS]
A memória alocada em Java não é liberada pelo programador, ou seja,
objetos criados não são destruídos pelo programador
A criação de objetos em Java consiste de
Alocar memória para armazenar os dados do objeto
Inicializar o objeto (via construtor)
Atribuir endereço de memória a uma variável (referência)
Mais de uma referência pode apontar para o mesmo objeto
Mensagem m, n, p;
m = new Mensagem("A");
n = m;
p = new Mensagem("B");
Quando um objeto não tem mais referências apontando para ele, seus dados
não mais podem ser usados e a memória deve ser liberada.
O coletor de lixo irá liberar a memória na primeira oportunidade
n = null;
p = new Mensagem("C");
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
28
3.8. Um pouco de entrada e saída de dados em JAVA [AC]
a) Leitura de Dados via Entrada Padrão
- A leitura de dados de entrada pelo teclado era difícil em Java antes da versão
1.5. Quando usamos componentes como caixas gráficas de entrada de dados
isto se torna menos complexo, mas antes disso é preciso verificar como
funciona a entrada via console.
- De forma gerla, uma declaração de import serve para importar uma ou todas
as classes de um pacote. O caminho
indicado no import é justamente um
caminho de pastas. Asterisco significa todos os arquivos da pasta (mas não as
subpastas).
- O exemplo a seguir utiliza a classe Scanner, que possui métodos para leitura
de diversos tipos de dados de entrada via console:
Exemplo :
import java.util.*;
public class LeituraComScanner
{
// Testes de leitura com classe Scanner (Java 5.0)
public static void main(String[] args)
{
//objeto para leitura via console
Scanner entrada = new Scanner (System.in);
System.out.println("Informe nome:");
//lê uma string como o método nextLine()
String nome = entrada.nextLine();
System.out.println("Informe idade:");
//lê um inteiro com o método nextInt
int idade = entrada.nextInt();
System.out.println("Nome:" + nome +
"\nIdade:" + idade);
}
}
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
29
Tabela com alguns métodos da classe Scanner [JTAS]
Método Descrição
String nextLine() Lê toda a linha
int nextInt() Lê um inteiro
double nextDouble() Lê um double
float next Float() Lê um float
long nextLong() Lê um long
boolean hasNext() Verifica se ainda existem dados a serem lidos
b) Leitura via Componentes Gráficos do Pacote Swing
- Mais tarde estudaremos componentes gráficos para interfaces de aplicativos,
mas já podemos começar a trabalhar com o componente chamado
JOptionPane, que representa uma janela ou caixa de diálogo com o usuário.
A classe JOptionPane está no pacote javax.swing que devemos importar
para utilizar este componente.
Exemplo:
import javax.swing.JOptionPane; //pacote necessário
//ou
//import javax.swing.*;
//o compilador verifica
public class Mensagem
{ public static void main (String[] args)
{
//comando para a caixa de diálogo
JOptionPane.showMessageDialog
(null, “Esta é uma mensagem !”);
//saída obrigatória do sistema
System.exit(0);
}
}
- O componente pode ser usado, pois a classe foi incluída no código com o
comando import. É possível também usar o seguinte (selecionar todo o pacote
e deixar o trabalho de carregar a classe, feito pelo compilador):
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
30
import javax.swing.*;
- O comando JOptionPane.showMessageDialog é usado para mostrar
caixas de mensagem e pode ser usado nesta forma simples, com dois
parâmetros: o primeiro, com valor null, representa o componente parent
(janela maior que abriria a caixa de mensagem, como não existe, usa-se null),
o segundo representa a mensagem a ser exibida.
- Por último, é preciso, sempre que se usar componentes de interface com o
usuário, incluir o comando de saída do sistema, para encerrar a execução.
- Uma versão mais completa do comando de caixa de diálogo contém quatro
argumentos, como segue:
JOptionPane.showMessageDialog
(null, “Texto da Mensagem”,
“Titulo da janela”, TIPOICONE);
- O campo TitulodaJanela aparece na barra azul da caixa de diálogo. Já o
TIPOICONE representa o pequeno desenho que pode aparecer, identificando o
tipo de mensagem. Veja o que pode ser colocado neste argumento e o tipo de
janela gerado:
JOptionPane.ERROR_MESSAGE
JOptionPane.INFORMATION_MESSAGE
JOptionPane.WARNING_MESSAGE
JOptionPane.QUESTION_MESSAGE
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
31
JOptionPane.PLAIN_MESSAGE
- Para entrada de dados utilizamos o comando showInputDialog, com uma
variável do tipo String aguardando o retorno (as janelas retornam sempre
uma string):
String numLido =
JOptionPane.showInputDialog( "Informe:" );
- Gerando a janela a seguir:
- Após a leitura, é necessário obter o número a partir da string lida, o que deve
ser feito com um dos comandos a seguir:
int numero =
Integer.parseInt( numLido );
//obtém inteiro
double numero =
Double.parseDouble( numLido );
//obtém ponto flutuante
NOTE : Classe Integer com o método parseInt
Classe Double com o método parseDouble
Exemplo (DEITEL):
import javax.swing.JOptionPane;
public class Soma {
public static void main( String args[] )
{
String numero1, numero2;
int n1, n2, resultado;
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
32
numero1 = JOptionPane.showInputDialog
("Informe um inteiro:");
numero2 = JOptionPane.showInputDialog
("Informe outro inteiro");
// convertendo
n1 = Integer.parseInt( numero1 );
n2 = Integer.parseInt( numero2 );
// somando
resultado = n1 + n2;
JOptionPane.showMessageDialog
(null, "A soma é "+resultado,
"Resultado:", JOptionPane.PLAIN_MESSAGE);
System.exit( 0 );
}
}
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
33
4. Vetores (Arrays)
São estruturas homogêneas, ou seja, são estruturas utilizadas para
armazenar vários elementos de um mesmo tipo. Os elementos de um vetor,
em Java, podem ser de tipos primitivos (Ex: int, double, etc) ou objetos
(referências).
O primeiro elemento (posição) possui índice 0 (zero).
São tratados em java como objetos, ou seja, para serem utilizados temos que
instanciá-los (usando new).
4.1. Criação de Vetores
Exemplo 1: Criando um vetor de tipos primitivos (int).
int c[]; // declara o array
c = new int[10]; // aloca o array
c[1] = 20; // atribui o valor 20 ao componente de
// índice 1
Obs: A linha int c[]; poderia ser substituída por int [] c;
Outro exemplo criando um array com valores iniciais:
int n[] = {20,63,40,58}; //Cria, aloca e inicializa o array
Exemplo 2: Criando vetores de objetos.
class Coisa { } // Uma classe qualquer
Coisa[] a; // referência do vetor (Coisa[]) é null
Coisa[] b = new Coisa[5]; // referências Coisa null
Coisa[] c = new Coisa[4];
for (int i = 0; i < c.length; i++) {
c[i] = new Coisa(); // refs. Coisa inicializadas
}
Coisa[] d = {new Coisa(), new Coisa(), new Coisa()};
4.2. Comprimento de um vetor
Pode ser obtido, usando-se a propriedade length.
int x[] = {1,2,3,4,5};
System.out.println(x.length); // Imprimirá 5;
4.3. Vetores Multidimencionais (Matrizes)
Possuem mais de uma dimensão
int b[][]; //Declaração
b = new int[3][3]; //Criação
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
34
b[1][2]=5; //Atribuição
ou
int b[][] = {{2,3,4},{4,5,6}};
4.4. Vetores com dimensões diferentes
int b[][];
b = new int[2][];
b[0]=new int[3];
b[1]=new int[10];
5. Getters, Setters e Construtores
5.1. Construção de Classes
Veremos agora algumas recomendações para criarmos programas JAVA mais
sofisticados, onde a classe escolhida para começar a executar pelo interpretador
geralmente tem pouca funcionalidade além de criar os vários objetos que vão
realmente fazer o trabalho do programa.
Construtores
- Um construtor tem o mesmo nome da classe;
- Um construtor pode ter um ou mais parâmetros, ou mesmo nenhum (construtor
padrão fornecido pelo compilador);
- Um construtor é sempre chamado através da palavra-chave new;
- Um construtor não retorna valor (mesmo assim não tem void na assinatura)
Exemplo :
public class Cliente{
private String nome; //atributos nome e numConta
private int numConta;
public Cliente(String n, int c)//construtor
{ nome = n;
numConta = c;
}
}
Construtores Padrões
- Se um método construtor não for especificado para uma classe e um objeto for
referenciado no sistema, um construtor padrão será providenciado. Estes
construtores não têm argumentos e inicializam todos os campos de instância
com valores padrões.
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
35
Sobrecarga de Construtores
- Ao implementar uma classe, podemos definir mais de um construtor para a
classe, a fim de que possamos criar objetos de várias maneiras. Exemplo:
Dia hoje = new Dia ();
Dia hoje = new Dia (1999,11,31);
- Existem dois construtores para uma certa classe Dia, o primeiro inicializa os
campos de instância com a data atual do sistema e o segundo inicializa os
campos de instância com os parâmetros passados na inicialização do objeto.
- A sobrecarga de métodos acontece quando vários métodos dentro de uma
mesma classe têm o mesmo nome, mas argumentos diferentes (o compilador
decide que método será usado).
- Java permite sobrecarregar qualquer método, de qualquer tipo!
Utilização de Métodos e Campos Privados
- Ao implementar uma classe, recomenda-se que os atributos sejam privados
(private), mantendo estes atributos ocultos, impedindo que outros objetos os
acessem, protegendo os objetos como caixas pretas, com sua comunicação
apenas através de mensagens (chamada dos métodos). A classe Cliente no
exemplo anterior já possui dados privados.
- Os métodos também podem ser private, o que os torna acessíveis apenas
por outros métodos da mesma classe. Estes métodos ocorrem normalmente
quando se divide um método público em vários módulos de tarefas específicas.
- É recomendável encapsular tarefas internas das classes do sistema em
métodos privados, para que possam ser modificadas minimizando as mudanças
no lado do usuário, sem mexer na interface com o usuário.
Métodos Acessadores (getters) e Modificadores (setters)
- Acessadores são métodos que simplesmente retornam o estado atual de um
campo private do objeto. Por convenção, os nomes iniciam com o prefixo
―get‖.
Por exemplo, digamos que na nossa classe Empregado, quiséssemos um
método para nos retornar o número da conta do cliente:
public int getNumConta ()
{ return numConta; //o get retorna
}
A partir de agora, com este método, tornamos o campo numConta um campo
de ―somente-leitura‖ para o mundo exterior à classe, ou seja, só através de
operações na classe é possível modificar o seu valor.
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
36
Um método modificador para este mesmo campo poderia ser:
public void setNumConta (int novoNumero)
{ numConta = novoNumero; //o set modifica
}
Em geral, quando o usuário tem interesse em ler e escrever em um campo
private, o programador poderá fornecer (se estiver de acordo com o projeto):
o Um método público de leitura de campo (acessador get);
o Um método público de alteração de campo (modificador set).
Inicialização de atributos
- Em Java, se o construtor do objeto não indicar o valor para inicialização dos
campos de instância, os números são inicializados com 0 (zero), objetos com
null e booleanos com false, mas as variáveis locais dos métodos precisam
ser inicializadas explicitamente
Referência ao Objeto Através de this
- Para acessar o objeto atual em sua totalidade e o não atributo em particular,
usamos this:
1. Fazendo referência ao objeto no qual o método opera.
System.out.println (this);
//mostra apenas o endereço do objeto
//usaremos isto no tratamento de eventos
//no próximo capítulo
2. Chamada para outro construtor da mesma classe. É um excelente
artifício para combinar código dos construtores.
Veja um exemplo completo, mostrando vários usos do this:
public class Cliente
{ public Cliente(String n) //sobrecarga
{ this(n,0 );
}
//argumento com mesmos nomes dos atributos
public Cliente(String nome, int numConta)
{
this.nome = nome; //atributo=argumento
this.numConta = numConta;
}
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
37
public int getNumConta ()
{ return numConta;
}
public void setNumConta (int numConta)
{ this.numConta = numConta;
}
private String nome;
private int numConta;
}
Ao fazer new Cliente (“Joe Satriani”), o construtor
Cliente(String) chama o outro construtor Cliente(String, int).
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
38
5.2. Os principais modificadores [FS]
A) Modificadores de Classes
- public
o Classes public podem ser instanciadas por qualquer objeto livremente.
o Para declarar uma classe como public, inclua a palavra reservada
public na definição da classe (esta é a convenção):
public class NomeClasse
- abstract
o Classes abstract são classes que não permitem que sejam
instanciadas, ou seja, servem para definir superclasses.
o Para declarar uma classe como abstract, inclua a palavra reservada
abstract na definição da classe:
public abstract class NomeClasse
- final
o Classes final são classes que não permitem que você crie subclasses
delas. Para declarar uma classe como final, inclua a palavra reservada
final na definição da classe:
public final class NomeClasse
B) Modificadores de Métodos e Atributos
- public
o Faz com que o método ou atributo possa ser utilizado livremente, como
em (na definição da classe Empregado):
public double calc ()
- protected
o Faz com que o método ou atributo somente possa ser invocado
pelas classes do mesmo pacote, ou seja, para classes dentro do
mesmo pacote é o mesmo que public (em Java é mais comum
proteger/encapsular com private). As subclasses podem acessar
os membros protected, mesmo que estejam em outros pacotes.
protected double calc ()
- private
o Faz com que o método ou atributo somente possa ser invocado na
classe em que é definido. Mas as instâncias da classe podem acessar
os atributos em outras instâncias da mesma classe, ou seja, private
é concernente à classe e não às instâncias. Uma subclasse não
acessa atributos nem métodos private da superclasse.
private double calc ()
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
39
- static
o Métodos e atributos static podem ser considerados como
pertencentes à classe e não às instâncias. Um membro static pode
ser invocado por todas as instâncias da classe, ou mesmo sem a
instanciação de um objeto, como é o caso do método main na criação
de um aplicativo:
public static void main (String[] args)
- final
o Métodos final não permitem sobreposição. Atributos final
possuem valor constante, ou seja, não podem ser modificados.
public static final double LUCRO = 0.2;
- abstract
o Métodos abstract não possuem
corpo, apenas definem a assinatura
do método e indicam que devem ser implementados nas subclasses.
Métodos static, final e private não podem ser abstratos, não faz
sentido reescrevê-los em subclasses, isto é considerado erro de
sintaxe.
public abstract double calc();
- Default
o Um membro sem modificador de acesso definido é dito possuir o
modificador default. Mas ―default‖ não é uma palavra-chave em Java, é
apenas uma denominação. Na prática, o acesso funciona normalmente
como o public, mas se estiverem definidos pacotes diferentes para
as classes, o modificador default só permite o acesso para classes
dentro do mesmo pacote, ou seja, neste caso funciona como
protected. O conselho então é definir bem os modificadores de
acesso, escreva todos, mesmo que sejam public. Em Java é uma
boa prática de programação deixar tudo muito claro e definido.
Hierarquia de Modificadores na Sobreposição de Métodos
- A ordem a ser respeitada é:
private default protected public
ou seja, um método private pode ser reescrito nas subclasses com os
modificadores private, default (sem modificador), protected e public,
um método default pode ser reescrito nas subclasses com os modificadores
default, protected e public, e assim por diante.
- Para maiores informações sobre modificadores, leia o capítulo 3 do ―Sybex
Complete Java Certification Study Guide‖.
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
40
Sintaxe de declaração de atributos
Sintaxe básica:
[modificador]* tipo identificador [= valor] ;
onde:
[modificador]* – zero ou mais modificadores (de acesso, de qualidade), separados
por espaços: public, private, static, final, etc.
tipo – tipo de dados que a variável (ou constante) pode conter
identificador – nome da variável ou constante
[= valor] – valor inicial da variável ou constante
Exemplo:
protected static final double PI = 3.14159 ;
int numero;
Sintaxe de definição de métodos
Sintaxe básica
[mod]* tipo identificador ( [tipo arg]* ) [throws exceção*] { ... }
onde:
[mod]* – zero ou mais modificadores separados por espaços
tipo – tipo de dados retornado pelo método
identificador – nome do método
[arg]* – zero ou mais argumentos, com tipo declarado,
separados por vírgula
[throws exceção*] – declaração de exceções. Estudaremos mais adiante.
Exemplos
public static void main ( String[] args ) { ... }
private final int metodo (int i, int j, int k) ;
String abreArquivo () throws IOException, Excecao2 { ... }
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
41
6. Mais POO em Java – Herança e Polimorfismo
6.1. Herança [AC]
Ao estender uma classe, a classe filha passa a possuir todos os atributos e
métodos da classe mãe, além dos seus próprios. Pode-se também adicionar ou
modificar métodos que se aplicam apenas a esta classe filha. Então, a classe
filha "herda" métodos e propriedades da classe mãe.
Vejamos um exemplo:
Suponha que numa firma hipotética, os empregados sejam identificados por
suas matrículas e nomes. Há, porém, dois tipos de empregados: os vendedores e os
técnicos. Os vendedores têm uma comissão sobre o salário e os técnicos têm um
título (advogado, engenheiro, etc.).
Graficamente, pode-se representar este sistema desta forma:
- O vendedor tem, além de matrícula, nome, e salário, uma quarta informação,
a porcentagem de comissão, ou seja, podemos dizer que um objeto da classe
Vendedor herda os atributos da classe Empregado.
- Implementando este projeto em Java, da forma mais simples, temos:
Classe construtora Empregado:
public class Empregado
{
String matricula;
Empregado
matricula
nome
salario
Vendedor
comissao
Tecnico
titulo
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
42
String nome;
double salario;
}
Classe construtora Vendedor:
public class Vendedor extends Empregado
{
double comissao;
}
Classe construtora Tecnico:
public class Tecnico extends Empregado {
String titulo;
}
- Podemos observar que os atributos matricula, nome e salario foram
definidos na classe Empregado (também chamada superclasse), e as
classes Vendedor e Técnico (também chamadas subclasses) utilizam tais
atributos, pois os herdam da super classe da qual são derivadas.
- No código acima, criamos a classe Vendedor por herança da classe
Empregado utilizando o nome desta após a instrução extends:
public class Vendedor extends Empregado
- Qualquer modificação na classe Empregado refletirá na classe Vendedor
(bem como na classe Tecnico). Por exemplo, a alteração do atributo
matricula de String para int altera este dado também nas subclasses.
Para completar o exemplo, só falta a classe que instanciará os objetos das
classes Empregado, Vendedor e Técnico. Para utilizar os atributos e métodos
definidos em uma classe, precisamos utilizar um objeto desta classe, o que significa
dizer que precisamos instanciar um objeto desta classe.
A classe que instanciará os objetos será chamada de Firma, tendo seu código-fonte
definido a seguir:
public class Firma
{
public static void main(String[] args)
{
Empregado e; //declarações
Vendedor v;
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
43
Tecnico t;
e = new Empregado(); //instanciações
v = new Vendedor();
t = new Tecnico();
e.nome = "João"; //inicializações dos atributos
e.matricula = "E1";
e.salario = 100.00;
v.nome = "Pedro";
v.matricula = "V1";
v.salario = 500.00;
v.comissao = 20;
t.nome = "José";
t.matricula = "T1";
t.salario = 900.30 ;
t.titulo = "Dr. ";
System.out.println ("Matrícula: "+ e.matricula +
" Nome: “ + e.nome +
" Salário: R$" + e.salario);
System.out.println ("Matrícula: "+ v.matricula +
" Nome: " + v.nome + " Salário: R$" +
v.salario + "(já incluída a comissão de:
" + v.comissao + "%)");
System.out.println ("Matrícula: "+ t.matricula +
" Nome: " + t.titulo + t.nome +
" Salário: R$" + t.salario);
}
}
Salve-o como Firma.java, compile-o (as outras classes serão compiladas
automaticamente) e execute com sua ferramenta.
6.2. Uso de Classes Existentes
Podemos usar classes existentes nos nossos projetos, bastando para isso
saber a sintaxe de seus métodos, como no exemplo anterior:
- Na maior parte das classes Java, criam-se objetos, especifica-se o estado inicial
de cada um e depois se trabalha com estes objetos. E para acessar os objetos,
define-se variáveis objeto. Veja:
Empregado e;
// „e‟ não é objeto ainda nem se refere a nenhum
//objeto
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
44
e.calculaAumentoAnual(); // NÃO AINDA !!!!!! ERRO!!!
e = new Empregado(); // agora sim ! Existe o objeto e
e.nome = "João"; //OK
e.matricula = "E1";
e.salario = 100.00;
6.3. Relações entre Classes
- Relações mais comuns:
o Uso: quando uma classe usa objetos de outra classe. No exemplo
anterior, Firma usa objetos de Empregado.
De um modo geral, uma classe A usa uma classe B se um
método de A envia
uma mensagem para um objeto da classe B,
ou se um método de A cria, recebe ou retorna objetos da classe
B.
O uso desta relação deve ser minimizado, visando independência
de funcionamento entre as classes, facilitando a manutenção do
código.
o Inclusão (“tem um”): ocorre quando um atributo de uma classe é um
objeto de outra classe.
Exemplo : Imagine uma Classe Endereco, que possui os atributos :
logradouro, numero, complemento, bairro, cidade, estado, cep.
Pode-se ter outra classe Funcionario, que tenha como
Endereco como um de seus atributos.
o Herança (“é um”): denota especialização ou generalização. É quando
uma classe estende outra. Vendedor é um Empregado.
6.4. Polimorfismo
Voltando ao assunto Herança, veremos um conceito muito importante, o de
Polimorfismo.
No nosso exemplo Firma, o vendedor deve ter X% de comissão. Suponha
então que seja necessária a construção de um método que calcule o salário de
todos os empregados, descontando 15% de imposto.
Por exemplo, se o salário de:
Empregado = 200;
Vendedor = 200; //Salário-base
Tecnico = 2.000;
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
45
Supondo uma comissão de 20% , o salário de Vendedor seria:
Vendedor = 240; // 200 + 20% = 200 + 40 = 240
Calculando o salário líquido de cada um:
Empregado = 170 // 200-15% = 200-30
Vendedor = 204 // 240-15% = 240-36
Tecnico = 1700 // 2.000-15% = 2.000- 300
O método para cálculo do salário para a classe Empregado pode ser:
public double calc()
{ return ( 0.85 * salario ); //desconto de 15%
}
E esse método será herdado pela classe Tecnico. Porém, a classe
Vendedor deverá implementar seu próprio método:
public double calc()
{
double sal = salario * (1 + comissao/100);
//aumento de 20%
return ( 0.85 * sal);
//desconto de 15%
}
Graficamente, os métodos são representados separadamente dos atributos,
na parte inferior.
Desta forma, poderíamos reescrever os códigos para um novo exemplo:
Empregado
matricula
nome
salario
calc()
Vendedor
comissao
calc()
Tecnico
titulo
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
46
public class Empregado
{
String matricula;
String nome;
double salario;
public double calc ()
{
return (0.85 * salario);
}
}
public class Vendedor extends Empregado
{
double comissao;
public double calc ()
{
double sal = salario * (1 + comissao/100);
return (0.85 * sal);
}
}
public class Firma
{
public static void main(String args[])
{
Empregado e;
Vendedor v;
Tecnico t;
e = new Empregado();
v = new Vendedor();
t = new Tecnico();
e.nome = "João";
e.matricula = "E1";
e.salario = 100.00;
v.nome = "Pedro";
v.matricula = "V1";
v.salario = 500.00;
v.comissao = 20;
t.nome = "José";
t.matricula = "T1";
t.salario = 900.30 ;
t.titulo = "Dr. ";
System.out.println ("Matrícula: "+ e.matricula +
" Nome: “ + e.nome +
" Salário: R$" + e.calc() );
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
47
System.out.println ("Matrícula: "+ v.matricula +
" Nome: " + v.nome + " Salário:
R$" + v.calc() + "(já incluída a
comissão de: " + v.comissao +
"%)");
System.out.println ("Matrícula: "+ t.matricula +
" Nome: " + t.titulo + t.nome
+ " Salário: R$" + t. calc());
}
}
Então, Polimorfismo é a capacidade que os métodos de mesmo nome têm de
efetuarem tarefas diferentes.
Polimorfismo: um mesmo método com várias formas.
O polimorfismo acontece quando os métodos são definidos em classes em
herança (sobreposição)
No nosso caso, o método calc efetua um cálculo quando utilizado pelos
objetos das classes Empregado e Tecnico, e outro cálculo quando o objeto em
questão foi instanciado da classe Vendedor.
Pode-se observar que tanto Empregado como Tecnico utilizam o método
calc para cálculo do trabalho, e que Vendedor, apesar de utilizar o método
calc, utiliza o seu próprio método, com corpo diferente daquele definido na
classe ancestral Empregado.
Resumindo o conceito de Polimorfismo:
Reutilização do mesmo nome para um
conceito correlato em tipos diferentes.
Não confunda !
o Sobreposição (Overriding) comparação feita em tempo de
execução que pergunta ―Qual método foi definido para este tipo de
objeto? Existe uma redefinição deste método na classe do objeto ou
deve ser usado o método definido na superclasse?‖.
o Sobrecarga (Overloading) comparação feita em tempo de
compilação que pergunta ―Qual método possui os tipos de argumentos
correspondentes?‖ e escolhe o método que será usado. Recurso usado
no caso de métodos de mesmo nome, definidos em uma mesma
classe, com argumentos diferentes.
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
48
6.5 . Uso de SUPER
O comando super sempre se refere a uma superclasse. Todo método
construtor de uma subclasse precisa também chamar um construtor para os
campos de dados da superclasse, caso existam campos de instância também na
superclasse.
Se a superclasse tiver um construtor então as subclasses precisam usar
super para passar os parâmetros, a fim de utilizar este construtor da
superclasse.
super também pode ser usado para passar parâmetros para métodos da
superclasse, utilizando o código deste, sem ter que redefinir totalmente o
método, por exemplo, na linha super.calc (); do exemplo a seguir.
- Exemplo Firma utilizando encapsulamento, polimorfismo, super e this:
public class Empregado
{
private String matricula, nome;
private double salario;
public Empregado (String m, String n, double s)
{ matricula = m;
nome = n;
salario = s;
}
public Empregado (String m, String n)
{ this(m, n, 0 ); //sobrecarga salário não definido
}
public double calc () {
return (this.getSalario() * 0.85);
}
//getters & setters
public String getMatricula()
{ return matricula; }
public void setMatricula(String matricula)
{ this.matricula = matricula; }
public String getNome()
{ return nome; }
public void setNome(String nome)
{ this.nome = nome; }
public double getSalario()
{ return salario; }
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
49
public void setSalario(double salario)
{ this.salario = salario; }
}// fim classe Empregado
public class Vendedor extends Empregado
{
private double comissao;
public Vendedor(String m, String n, double s, double c)
{ super(m, n, s);
this.comissao = c;
}
public double calc ()
{ return super.calc() * (1 + this.comissao / 100); }
//getters & setters
public double getComissao()
{ return comissao; }
public void setComissao(double comissao)
{ this.comissao = comissao; }
} // fim classe Vendedor
public class Tecnico extends Empregado
{
private String titulo;
public Tecnico(String m, String n, double s, String t)
{
super(m, n, s);
this.titulo = t;
}
//getters & setters
public String getTitulo()
{ return titulo; }
public void setTitulo(String titulo)
{ this.titulo = titulo; }
} // fim classe Tecnico
import java.util.Formatter
public class Firma
{
public static void main(String[] args)
{
Empregado e = new Empregado("E1","João",100);
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
50
Vendedor v = new Vendedor("V1","Pedro",500,0.2);
Tecnico t = new Tecnico("T1","José",930,"Dr. ");
System.out.format("\nMatricula: %s
\nNome: %s \nSalario:R$ %.2f \n ",
e.getMatricula(), e.getNome(), e.calc());
System.out.format("\nMatricula: %s
\nNome: %s \nSalario:R$ %.2f
\nComissao de %.0f por cento\n",
v.getMatricula(), v.getNome(),
v.calc(), v.getComissao()*100);
System.out.format("\nMatricula: %s
\nNome: %s \nSalario:R$ %.2f \n ",
t.getMatricula(), t.getNome(), t.calc());
}
}
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
51
6.6. Relacionamento entre objetos da superclasse e objetos
da subclasse [JTAS]
O objeto de uma subclasse pode ser tratado como um objeto de sua
superclasse. Isso é validado pela própria condição de herança e pode ser
interessante, se for desejável, por exemplo, criar um vetor com objetos das
subclasses.
Não é possível, no entanto, fazer um objeto de uma subclasse receber um
objeto da superclasse. Isso configura erro de sintaxe.
No exemplo da classe Ponto e sua subclasse Circulo, que veremos a seguir,
foi usado o operador cast. Este operador converte a expressão do seu lado
direito no tipo da variável ou objeto do lado esquerdo de uma atribuição.
(tipo) expressao ou (Classe) expressao
Se tivermos, por exemplo,
int x = 5;
O cálculo x/2 dará o inteiro 2 (quociente da divisão com /).
O cálculo de (double)x/2 dará 2.5, pois x foi convertido para double.
Exemplo : Vejamos agora as classes Ponto e Circulo
Classe Ponto
public class Ponto {
protected int x, y; // variáveis de instância
public Ponto() { setPonto(0,0); }
public Ponto(int xc, int yc) { setPonto(xc,yc); }
public void setPonto(int xc, int yc) {
x = xc;
y = yc;
}
public int getX() { return x; }
public int getY() { return y; }
public String toString() {
return "[ " + x + " , " + y + "]";
}
}
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
52
Classe Circulo
public class Circulo extends Ponto {
protected double raio;
public Circulo() { setRaio(0); }
public Circulo(double r, int x, int y) {
super(x,y);
setRaio(r);
}
public void setRaio(double r) {
raio = (r >= 0.0 ? r : 0.0);
}
public double getRaio() { return raio; }
public double getArea() {
return (Math.PI * Math.pow(raio,2));
}
public String toString() {
return "Centro = " + "[ " + x + " , " + y + "]"
+ "; Raio = " + raio;
}
}
Arquivo : TestaHeranca_e_Cast
public class TestaHeranca_e_Cast {
public static void main(String[] args) {
Ponto p1, p2;
Circulo c1, c2;
p1 = new Ponto(30,50);
c1 = new Circulo(2.7, 120, 89);
String saida = "Ponto p1 : " + p1.toString() +
"\nCirculo c1 : " + c1.toString();
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
53
// Atribui objeto da subclasse a um objeto da superclasse
// Ocorrerá vinculação dinâmica ou vinculação tardia . Ou seja,
// Java sabe que o objeto na verdade é um círculo.
// Por isso, o método toString() invocado é o da classe Circulo.
p2 = c1;
saida += "\n\nCirculo c1 (atraves da referencia p2) " + p2.toString();
saida += "\n\nCirculo c1 (atraves da referencia c1) " + c1.toString();
// É um cast, mas especificamente, um downcasting (cast para a
// subclasse), ou seja, (Circulo)
// NOTE : obj. da subclasse c2 recebe obj. da superclasse p2, pois p2
// havia recebido, primeiramente, um objeto da subclasse, ou seja,
// p2 na verdade referencia um circulo e não um ponto.
c2 = (Circulo) p2; //Converte p2 para c2 apenas neste momento
saida += "\n\nCirculo c1 (via c2) : " + c2.toString();
// ERRO de sintaxe na próxima linha : objeto da subclasse recebe obj.
// da superclasse. Nem que haja cast será possível !!!
//c2 = (Circulo)p1; // ERRO !!!!!
System.out.print(saida + "\n\n");
} // fim main
} // fim classe
Comentário :
Lembre-se de que os construtores nunca são herdados, pois são específicos
da classe onde são definidos.
6.7. Classes Abstratas [AC]
Ao subir na hierarquia de heranças, as classes tornam-se mais genéricas. A
classe ancestral pode tornar-se tão geral que acaba sendo vista mais como um
modelo para outras classes, do que como uma classe com instâncias
específicas.
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
54
Uma classe declarada abstrata não pode ser instanciada, nenhum objeto
desta classe pode ser criado.
Se a classe abstrata contém um método abstrato, deve-se implementar o
método concreto (com todo o código) nas subclasses. Os métodos abstratos
servem apenas como declaração dos métodos concretos.
Quando uma subclasse de uma classe abstrata não implementa todos os
métodos abstratos que herda, ela também é abstrata, não podendo, portanto, ser
instanciada.
Métodos static, private e final não podem ser abstract. A
justificativa é a seguinte :
1. por definição, um método final não pode ser sobrescrito na subclasse;
2. por definição, um método private só pode ser acessado na classe onde foi
escrito
3. métodos static não podem ser sobrepostos.
Uma classes abstrata pode ter: [item de FS]
métodos concretos (usados através das subclasses)
campos de dados (memória é alocada na criação de objetos pelas suas
subclasses)
construtores (chamados via super( ) pelas subclasses)
Uma classe abstrata é dita "pura", quando :
não têm procedimentos no construtor (construtor vazio)
não têm campos de dados (a não ser constantes estáticas - static)
todos os métodos são abstratos
Classes abstratas "puras" podem ser definidas como "interfaces" , que
estudaremos mais adiante.
No nosso exemplo Firma, se definíssemos a classe Empregado como
abstract, não poderíamos instanciar objetos desta classe, e a mesma serviria
apenas como modelo para Vendedor e Tecnico (tente modificar o código,
retirando também a instanciação de Empregado).
No exemplo a seguir, para termos um vetor de formas (Circle, Retangle,
etc), definimos uma classe abstrata Shape, com métodos abstratos apenas.
Poderemos então criar um array de objetos Shape.
O código de Shape é:
public abstract class Shape
{ public abstract double area
();
public abstract double total ();
// outros métodos poderiam ser incluídos aqui,
// sendo abstract ou não
}
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
55
Usando estas classes, poderíamos utilizar um código como, por exemplo:
Shape[] formas = new Shape[3]; //Cria array
formas[0] = new Circle (2.0); //Preenche array
formas[1] = new Rectangle (1.0, 3.0);
formas[2] = new Rectangle (4.0, 2.0);
double totalArea = 0;
for (int i = 0; i < formas.length; i++)
totalArea += formas[i].area();
Veja o código das outras classes (compile-as junto com a classe Shape
anterior):
public class Circle extends Shape
{
private double r;
public Circle (double r) //Construtor
{ this.r = r; }
public double getRadius () { return r; }
public double area () //Implementa o abstrato
{ return (Math.PI*r*r);}
public double total () //circunferencia
{ return (2*Math.PI*r); }
}
public class Rectangle extends Shape
{
public Rectangle (double w, double h)
{ this.w = w; this.h = h;
}
public double getWidth () { return w; }
public double getHeight () { return h; }
public double area () { return (w*h); }
public double total () //Perimetro
{ return (2*(w+h)); }
private double w, h;
}
- Pode-se invocar os métodos area() e total() de qualquer
objeto Shape do array, embora a classe Shape não defina um corpo para
estes métodos. Quando se faz isso, o método a ser invocado é encontrado
como método dinâmico, a área de um Circle é calculada usando o método
definido em Circle e a área de um Rectangle é calculada usando o
método definido em Rectangle.
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
56
6.8. Interface [AC]
Uma classe Java pode herdar de apenas uma classe imediata. Para uma
classe herdar de mais de uma superclasse (o que em C++ se chama Herança
Múltipla), a solução elegante de Java se chama Interface de Objeto. Ou seja, uma
classe pode estender apenas uma superclasse, mas pode implementar várias
interfaces (usa-se a palavra-chave implements e o separador ―,‖).
Uma Interface deve ser definida de forma parecida à das classes abstratas,
trocando os termos abstract class por interface.
Uma interface especifica uma API (Application Programing Interface) para
executar determinada funcionalidade. Não é definida nenhuma implementação
dentro de uma interface e as seguintes regras devem ser seguidas :
o Todos os métodos de uma interface são abstract, mesmo que
seja omitido o modificador na assinatura. Não há implementação, os
métodos terminam com ponto e vírgula.
o Uma interface define uma API pública. Todos os métodos de uma
interface são implicitamente public, mesmo quando o modificador é
omitido. É um erro definir um método protected ou private em
uma interface.
o Uma interface não pode definir campos de instância. São
permitidos apenas os campos constantes (static e final).
o Uma interface não pode ser instanciada.
o Quando uma classe implementa mais de uma interface, ela deve
implementar cada método de cada interface implementada, ou
deve ser obrigatoriamente uma classe abstract.
Exemplo [Fonte : Como Programar em Java –Deitel & Deitel]
// Projeto : FormasComInterface
// Arquivo : FormasComInterface.java
import java.util.Formatter;
public class FormasComInterface {
public static void main(String[] args) {
Ponto p = new Ponto(7,11);
Circulo c = new Circulo(3.5, 22, 8);
Shape f[] = new Shape[2]; // declara e cria um vetor para duas Shapes
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
57
f[0] = p;
f[1] = c;
String saida = p.getNome() + " : " + p.toString() + "\n" +
c.getNome() + " : " + c.toString() + "\n";
for (int i = 0; i < f.length; i++)
{
System.out.format("\n\n%s : %s \nArea = %.2f\n",
f[i].getNome() ,
f[i].toString() ,
f[i].area() );
}
System.out.println();
}
}
// Arquivo : Shape.java
public interface Shape {
//calcula area
public abstract double area();
// retorna o nome
public abstract String getNome();
}
// Arquivo : Ponto.java
public class Ponto extends Object implements Shape{
protected int x, y; // variáveis de instância
public Ponto() { setPonto(0,0); }
public Ponto(int xc, int yc) { setPonto(xc,yc); }
public void setPonto(int xc, int yc) {
x = xc;
y = yc;
}
public int getX()
{
return x;
}
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
58
public int getY() { return y; }
public String toString() {
return "[ " + x + " , " + y + "]";
}
public double area() {
return 0.0;
}
public String getNome() {
return ("Ponto");
}
}
// Arquivo : Circulo.java
public class Circulo extends Ponto {
protected double raio;
public Circulo() {
setRaio(0);
}
public Circulo (double r, int x, int y) //Construtor
{
super(x,y); // invoca o construtor da superclasse Ponto
setRaio(r);
}
public void setRaio (double r) {
raio = r;
}
public double getRaio () //Acessador
{
return raio;
}
public double area () //Implementa o abstrato
{
return (Math.PI*raio*raio);
}
public double perimetro () {
return (2*Math.PI*raio);
}
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
59
public String getNome() {
return "Circulo";
}
// Converte Circulo para uma representação de String,
// usando o método toString() da classe Ponto
public String toString()
{
return "Centro = " + super.toString() //invoca o método do pai
+ "; Raio = " + raio ;
}
}
Comentários :
1. Quando uma classe implementa uma interface, aplica-se o mesmo
relacionamento ―é um ― fornecido por herança. Por exemplo, como a classe Ponto
implementa (implements) Shape, um objeto da classe Ponto é um Shape. Além
disso, qualquer objeto de qualquer classe que estende Ponto, também um Shape.
2. O método toString() é definido na classe Object da seguinte forma :
String toString() retorna uma representação de string do objeto
Note que ele foi sobreposto nas classes vistas.
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
60
7. Exceções [FS , Prof. Letícia Winkler e JTAS]
7.1. Introdução
Uma exceção é um evento que foge ao fluxo normal de execução esperado
em um programa. É uma situação excepcional e geralmente indesejável que pode
ocorrer durante a execução de um programa. Exceções podem ser tratadas
incluindo-se código adequado no programa. Portanto, erros fatais não podem ser
tratados como exceção.
Alguns exemplos de exceções são:
Índice de um vetor fora
do intervalo permitido.
Problemas em operações aritméticas, tais como overflow, underflow e
divisões por zero.
Parâmetros inválidos na chamada de um método.
Falta de memória.
Arquivo não encontrado
O mecanismo de tratamento de exceção deve ser utilizado, por exemplo, para
processar apenas situações excepcionais em que um método é incapaz de
completar sua tarefa por razões que ele não pode controlar.
O modelo de tratamento de exceções do Java permite tratar uma exceção num
escopo diferente daquele que gerou a exceção. Isto permite uma melhor
organização do código. Em Java, existem várias classes de exceções, todas elas
subclasses de java.lang.Exception.
Métodos podem capturar exceções (Mecanismo try-catch) ou podem deixar
passar exceções que ocorrerem em seu corpo, mas é obrigatório, para a maior parte
das exceções, que o método declare quaisquer exceções que ele não capturar
(usar throws).
7.2. Tipos de erros em tempo de execução
Basicamente, há três tipos de erros em tempo de execução :
1. Erros de lógica de programação : Devem ser corrigidos pelo programador
Ex: limites do vetor ultrapassados, divisão por zero
2. Erros devido a condições do ambiente de execução : Fogem do controle do
programador, mas podem ser contornados em tempo de execução
Ex: arquivo não encontrado, rede fora do ar, etc.
3. Erros graves onde não adianta tentar recuperação : Fogem do controle do
programador e não podem ser contornados .
Ex: falta de memória, erro interno da JVM
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
61
7.3. Exceções e métodos
Uma declaração throws (observe o "s") é obrigatória em métodos e
construtores que deixam de capturar uma ou mais exceções que ocorrem em seu
interior, caso tais exceções precisem ser checadas pelo compilador.
Ex: public void m() throws Excecao1, Excecao2 {...}
public Circulo() throws ExcecaoDeLimite {...}
A palavra reservada throws declara que o método pode provocar exceções do
tipo declarado (ou de qualquer subtipo).
A declaração abaixo declara que o método pode provocar qualquer exceção.
Evite ao máximo de fazer isto !
Ex: public void m( ) throws Exception {...}
Métodos sobrepostos não podem provocar mais exceções que os métodos
originais.
O que acontece quando ocorre uma exceção?
Uma exceção lançada interrompe o fluxo normal do programa, o que faz com
que o fluxo do programa siga a exceção. Se o método onde ela ocorrer não a
capturar, ela será propagada para o método que chamou este método, e assim por
diante. Se ―ninguém‖ capturar a exceção, ela irá causar o término da aplicação. No
entanto, se em algum lugar ela for capturada, o controle poderá ser recuperado.
7.4. Estrutura do Mecanismo de Tratamento de Exceções
try {
// Código que pode gerar uma exceção.
// Se a exceção ocorrer, daqui até o fim deste bloco nada será executado
}
catch (XException ex)
{
/* Bloco de tratamento associado à condição de exceção XException ou a qualquer
uma de suas subclasses, identificada aqui pelo objeto com referência ex */
}
catch (YException ey)
{
/* Bloco de tratamento para a situação de exceção YException ou a qualquer uma de
suas subclasses, identificada aqui pelo objeto com referência ey */
}
… // outros blocos catch
finally {
/* Bloco de código que sempre será executado após o bloco try, independentemente de
sua conclusão ter ocorrido normalmente ou ter sido interrompida.
Só é obrigatório se não forem especificados blocos catch */
}
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
62
Observações:
XException e YException devem ser substituídos pelo tipo de exceção.
Os blocos não podem ser separados por outros comandos — um erro de
sintaxe seria detectado pelo compilador Java neste caso.
Cada bloco try pode ser seguido por zero ou mais blocos catch;
Cada bloco catch refere-se a uma única exceção e pode tratar de qualquer
exceção que seja da mesma classe ou uma subclasse daquela declarada.
Pode-se chamar cada bloco de catch de tratador de exceção, já que quando
possível o bloco catch tentará recuperar a situação.
É possível fazer um bloco catch para uma exceção específica e outro para
todas as outras subclasses de uma determinada Exception. Porém, é
necessário que o catch mais específico (subclasse) apareça antes que o
catch mais genérico (superclasse). Caso contrário o programa não irá
compilar, apresentando uma mensagem de erro dizendo que a exceção já é
tratada anteriormente.
O bloco finally, quando presente, é sempre executado independente de
ocorrer exceção, ou não. Em geral, ele inclui comandos que liberam recursos
que eventualmente possam ter sido alocados durante o processamento do
bloco try e que podem ser liberados, independentemente de a execução ter
encerrado com sucesso ou ter sido interrompida por uma condição de
exceção. A presença desse bloco é opcional.
Tanto a cláusula finally como a catch são opcionais, porém é necessário ter
pelo menos uma delas para cada bloco try.
Quando ocorre uma exceção, o fluxo de execução de instruções deixa o bloco
do try, e os blocos de catch são pesquisados em ordem, quanto ao tratador
apropriado. Se o tipo da exceção lançada corresponder ao tipo de parâmetro em um
dos blocos catch, o código deste bloco catch é disparado. Se não ocorrer exceção
dentro do bloco try, os tratadores de exceção são pulados e o programa continua
seu fluxo após os blocos catch, que poderá ser (caso exista) o bloco finally
Lembre-se: Se uma classe mais geral (ex: Exception) aparecer antes de uma ou
mais classes específicas (subclasses), uma exceção do tipo da específica jamais
será capturada . O compilador detecta a situação acima e não compila o código
Para pegar qualquer exceção (geralmente isto não é recomendado), faça um
catch que pegue Exception. Exemplo : catch (Exception e) { ... }
Exemplo em que se captura uma exceção :
public class HelloWorld
{
public static void main (String args[])
{
int i;
String msgs [] = {"Aula", "de", ―POOII" };
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
63
i = 0;
while (i < 4)
{
try {
System.out.println (msgs[i]);
i++;
}
catch (ArrayIndexOutOfBoundsException e)
{ System.out.println("Indice fora do limite");
break;
}
finally
{
System.out.println("Vai imprimir sempre esta frase !!! ");
} // fim finally
} // fim while
} // fim main
} // fim class HelloWorld
Muitas classes de biblioteca possuem métodos que podem lançar exceções.
Estas exceções podem ser capturadas por um código escrito pelo programador.
Além disto, métodos escritos pelo programador também podem lançar exceções
(throw), tanto de tipos definidos nas bibliotecas como de novos tipos construídos
pelo programador.
Exemplo em que se lança uma exceção com throw (sem „s‟ ) :
Às vezes, após a captura de uma exceção, é desejável relançá-la para que
outros métodos lidem com ela. Isto pode ser feito da seguinte forma:
public void metodo() throws ExcecaoSimples
{
try {
// instruções
}
catch (ExcecaoSimples ex)
{
// faz alguma coisa para lidar com a exceção
throw ex; // lança exceção
} // fim catch
} // fim metodo
Tipo de
exceção
Prof
a
. Jane Programação Orientada a Objetos I
I (Linguagem Java)
64
Exemplo : Avisar que as exceções podem ocorrer (throws). Neste caso, a
exceção não foi lançada e nem capturada. Portanto, ocorrerá erro na
excecução.
public class Teste
{
public static void main(String args[]) throws ArrayIndexOutOfBoundsException
{
int i = 0;
String msgs [] = {"Aula"," de"," POOII" };
while (i < 4)
{
System.out.println ("i = " + i + msgs[i]);
i++;
}
}// fim main
} // fim classe
Exemplo : Uma exceção pode ser lançada para outro método a tratar, caso ele
seja programado para isso.
Lançar uma exceção com throw, passa a responsabilidade para o método
que disparou este trecho.
public class TesteExcecao
{
static int i = 0;
static String msgs [] = { " Hello world!", " Alo mundo!", " Estacio de Sa"};
public static void escrever() throws ArrayIndexOutOfBoundsException
{
try {
while (i < 4)
{
System.out.println ("i = " + i + msgs[i]);
i++;
}
}
catch (ArrayIndexOutOfBoundsException e)
{
System.out.println("Lancei a exceção");
throw e; // lança a exceção
}
} // fim escrever
public static void main(String args[]) // Ocorrerá erro na exceução {
escrever();
}// fim main
} // fim classe
Objeto e
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
65
Para que o erro não ocorra, seria necessário, já que a programação foi mal
feita, capturar a exceção na main.
As exceções podem ser de dois tipos:
Exceções verificadas (checked). Neste caso, a exceção obrigatoriamente terá
que ser capturada (try/catch) ou pelo menos, declarada com throws.
Exceções de runtime, ou exceções não-verificadas (uncheked). Neste caso
na linguagem Java não é exigido o tratamento da exceção e nem que a
mesma seja declarada com throws. Por exemplo, para testar o limite de um
vetor, basta programar corretamente, o que é o mais adequado. Mas se
desejado, pode-se declarar a exceção com throws ou capturá-la com
try/catch.
Uma exceção em Java é um objeto. A classe raiz de todas as exceções é
java.lang.Throwable. Apenas objetos dessa classe ou de suas classes derivadas
podem ser gerados, propagados e capturados através do mecanismo de tratamento
de exceções.
A classe Throwable tem duas subclasses:
java.lang.Exception
É a raiz das classes derivadas de Throwable que indica situações que a
aplicação pode querer capturar e realizar um tratamento que permita
prosseguir com o processamento. Provê alguns métodos muito úteis para
obter informações sobre uma exceção, tais como o printStackTrace().
java.lang.Error
É a raiz das classes derivadas de Throwable que indica situações que a
aplicação não deve tentar tratar. Usualmente indica situações anormais, que
não deveriam ocorrer.
Errors e RuntimeExceptions são considerados uncheked (não verificadas),
portando o compilador não obriga que exista tratamento para eles. Erros
normalmente representam situações críticas, que não deveriam acontecer, como por
exemplo, acabar a memória da JVM. Já subclasses de RuntimeException
representam erros de lógica de programação que devem ser corrigidos (podem, mas
não devem ser capturadas: erros devem ser corrigidos) .
Exemplos de exceções já definidas em Java incluem:
java.lang.ArithmeticException
Indica situações de erros em processamento aritmético, tal como uma
divisão inteira por 0.
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
66
java.lang.NumberFormatException
Indica que ocorreu uma tentativa de converter uma string para um formato
numérico, mas seu conteúdo não representava adequadamente um número
para aquele formato. É uma subclasse de
java.lang.IllegalArgumentException.
java.lang.ArrayIndexOutOfBoundsException
Indica a tentativa de acesso a um elemento de um vetor fora de seus
limites - ou o índice era negativo ou ainda, era maior ou igual ao tamanho do
vetor. É uma subclasse de java.lang.IndexOutOfBounds, assim como a
classe java.lang.StringIndexOutOfBounds.
java.lang.NullPointerException
Indica que a aplicação tentou usar null onde uma referência a um objeto
era necessária -- invocando um método ou acessando um atributo, por
exemplo.
java.lang.ClassNotFoundException
Indica que a aplicação tentou carregar uma classe mas não foi possível
encontrá-la.
java.io.IOException
Indica a ocorrência de algum tipo de erro em operações de entrada e
saída. É a raiz das classes java.io.EOFException (fim de arquivo ou stream),
java.io.FileNotFoundException (arquivo especificado não foi encontrado) e
java.io.InterruptedIOException (operação de entrada ou saída foi
interrompida), entre outras.
Entre os erros definidos em Java, as subclasses de java.lang.Error, são
java.lang.StackOverflowError e java.lang.OutOfMemoryError. São situações onde
não é possível uma correção a partir de um tratamento realizado pelo próprio
programa que está executando.
Como exceções são objetos, podem incluir atributos. A classe Throwable inclui o
registro do estado atual da pilha das chamadas de métodos e uma string associada
a uma mensagem de erro, que pode ser obtida para qualquer exceção através do
método Throwable.getMessage().
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
67
Hierarquia
Principais Métodos de Exception :
1. String getMessage() Retorna mensagem passada pelo construtor
2. String toString() Retorna nome da exceção e mensagem
3. void printStackTrace( ) Imprime detalhes (stack trace) sobre exceção
Exemplo : Aqui você vê a criação de uma nova exceção que é lançada. Este
exemplo ilustra o uso dos métodos getMessage, toString e printStackTrace.
public class TesteExcecao
{
static int i = 0;
static String msgs [] = {" Hello world!", " Alo mundo!"," Estacio de Sa"};
public static void escrever() throws ArrayIndexOutOfBoundsException
{
try {
while (i < 4)
{
System.out.println ("i = " + i + msgs[i]);
i++;
}// fim do while
} // fim try
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
68
catch (ArrayIndexOutOfBoundsException e) //e é obj original
{
System.out.println("Lancei a excecao");
e.printStackTrace();
System.out.println("Treinando a toString " + e.toString());
// cria uma nova exceção - imprime msg desejada e a msg do obj original
throw new ArrayIndexOutOfBoundsException("Voce acessou
indice inexistente ! " + e.getMessage());
} // fim catch
} // fim escrever
public static void main(String args[])
{
escrever();
} // fim main
} // fim classe
Exemplo : Entrada de dado via teclado (System.in), através de nextInt(), e
verificação se os dados de entrada são dígitos.
import java.util.Scanner;
public class Numero2 {
public static void main(String args[])
{
Scanner teclado;
teclado = new Scanner(System.in);
try
{
System.out.print("Digite um numero:");
int num = scanner.nextInt();
System.out.println ("O numero digitado foi: " + num);
}
catch (InputMismatchException e)
{
System.out.println ("\nERRO: Digite um numero !\n");
}
} // fim main
} // fim classe
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
69
8. Coleções
8.1. Introdução
O objetivo no estudo de Coleções (Java Collections FrameWork) é manipular
um conjunto de classes e no caso, interfaces também, ―oferecendo acesso a
estrutura de dados pré-empacotadas e a algoritmos para manipular tais estruturas,
representando reutilização de código e funcionalidade apropriadas.‖ [Deitel & Deitel]
Em outras palavras, a Java Collections API oferece :
• uma biblioteca de classes e interfaces (no pacote java.util) que implementa
as principais estruturas de dados de forma reutilizável ;
• implementações para iteração para extrair dados de qualquer estrutura
usando uma única interface;
• implementações de métodos estáticos utilitários para manipulação de
coleções e vetores .
Em versões anteriores do Java existiam apenas algumas classes de coleção,
como por exemplo, a classe Stack (para pilha) e alguns recursos para arrays pré-
definidos.
Destacam-se as interfaces Collection, Set, List, Map e as diversas classes do
pacote java.util, da qual podem ser citadas Arrays, Collections, ArrayList, LinkedList,
entre outras.
Classe Arrays
Tal classe fornece os métodos static fill, sort, binarySearch e equals. Veja o
exemplo adaptado do DEITEL com comentários.
Exemplo : Usando os métodos da classe Arrays
import java.util.*;
public class ClasseArraysExemplo {
private int vet[] = {60,40,50,30,20,10};
private int outroVet[];
// Construtor
public ClasseArraysExemplo()
{
outroVet = new int [10];
System.out.println("Preenchendo o vetor outroVet ... ") ;
Arrays.fill(outroVet,7);
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
70
//Ordena o array de inteiros crescentemente (por default)
System.out.println("Ordenando vet ... ") ;
Arrays.sort(vet);
//Usa o método static arraycopy de System
//1o.arg : vetor origem ; 2o. arg. : índice a partir de onde copiar
//3o. arg: vetor destino; 4o. arg. : índice a partir de onde gerar a cópia
//último arg. : quantidade de elementos a serem copiados da origem
System.out.println("Copiando os dados de vet para outroVet ... ") ;
System.arraycopy(vet,0,outroVet,0,vet.length);
}
//Métodos
public void escreveArray() {
System.out.println("Vetor vet : ");
for (int cont = 0; cont < vet.length; cont++)
System.out.println(vet[cont] + " ");
System.out.println("Outro vet : ");
for (int cont = 0; cont < outroVet.length; cont++)
System.out.println(outroVet[cont] + " ");
}
public int buscaValor(int valor) {
System.out.println("Iniciando a busca binaria em vet pelo valor " + valor + " : " );
return Arrays.binarySearch(vet, valor);
}
public void escreveIgualdade() {
boolean b = Arrays.equals(vet,outroVet);
System.out.println("vet " + (b ? " igual a " : " diferente de") + " outroVet");
}
// Método main
public static void main (String args[])
{
ClasseArraysExemplo a;
int posicao, valorInt;
double valorReal;
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
71
Scanner scan;
a = new ClasseArraysExemplo();
a.escreveArray();
a.escreveIgualdade();
// Lendo um valor inteiro da entrada padrão
scan = new Scanner(System.in);
System.out.println("Digite um valor inteiro para procurar no vetor: ");
valorInt = scan.nextInt();
posicao = a.buscaValor(valorInt);
System.out.println(posicao >= 0 ? "Encontrado na posicao "
+ posicao : "nao encontrado " + valorInt);
} // fim main
} //fim classe
Resumo :
Métodos da classe Arrays :
Arrays.fill(array, elemento) preenche todo o array com elemento.
Arrays.sort(array) classifica o array, ou seja, ordena crescentemente, por
default.
Arrays.binarySearch(array, elemento) busca o elemento retornando o
índice se foi localizado (>= 0) ou um número negativo (< 0) indicando a
posição após a que deveria estar o elemento. É necessário ordenar antes o
array. É erro de lógica não ordenar o array previamente !!!!
Dica : Se quiser inserir um elemento de forma ordenada, ajuste a posição
retornada pelo método, multiplicando por -1 e depois subtraia de 1.
Arrays.equals(array1, array2) verifica a igualdade de dois arrays.
Método utilitário de java.lang.System
static void arraycopy(origem_da_copia, offset,
destino_da_copia, offset,
num_elementos_a_copiar)
Ex: int [ ] um = {12, 22, 3};
int [ ] dois = {9, 8, 7, 6, 5};
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
72
System.arraycopy(um, 0, dois, 1, 2);
Resultado: ___ dois é {9, 12, 22, 6, 5}
Interface Collection
A interface Collection possui operações para adicionar, limpar, comparar
objetos na coleção e a classe Collections fornece métodos static que
manipulam as coleções polimorficamente.
Listas
Uma lista é uma coleção de elementos arrumados numa ordem linear, isto é,
onde cada elemento tem um antecessor (exceto o primeiro) e um sucessor
(exceto o último), que pode ser implementada de forma sequencial ou
encadeada.
Uma lista pode ser mantida ordenada ou não e pode apresentar repetição de
elementos.
Algumas operações são:
Adição de elementos : Adicionar um objeto no fim da lista, por exemplo.
Acesso aos elementos : Obter o elemento de qualquer posição da lista,
fornecendo o índice desejado
Pesquisa de elementos (Descobrir se um certo elemento está na lista )
Obter o número de elementos da coleção
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
73
List é uma collection, chamada sequência, que pode conter elementos
repetidos.
As Lists baseiam-se em ter índice inicial zero.
A interface List é implementada pelas classes ArrayList e LinkedList.
Métodos da interface List e da classe ArrayList :
umaLista.add(elemento) adiciona elemento no fim da lista
umaLista.add(int índice, elemento) adiciona o elemento especificado na
posição determinada por índice.
umaLista.addAll(outraLista) concatena outraLista no final de umaLista,
atualizando umaLista
umaLista.get(indice) retorna o valor que tem índice especificado
umaLista.size() retorna a quantidade de elementos da lista
umaLista.clear() remove todos os elementos da lista
umaLista.isEmpty() retorna true se a lista está vazia e false, caso contrário.
umaLista.contains(Object obj) retorna true ou false, caso a lista contenha
ou não o objeto obj passado.
umaLista.indexOf(Object obj) retorna o índice da 1ª ocorrência do elemento
especificado ou -1, se a lista não contém o elemento.
umaLista.remove(int indice) Remove o element de índice especificado e
retorna o elemento que foi removido, além de atualizar a lista.
umaLista.remove(Object o) Remove da lista, a 1ª. ocorrência do elemento
especificado, caso ele esteja presente na lista.
umaLista.subList(int indiceInicial, int indiceFinal) Retorna uma visão da
porção entre o indiceInicial (inclusive) e o indiceFinal (exclusive).
NOTA : A classe LinkedList que implementa a interface List ainda possui os métodos
: addLast, addFirst, removeLast, removeFirst, isEmpty(), entre outros.
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
74
Exemplo : Ilustando os métodos apresentados com ArrayList
import java.util.*;
public class ColecaoExemplo
{
private int num[ ] = {1,2,3};
public ColecaoExemplo()
{
ArrayList <Integer> lista = new ArrayList <Integer>();
ArrayList <Integer> outra = new ArrayList <Integer>();
// Adiciona objetos a lista
for (int i = 0; i < num.length; i++)
lista.add(num[i]); // adiciona cada componente de num
lista.add(50); // adiciona 50 no final da lista
//Escrevendo o conteúdo da lista
System.out.print("\nArrayList (lista) => ");
for (int i = 0; i < lista.size();i++)
System.out.print(lista.get(i) + " ");
System.out.println();
// Montando a lista outra
outra.add(10);
outra.add(20);
// Imprimindo a lista outra
System.out.print("ArrayList (Outra lista) => ");
for (int i = 0; i <outra.size();i++)
System.out.print(outra.get(i) + " ");
System.out.println();
//Concatena outra no final de lista, atualizando lista
lista.addAll(outra);
System.out.print("Lista resultante (lista + outra) => ");
for (int i = 0; i < lista.size();i++)
System.out.print(lista.get(i) + " ");
// lista.clear(); // Remove todos os elementos da lista
// Verifica se a lista possui o elemento 50
if (lista.contains(50))
System.out.print("\n50 esta na lista !");
System.out.print("\nTamanho da lista => " + lista.size());
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
75
//Passa o objeto da classe Integer para o método remove, para
// removê-lo e então, atualizar a lista
if (lista.remove(new Integer(10)))
System.out.print("\nRemocao ok !");
// Invoca o método estático da classe Collections para ordenar
// a lista
Collections.sort(lista);
System.out.print("\nTamanho da lista => " + lista.size());
System.out.print("\n");
} // fim do construtor
// Método main
public static void main(String args[])
{
new ColecaoExemplo ();
}
} // fim da classe
Conjuntos (sets)
Qual é a diferença de uma lista para um conjunto ?
List : pode-se ter repetição de elementos,
Set : não há repetição de elementos.
As classes HashSet e TreeSet implementam Set.
HashSet armazena seus elementos em uma tabela hash
TreeSet armazena seus elementos em uma árvore.
Algoritmos
A estrutura de coleções fornece diversos algoritmos de alto desempenho para
manipular os elementos de coleções. Tais algoritmos são implementados como
métodos static. Dessa forma, temos :
Método Sintaxe Operação Descrição
sort Collections.sort(lista); List Ordena valores
shuffle Collections.shuffle(lista) List Embaralha os
elementos
reverse Collections.reverse(lista) List Inverte a ordem dos
elementos
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
76
fill Collections.fill(lista, valor) List Colocar um valor em
todas posições da
lista
binarySearch Collections. binarySearch
(lista, chave)
List Pesquisar um array
ordenado
copy Collections.copy
(listaCopiada, lista)
List Copia elemento
max Collections.max (lista) Collection Maior elemento
min Collections.min (lista) Collection Menor elemento
Exemplo :
import java.util.*;
public class TestaAlgoritmos
{
public TestaAlgoritmos() // Construtor
{
LinkedList <Integer> listaClone = new LinkedList <Integer> ();
LinkedList <Integer> listaNum = new LinkedList <Integer> ();
// montando a listaNum
for (int conta = 1; conta < 6; conta++)
if (conta % 2 == 0)
listaNum.add(10*conta);
else
listaNum.add(conta);
// Ordenando crescentemente a listaNum
Collections.sort(listaNum);
System.out.println("\n\n** APOS O SORT ... ");
escreveLista(listaNum);
// Embaralhando com shuffle
Collections.shuffle(listaNum);
System.out.println("\n\n APOS o shuffle ...");
escreveLista(listaNum);
// Invertendo com reverse
Collections.reverse(listaNum);
System.out.println("\n\n APOS o reverse...");
escreveLista(listaNum);
// Inicializando a listaClone com zeros
for (int conta = 1; conta < 6; conta++)
listaClone.add(0);
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
77
// Copiando os dados de listaNum para listaClone
Collections.copy(listaClone,listaNum);
System.out.println("\n\n APOS o copy - lista clone...");
escreveLista(listaClone);
// Preenchendo (fill) a listaClone com valor 10
Collections.fill(listaClone,10);
System.out.println("\n\n Apos fill - lista clone ficará ...");
escreveLista(listaClone);
// ―pegando‖ o menor elemento de listaNum
System.out.println("\n Menor valor de listaNum : "
+ Collections.min(listaNum));
// ―pegando‖ o maior elemento de listaNum
System.out.println("\n Menor valor de listaNum : "
+ Collections.max(listaNum));
} // Fim do construtor
// Método para escrever os dados da lista
public void escreveLista(List lista)
{
System.out.print("\nLista : ");
for(int conta = 0; conta < lista.size(); conta++)
System.out.print(lista.get(conta) + " ");
}
// Método main
public static void main(String args[])
{
new TestaAlgoritmos();
}
}
Comentário : Se tivéssemos ArrayList, a aplicação dos algoritmos não mudaria.
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
78
9. Manipulação de Arquivos em Disco [LW]
9.1. Introdução
“Java vê cada arquivo como um fluxo de bytes, que termina sempre com um
caractere indicador de final de arquivo (último caractere gravado no arquivo) – EOF
(End Of File - Fim de Arquivo) ou em um número específico de bytes .‖ [DEITEL]
Todos os aspectos que se relacionam com as diferentes formas de se realizar
a leitura e a escrita de dados a partir de uma fonte, para um destino, são reunidas, e
abstraídas, no conceito de fluxo (ou canais ou ainda, em inglês, streams).
Para manipular arquivos em Java, deve-se importar o pacote java.io. As
bibliotecas de classes Java para I/O (input/output == entrada e saída), estão
divididas basicamente em entrada e saída.
Um programa que manipula um arquivo em disco deve executar três etapas:
Abertura ou criação de um arquivo;
Transferência de dados; e
Fechamento do arquivo.
9.2. A classe File (java.io.File) - Representando Arquivos e Diretórios
Em Java, a classe File permite representar arquivos. É apenas uma abstração: a existência de
um objeto File não significa a existência de um arquivo ou diretório.
Um dos construtores desta classe recebe como argumento uma string que pode identificar, por
exemplo, o nome de um arquivo em disco. Assim, instâncias da classe java.io.File
representam caminhos (paths) para possíveis locais. Por exemplo, o código a seguir cria uma
instância da classe File, associada ao arquivo \Estacio\alunos\arquivo.txt:
File file = new File("\\Estacio\\alunos\\arquivo.txt");
1
Caso não seja especificado
o caminho (nome completo do arquivo), será possível encontrar o
arquivo no diretório onde se encontra o arquivo .class.
File file = new File("arquivo.txt");
Os métodos da classe File permitem obter informações sobre o arquivo, como por exemplo:
testar a existência de arquivos, definir permissões (nos S.O.s onde for aplicável), apagar
arquivos, criar diretórios, listar o conteúdo de diretórios, etc.
Alguns Métodos da Classe File
boolean exists()
Permite verificar se o arquivo especificado existe ou não;
boolean canRead()
Verificam se o arquivo concede a permissão para leitura;
boolean canWrite()
Verificam se o arquivo concede a permissão para escrita;
long length()
1
No caso do sistema operacional windows, usam-se duplas barras invertidas (\\), porque uma barra invertida
apenas é considerado escape pelo java.
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
79
Retorna o tamanho do arquivo em bytes.
long lastModified()
O tempo em que ocorreu a última modificação (em milissegundos desde primeiro de
janeiro de 1970).
boolean delete()
Tenta apagar o diretório ou arquivo.
boolean mkdir();
Cria um diretório.
boolean mkdirs();
Cria todos os diretórios necessários para chegar no caminho especificado.
String getParent();
Retorna o diretório (objet File) pai
String[] list();
Retorna lista de arquivos contido no diretório.
boolean renameTo(File file);
deleteOnExit().
boolean isDirectory();
boolean isFile();
String getAbsolutePath()
A seguir é apresentado um exemplo, que define um objeto e o associa ao arquivo testando.txt
e verifica se este arquivo existe no diretório local.
import java.io.File;
class TesteArq {
static void p (String s){
System.out.println(s);
}
public static void main (String args[]) {
File f1 = new File("testando.txt");
p("Nome do arquivo: " + f1.getName());
p("Caminho: " + f1.getPath());
p("Caminho abs: " + f1.getAbsolutePath());
p("Pai do arquivo: " + f1.getParent());
p(f1.exists() ? "existe" : "nao existe");
p(f1.canWrite() ? "pode ser gravado" : "nao pode ser gravado");
p(f1.canRead() ? "pode ser lido" : "nao pode ser lido");
p(f1.isDirectory() ? "eh " : "nao eh " +"um diretorio");
p(f1.isFile() ? "eh " : "nao eh " +"um arquivo");
p("Ultima modificacao: " + f1.lastModified());
p("Tamanho do arquivo: " + f1.length() + " bytes");
}
}
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
80
9.3. Implementando Entrada e Saída
Há várias formas diferentes de ler/escrever dados:
Seqüencialmente / aleatoriamente
Como bytes / como caracteres
Linha por linha / palavra por palavra,
...
As APIs Java para I/O oferecem objetos que abstraem fontes/destinos (nós) e fluxos de
bytes e caracteres.
A implementação de entrada e saída em arquivos é feita pela utilização de fluxos que
derivam das classes: InputStream; Reader; OutputStream; Writer.
Todas as classes derivadas de InputStream e Reader possuem os métodos para
manipular entrada (leitura de um arquivo – entrada no programa) e todas as classes derivadas
de OutputStream e Writer possuem os métodos para manipular saída (gravação em um
arquivo – saída do programa).
Classes abstratas
Classes Concretas
E ainda, a implementação de arquivos de acesso aleatório é realizada através da classe
RandomAccessFile. Recursos de serialização básica são realizados a partir da interface
Serializable e das classes ObjectOutputStream e ObjectInputStream
Os arquivos, de acordo com o tipo de informação que podem armazenar, podem ser
classificados em:
Arquivos de Texto (Orientado a caractere)
Arquivos de Dados (Orientado ao byte)
InputStream OuputStream Reader Writer
FileInputStream FileOutputStream FileReader FileWriter
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
81
9.4. Arquivos Texto
Derivam das classes abstratas: Reader e Writer.
Fácil de ser lido por humanos com ferramentas simples (type, more, edit, ...).
Linhas com comprimento variável.
Cada linha termina com uma marca.
Exemplo: arquivo com código-fonte em Java.
No pacote java.io existe a classe FileWriter, que é um fluxo de dados, ou seja, ela pega
seus dados no formato String e os coloca em um determinado arquivo texto. Mas existe um
problema nisso tudo: imagine que, a cada String passada o HD tivesse que se movimentar,
localizar o ponto a ser gravado e só então gravar o String no arquivo. Isso, além de perder
tempo, provocaria um desgaste físico e desnecessário. Então, também no pacote java.io, existe
uma classe chamada BufferedWriter, que armazena uma certa quantidade de dados em um
determinado espaço da memória virtual e quando esse espaço está completamente cheio, é
feita a gravação no arquivo.
Passos necessários para criar um arquivo de texto:
1. Criar um objeto do tipo File.
Permite manipular diversos atributos de um arquivo.
2. Criar um fluxo FileWriter ligado ao objeto File.
Permite associar um arquivo de texto a um fluxo de escrita.
3. Criar um fluxo BufferedWriter ligado ao objeto FileWriter.
Maior eficiência na escrita de um arquivo.
4. Criar um fluxo PrintWriter ligado ao objeto BufferedWriter.
Permite a utilização dos métodos print e println.
Reader
Writer
StreamTokenizer
Object
PrintWriter
BufferedWriter
CharArrayWriter
PipedWriter
FilterWriter
PipedReader
LineNumberReader
FileReader
PushBackReader
FileWriter
StringWriter
StringReader
InputStreamReader
CharArrayReader
BufferedReader
FilterReader
OutputStreamWriter
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
82
Exemplo de programa que realiza a gravação de um arquivo texto:
import java.io.*;
public class GravarArquivoTexto{
public static void main (String arg[]) {
// Passo 1 - Criar um objeto do tipo File.
File meuArquivo;
meuArquivo = new File ("arquivo.txt");
try {
// Passo 2 - Criar um fluxo FileWriter associado ao objeto File.
FileWriter fluxoEscrita = new FileWriter (meuArquivo);
// Passo 3 - Criar um fluxo BufferedWriter associado ao objeto FileWriter.
BufferedWriter bufEscrita = new BufferedWriter (fluxoEscrita);
// Passo 4 - Criar um fluxo PrintWriter ligado ao objeto BufferedWriter.
PrintWriter grav = new PrintWriter (bufEscrita);
// Gravando um texto (string) no arquivo
grav.println ("Saida com PrintWriter.");
grav.println ("Tipos primitivos são convertidos em strings:");
// declarando variáveis - tipos primitivos
boolean a_boolean = false;
int an_int = 1234567;
// Gravando estas variáveis como strings
grav.println (a_boolean);
grav.println (an_int);
// Fechando o arquivo
grav.close();
System.out.println("Gravei!!!");
}
catch (IOException ioe){
System.out.println("IO Exception");
}
finally {
System.out.println("Termino da execucao do programa!!!");
}
}
}
O inverso ocorre com as classes FileReader e BufferedReader, ao invés de
escrever, elas lêem os dados do arquivo texto, bastando consultar os APIs Java para
utilizá-las.
Prof
a
. Jane Programação Orientada
a Objetos I I (Linguagem Java)
83
Passos necessários para ler um arquivo de texto:
1. Criar um objeto do tipo File
Permite manipular diversos atributos de um arquivo.
2. Criar um fluxo FileReader ligado ao objeto do tipo File
Permite a leitura de um arquivo escrito em formato ASCII.
3. Criar um canal tampão BufferedReader ligado ao objeto do tipo FileReader
Maior eficiência na leitura de um arquivo.
Exemplo de programa que realiza a leitura de um arquivo texto:
import java.io.*;
import java.util.*;
class LerArquivoTexto{
public static void main(String[] args) throws IOException {
String linha;
// Passo 1 - Criar um objeto do tipo File
File meuArq;
// Passo 2 - Criar um fluxo FileReader ligado ao objeto do tipo File
FileReader arq;
// Passo 3 - Criar um canal BufferedReader ligado ao objeto do tipo FileReader
BufferedReader bufEnt = null;
try {
meuArq = new File("arquivo.txt");
arq = new FileReader(meuArq);
bufEnt = new BufferedReader(arq);
do {
linha = bufEnt.readLine();
if (linha != null )
System.out.println(linha);
} while (linha != null);
}
catch ( IOException e){
System.out.println("Erro de I/O.");
System.out.print(e);
}
finally {
System.out.println("\nFim da execucaoo.");
if (bufEnt != null)
bufEnt.close();
}
}
}
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
84
RESUMO DE CLASSES E MÉTODOS VISTOS NOS EXEMPLOS
Classes para
arquivo texto
(import java.io.*)
Métodos Descrição do método
InputStreamReader
public int read()
throws IOException
void close()
Retorna o caracter lido ou -1 no
fim da stream.
Fecha a stream
BufferedReader
void close()
public int read()
throws
IOException
public String
readLine()
throws
IOException
Fecha
Retorna o character lido ou -1 no
fim da stream
Lê uma linha de texto.
Considera-se que uma linha
terminou ou por linefeed('\n'), a
carriage return ('\r'), or a carriage
return seguido de um linefeed
FileReader
(Esta classe
permite criar um
objeto para ler do
arquivo)
void close()
public int read()
throws
IOException
Obs. : Construtores
FileReader (File arquivo)
FileReader (String ArqNome)
Fecha
Retorna o character lido ou -1
quando acha o fim da stream
OutputStreamWriter
public void
write(int c)
throws
IOException
Escreve um único caracter
BufferedWriter
(escreve texto em
uma stream de
saída de
caracteres, criando
um buffer de
caracteres para
prover eficiência)
void close(); Fecha
FileWriter
(permite criar
objetos escritores
de arquivo texto)
void close()
public void write(int c) throws
IOException
write(String str) throws
IOException
Obs. : Construtores
FileWriter (File arquivo)
FileWriter (String ArqNome)
Fecha
Escreve um caracter relativo a
um int
Escreve string
Prof
a
. Jane Programação Orientada a Objetos I I (Linguagem Java)
85
PrintWriter
(imprime
representações
formatadas de
objetos para uma
saídaem texto. Não
imprime bytes)
void close()
print(boolean b)
print(char c)
print(double d)
print(float f)
print(String s)
println(String s)
write(String s)
Obs. : Construtores
PrintWriter (File arquivo)
PrintWriter (String ArqNome)
FechaMais conteúdos dessa disciplina
Composição da Matéria- updateOrder 0
- 4
- updateOrder 0
- campanha_gio_15_55_100_7
- campanha_30_jul18_10_35_18
- createMaterialSectionMaterial
- updateOrder 0 0 1 2 0 0 1 2 0 1 0 0 1 2 0
- Material - 1
- profileLastSentMaterialsUserSections- 1
- profileLastSentMaterialsUserSections- 2
- 4fb355ce-a6c0-4281-a86e-b71a7da69c18
- imagem
- Coxal - asa do ilíaco
- Carpo - palmar
