ninja academy - curso java básico

Formação Básica de

Programadores Java

Prof. Marcos Vinicius de Andrade Lima

Powered by GreenBeans /* Programação Descomplicada */

Sumário

1. ACEITA UM CAFEZINHO? ............................................................ 6

1.1 Um pouco de história ......................................................... 7 1.2 Características de Java ........................................................ 9 1.3 Máquina Virtual Java (JVM) .............................................. 11 1.4 Jogo Rápido....................................................................... 14 1.5 Pergunte ao Oráculo... ...................................................... 15

2. PREPARANDO O AMBIENTE ...................................................... 16 2.1 Instalando o Java JDK........................................................ 17 2.2 Eclipse IDE ......................................................................... 20 2.3 O Primeiro Programa ........................................................ 21 2.4 Jogo Rápido....................................................................... 23 2.5 Pergunte ao Oráculo... ...................................................... 23

3. TIPOS DE DADOS ....................................................................... 24 3.1 Dados e mais dados... ....................................................... 25 3.2 Tipos Primitivos em Java .................................................. 27 3.3 Declarando variáveis ........................................................ 30 3.4 Declarando Constantes..................................................... 32 3.5 Operadores ....................................................................... 33 3.6 Casting .............................................................................. 35 3.7 Vamos Treinar................................................................... 36

4. JAVA TEM STRINGS? ................................................................. 37 4.1 Declarando Strings ............................................................ 38 4.2 Alguns métodos úteis... .................................................... 39 4.3 Vamos Treinar................................................................... 40

5. EXIBINDO E LENDO DADOS ....................................................... 41 5.1 Exibindo Dados ................................................................. 42 5.2 Lendo Dados ..................................................................... 43 5.3 Vamor treinar ................................................................... 44

6. ESTRUTURAS DE CONTROLE ..................................................... 45 6.1 Fluxo de Dados ................................................................. 46 6.2 Estruturas Condicionais .................................................... 46 6.3 Vamos Treinar................................................................... 51 6.4 Estruturas de Repetição ................................................... 51 6.5 Vamos pensar um pouco... ............................................... 56 6.6 Vamos treinar ................................................................... 56

7. ARRAYS... ISTO MORDE? ........................................................... 58

7.1 Arrays ................................................................................ 60 7.2 Manipulando Arrays ......................................................... 62 7.3 Arrays Multidimensionais ................................................. 62 7.4 Vamos treinar? ................................................................. 65

8. CONCEITOS INICIAIS DE ORIENTAÇÃO A OBJETOS ................... 67 8.1 Introdução ........................................................................ 68 8.2 Paradigma da Orientação a Objetos ................................. 69 8.3 Características da Orientação a Objetos .......................... 70 8.4 Objetos e Classes .............................................................. 71 8.5 Os Quatro Pilares da OO ................................................... 74 8.6 Jogo Rápido... ................................................................... 79

9. CLASSES E OBJETOS EM JAVA ................................................... 80 9.1 Flash back... ...................................................................... 81 9.2 Definindo classes em Java ................................................ 83 9.3 Criando Objetos ................................................................ 84 9.4 Acessando variáveis de instância ..................................... 85 9.5 Métodos dos Objetos ....................................................... 86 9.6 A Referência “this” ........................................................... 91 9.7 Acessibilidade Pública e Privada ....................................... 93 9.8 Métodos Construtores ..................................................... 95 9.9 Sobrecarga de Métodos ................................................... 96 9.10 Membros Estáticos ....................................................... 98 9.11 Vamos treinar? ........................................................... 102

10. PACOTES ................................................................................. 107 10.1 Cadê o Meu Pacote? ................................................... 108 10.2 Definindo Subpacotes ................................................. 109 10.3 Nomeando Pacotes..................................................... 111 10.4 Acessibilidade de Pacotes ........................................... 111 10.5 Vamos Treinar? ........................................................... 112

11. O QUE GANHEI DE HERANÇA? ................................................ 114 11.1 Introdução .................................................................. 115 11.2 Definindo nossas classes ............................................ 115 11.3 Vale a pena ver de novo... .......................................... 118 11.4 Aplicando Herança em Java ........................................ 120 11.5 Mais Sobre o Mecanismo de Herança ........................ 122 11.6 Classes Finais .............................................................. 124 11.7 Vamos treinar? ........................................................... 124

12. REDEFINIÇÃO DE MÉTODOS ................................................... 126 12.1 Mais Sobre Referência “this”................................. 127 12.2 O Construtor “this()” ............................................ 128 12.3 Nem Tudo Eu Faço Igual à Papai ................................. 129 12.4 A referência “super” ................................................... 131 12.5 O Construtor “super()” .......................................... 132 12.6 Encadeamento de Construtores ................................. 134 12.7 Métodos Finais ........................................................... 135 12.8 Vamos Treinar? ........................................................... 136

13. REFERÊNCIA E CIA... ................................................................ 137

13.1 Manipulando Referências ........................................... 138 13.2 Casting de Referências ............................................... 139

13.3 Operador instanceof ............................................ 141 13.4 Unindo casting e instanceof ................................ 142 13.5 Passagem de Parâmetros ........................................... 144 13.6 Vamos Treinar? ........................................................... 146

14. CLASSES ABSTRATAS E INTERFACES ....................................... 147 14.1 Classes Abstratas ........................................................ 148

14.2 Métodos Abstratos ..................................................... 149 14.3 Interfaces .................................................................... 152 14.4 Implementando Interfaces ......................................... 153 14.5 Interfaces e Polimorfismo........................................... 155 14.6 Constantes em Interfaces ........................................... 156 14.7 Vamos Treinar? ........................................................... 157

15. AGREGAÇÃO, LISTAS E MAPEAMENTOS ................................. 159 15.1 Agregação ................................................................... 160 15.2 Coleções de Selos, Carros... ........................................ 162 15.3 Listas ........................................................................... 164 15.4 Listas Genéricas .......................................................... 167 15.5 Mapeamentos............................................................. 168 15.6 Mapeamentos Genéricos ........................................... 170 15.7 Vamos Treinar? ........................................................... 171

16. NÃO FUI EU... .......................................................................... 174 16.1 Introdução .................................................................. 175 16.2 Exceções em Java ........................................................ 177

16.3 A Cláusula throws .................................................... 180 16.4 A Sentença throw ..................................................... 180 16.5 O bloco try-catch ................................................. 181 16.6 Adicionando Informações nas Exceções ..................... 183 16.7 Vamos Treinar? ........................................................... 184

17. MULTITAREFA COM THREADS ................................................ 187 17.1 Introdução .................................................................. 188

17.2 Threads ................................................................... 188

17.3 Estendendo de Thread ............................................. 190 17.4 Implementando Runnable ...................................... 191 17.5 Estados de Thread ...................................................... 192 17.6 Alterando a Prioridade ............................................... 195 17.7 Sincronização .............................................................. 196 17.8 Cuidado com os Deadlocks! ........................................ 199 17.9 Vamos Treinar? ........................................................... 200

1. ACEITA UM

CAFEZINHO?

Neste capítulo você conhecerá

a linguagem Java: sua origem,

características e popularidade.

Sinta o aroma de Java se

espalhando por todos os

lugares.

“Java is Everywhere”

7

G r e e n B e a n s / * P r o g r a m a ç ã o D e s c o m p l i c a d a * /

Formação Básica de Programadores Java

1.1 Um pouco de história

Hoje estamos completamente imersos em um mundo de software. Tudo ao nosso redor é controlado por programas: quer quando você compra um cafezinho em uma máquina expressa; ou quando realiza um saque em um caixa de autoatendimento; na hora de pagar a passagem do ônibus; ao realizar uma chamada telefônica; ao assistir televisão; navegar na Internet; entre outros. Na realidade, na maioria das vezes, nem ao menos nos damos conta desta imersão em que vivemos.

Estamos em uma época de profundo uso da tecnologia e convergência digital. Se antes o homem não poderia viver sozinho em uma ilha; hoje os equipamentos e serviços na web é que não podem.

Mas como realizar tamanha tarefa com a quantidade de dispositivos e plataformas existentes? É preciso de algo que consiga funcionar em multiplataformas, seja poderoso, robusto e orientado a objetos. Hummm... o agente perfeito para isto chama-se Java!

Java é uma linguagem de programação orientada a objetos lançada em 1995 pela Sun Microsystem. Ela é fruto do trabalho da equipe de Patrick Naughton, Mike Sheridan e James Gosling, que em 1991 iniciaram seu desenvolvimento

Formação Básica de Programadores Java 8


com o codinome de Projeto Green. Seus idealizadores acreditavam que em pouco tempo os aparelhos domésticos e os computadores teriam uma ligação íntima (acho que eles assistiram muito “Os Jetsons” quando eram crianças).

Oak (carvalho) seria o nome a ser adotado para a nova linguagem que estava nascendo, uma homenagem à árvore que Gosling podia observar da janela do seu escritório. Só que depois se descobriu que já existia uma linguagem com este nome (graças a Deus!). Então o nome Java surgiu pela grande quantidade de café, originário da ilha de mesmo nome, que a equipe tomava.

O primeiro produto utilizando a nova linguagem foi um controle remoto com interface touchscreen, o *7 (StarSeven). O aparelho tinha uma mascote que ensinava ao usuário a utilizar o controle. Durante algum tempo o projeto passou por dificuldades visto que o mercado de produtos eletrônicos da época não

cresceu como o esperado e infelizmente a tecnologia existente não estava preparada para tamanho avanço.

Após a grande popularidade alcançada pela Internet em 1993, a Sun viu o grande potencial que a linguagem tinha para o desenvolvimento de paginas mais dinâmicas. Hoje, Java é uma das linguagens de programação mais populares no mundo!

9



1.2 Características de Java Java possui algumas palavras chaves que a caracterizam, como: simples, orientada a objetos, sintaxe parecida com C/C++, independente de plataforma, multithread, dinâmica, robusta, distribuída e interpretada.

Simples: como dito anteriormente, a motivação principal do projeto de Java era fazer uma linguagem para rodar em pequenos dispositivos. Tanto é verdade que o interpretador básico é de somente 40KB, mas se forem levados em consideração as bibliotecas básicas, tem-se um total de 175KB, ainda assim um valor pequeno.

Orientada a Objetos: Java utiliza um paradigma mais atual de programação, onde é possível facilmente realizar reuso de software e o foco está centrado nos dados e suas interfaces.

Sintaxe parecida com C/C++: Java utiliza uma sintaxe semelhante ao C/C++ justamente por que a estratégia dos seus idealizadores era tornar seu aprendizado mais tranquilo, visto que a maioria dos programadores conheciam C/C++.

Independente de Plataforma: Java foi criada para rodas em uma infinidade de dispositivos. E por este motivo um programa escrito em Java, depois de compilado, pode rodar em qualquer lugar que possua uma Máquina Virtual Java. Um programa Java não é



compilado para um determinado tipo de plataforma. Resumindo, um programa em Java é portável.

Multithread: Foi-se o tempo que os programas faziam apenas uma determinada tarefa por vez. Hoje as aplicações precisam verificar ortografia enquanto se edita um texto, verificar e-mail enquanto navega na Internet, etc. Java possui um poderoso e fácil mecanismo de multitarefa.

Dinâmica: em Java muitos dos objetos utilizados em um sistema são definidos dinamicamente, ou seja, em tempo de execução. Este recurso faz toda a diferença para a aplicação do polimorfismo.

Robusta: Java é uma linguagem fortemente tipada destinada para escrever programas que possam ser confiáveis. Ser fortemente tipada significa que é realizada uma extensiva checagem de tipos em tempo de compilação, denunciando rapidamente problemas ou bugs.

Distribuída: em Java é possível escrever sistemas que acessam partes remotas com a mesma facilidade como se fossem locais. Diversos protocolos que rodam em cima de TCP/IP podem ser utilizados, como HTTP e FTP.

Interpretada: um arquivo fonte em Java precisa ser compilado para se gerar o bytecode. Após este processo, o bytecode é interpretado pela Máquina Virtual Java para que possa ser executado na

11



plataforma específica. Antigamente algumas pessoas reclamavam dizendo que Java era lenta, mas hoje em dia os programas em Java são muito rápidos, graças à diversas estratégias, como HotSpot.

1.3 Máquina Virtual Java (JVM)

A Máquina Virtual Java (JVM – Java Virtual Machine) é a grande responsável por fazer Java ser independente de plataforma. Mas antes de falar mais sobre JVM, vamos entender como as coisas funcionavam antes do surgimento de Java para executar um programa em diversas plataformas:

O programador em C precisa conhecer além da linguagem, as

características e nuances de cada uma das plataformas em

que trabalha. O código fonte em C, ainda que seja o mais

simples possível, depois de compilado, não consegue ser

Mais um

código fonte

em C saindo... compilação

compilação

compilação

Linux

IBM AIX

Windows

Execução

Execução

Execução



executado em diversas plataformas sem passar novamente

pelo processo de compilação. C não é portável!

Os projetistas de Java resolveram o problema da portabilidade

criando uma camada de software entre o código compilado

(que em Java são chamados de bytecodes) e o sistema

operacional da plataforma alvo. Com isto os programas em

Java só precisam ser compilados uma única vez! Veja a

ilustração a seguir e perceba a diferença com o que foi visto

anteriormente:

O programador Java escreve seu código de acordo com a sintaxe estabelecida pela linguagem. Finalizado o desenvolvimento do código, este passa por um processo de compilação. Se não houve nenhum erro é gerado, após o processo de compilação, um ou vários arquivos bytecode. Este arquivo pode então ser interpretado pela Máquina Virtual

Código fonte

em Java

saindo...

compilação

Linux

IBM AIX

Windows

J

V

M

13



Java em qualquer plataforma que tenha disponível uma JVM.

Observe que o código fonte é compilado uma única vez, independente se o programa é simples ou complexo! Outra maravilha com o uso da JVM é que podemos distribuir pacotes de classes que funcionam em todas as plataformas com JVM instalada. Antes era preciso gerar bibliotecas específicas para cada plataforma.

A JVM possui diversos fabricantes, mas todos eles devem seguir as especificações Java da Oracle para que possam executar qualquer bytecode. A versão mais popular pode ser baixada pelo site da Oracle: http://www.oracle.com/technetwork/java/javase/downloads/index.html Lá você encontrará as versões JRE (Java Runtime Environment) e JDK (Java Development Kit). Você saberia dizer qual a diferença entre as duas versões? Abaixo temos uma figura com a plataforma padrão Java:

Enquanto os bytecodes são independentes de plataforma, a Máquina Virtual Java (JVM) é

dependente de plataforma.

http://www.oracle.com/technetwork/java/javase/downloads/index.html




1.4 Jogo Rápido

a) Quais as principais características de Java?

b) O que são bytecodes?

c) Quais os passos necessários para executar um sistema

em Java? (código fonte até a execução)

d) O que é a JVM e qual sua importância?

e) Qual a diferença entre JDK e JRE?

15



1.5 Pergunte ao Oráculo...

a) Por que estudar Orientação a Objetos?

b) Como é que se chama o compilador Java? E a JVM?

c) O que é Garbage Collector?

2. PREPARANDO O

AMBIENTE

Para se tornar um excelente e

poderoso NINJA é preciso

preparar todo o ambiente antes

do início do treinamento diário!

Neste capítulo você verá como

configurar o ambiente

necessário para desenvolver suas

habilidades em Java.


17




2.1 Instalando o Java JDK

O primeiro passo para preparar o ambiente de desenvolvimento em Java é instalar a versão JDK em sua máquina. Basta acessar o site da Oracle e baixar a última versão Java SE (Standard Edition) de acordo com o seu Sistema Operacional:

O processo de instalação é bastante simples e intuitivo, bastando ir avançando em cada um dos passos até a que a instalação da plataforma esteja completa.

O próximo passo, caso deseje compilar e executar programas em Java no “Prompt de Comando” ou “Terminal Linux”, é configurar as variáveis de ambiente. A seguir é mostrado como configurá-las utilizando o Windows 7:

Passo 1: clique no botão “Iniciar” e em seguida “Painel de Controle”; Passo 2: selecione a opção “Sistema e Segurança”; Passo 3: Agora selecione “Sistema”; Passo 4: Selecione “Configurações Avançadas do Sistema”; Passo 5: Agora selecione “Variáveis de Ambiente”;

18



Passo 6: Em “Variáveis de Ambiente” você deve adicionar uma nova variável do sistema, clicando em “Novo” no agrupamento “Variáveis do Sistema”. Adicione a variável “JAVA_HOME”. O endereço de instalação depende de onde você instalou o JDK. Abaixo segue um exemplo:

Passo 7: ainda no agrupamento “Variáveis do Sistema” adicione a variável “CLASSPATH”, como mostrado abaixo:

Passo 8: agora procure a variável “path” na lista de “Variáveis do Sistema” e clique no botão “Editar...”. Cuidado para não apagar os valores que já existem! No final do valor da variável adicione “ %JAVA_HOME%\bin ; . ; ”

19



Passo 9: Confirme com “OK” e em seguida abra o “Prompt de Comando” para testar a configuração das variáveis. Digite “java” e tecle ENTER para verificar a execução da JVM. Depois digite “javac” para verificar a execução do compilador Java.

20



http://www.eclipse.org/downloads/

2.2 Eclipse IDE

Eclipse é uma IDE desenvolvida em Java, com código aberto para a construção de programas de computador. O projeto Eclipse foi iniciado na IBM, que desenvolveu a primeira versão do produto e doou-o como software livre para a comunidade.

Hoje, o Eclipse é a IDE Java mais utilizada no mundo. Possui como características marcantes o uso da SWT e não do Swing como biblioteca gráfica, a forte orientação ao desenvolvimento baseado em plug-ins e o amplo suporte ao desenvolvedor com centenas de plug-ins que procuram atender as diferentes necessidades de diferentes programadores, até para quem não programa em Java! A última versão, lançada em julho de 2013, foi batizada de Kepler. Abaixo veja o link para fazer o download:

Para instalar o programa não existe algo mais simples: basta descompactar o arquivo baixado do site em uma pasta e executar o arquivo “eclipse.exe” (no Windows). OBSERVAÇÃO: você precisa ter o Java previamente instalado no seu sistema!

21



2.3 O Primeiro Programa

Agora que todo o ambiente está preparado, vamos escrever o primeiro programa em Java para testar tudo. Na verdade este primeiro programa tem uma importância gigantesca, não por testar se tudo foi instalado corretamente, mas para quebrar a “Maldição das Linguagens de Programação”. Isto mesmo! Existe uma maldição que ronda as linguagens de programação e para que você tenha sucesso em Java será preciso quebrá-la! Uns dizem que isto é lenda geek, mas como seguro morreu de velho... é melhor não facilitar!

Para este primeiro programa, vamos utilizar algum editor de texto como o Bloco de Notas do Windows. Abaixo segue o código que deve ser digitado no editor:

public class HelloWorld

{

public static void main(String[] args)

{

System.out.println(“Hello World!”);

}

}

Após você terminar de digitar o código fonte acima, grave-o com o nome de “HelloWorld.java”. Tenha bastante atenção com relação as letras maiúsculas e minúsculas! Depois não diga que não avisei...

Agora que seu arquivo fonte foi gravado, é a hora de compilar o programa. Para isto abra um terminal, como o “Prompt de

22



Comando” do Windows. Entre na mesma pasta que o arquivo “HelloWorld.java” foi gravado e digite conforme abaixo:

Se tudo estiver certo não vai aparecer nenhuma mensagem na tela, apenas aparece o prompt com o cursor piscando esperando a entrada de um novo comando. Digite conforme a figura abaixo e observe a execução do programa:

23



Mas, se por algum motivo seu primeiro programa não funcionar bonito como o da apostila, não precisa arrancar os cabelos! Tenha calma! No início isto é normal! Conte até 10 e verifique se tudo foi digitado corretamente.

Não se esqueça das letras maiúsculas e minúsculas (avisando novamente para ficar grudado no seu cérebro, cérebro, cééééérebrooooooo...)

2.4 Jogo Rápido

a) Escreva um programa em Java que mostre na tela o seu nome.

b) Escreva um programa em Java que mostre na tela seu

nome em uma linha, e na outra o local em que você estuda ou trabalha.

2.5 Pergunte ao Oráculo...

a) Existe um documento que foi criado em uma convenção intergaláctica (com a participação de ninjas, jedis, siths, hobbits, etc), que determina o padrão que deve ser seguido por todas as pessoas que trabalham com Java. O nome do documento é “Java Code Conventions”. Pesquise mais sobre essas convenções.

3. TIPOS DE DADOS

Neste capítulo você verá o que

são dados e qual sua

importância. Também aprenderá

o que são variáveis, quais são os

tipos primitivos em Java e

quando utilizar cada um deles.

Que a Força esteja com você

para conseguir resolver todos os

exercícios...


25



3.1 Dados e mais dados...

Hoje a informação é tratada como recurso principal das empresas e organizações. Mas de onde ela vem? Ela surge do além? Vem de um universo paralelo? O que você acha?

Informação pode ser definida como um conjunto de fatos organizados de tal forma que adquirem valor adicional além do valor do fato em si. Complicou? Veja o exemplo abaixo para ver se melhora... ou não...

“O inverno em Nova Iorque começa em dezembro” Esta frase é um exemplo de informação por que tem um conjunto de caracteres organizados dentro de um determinado contexto.

Já as palavras soltas: “inverno”, “Nova Iorque” e “dezembro” são considerados dados.

Informação: “Dados dotados de relevância e propósito”

Peter Drucker

Dados: “... são puramente sintáticos...”

Valdemar Setzer

26



Regras e relações podem ser estabelecidas para organizar os dados em informação útil e valiosa. Mas é claro que o tipo de informação criada depende diretamente da relação definida entre os dados existentes. Uma escolha errada dos dados pode produzir informações distorcidas e até mascarar a realidade vivida por uma organização.

É importante observar que relações podem ser redefinidas e novas informações criadas com a inclusão de novos dados. E que informações podem produzir mais informação.

A tabela abaixo resume as principais diferenças entre dados e informação:

Dados Informação

Simples observação sobre um estado.

Dados dotados de relevância e propósito.

• facilmente estruturados; • facilmente obtidos por

máquinas; • frequentemente

quantificados; • facilmente transferível.

• requer unidade de análise;

• exige consenso em relação ao significado;

• exige necessariamente a medição humana.

Legal saber isto tudo sobre dados e informação, mas como é mesmo que o computador armazena e trabalha com eles?

Grande parte do trabalho realizado pelo computador é baseada na manipulação do conteúdo contido em sua memória: dados e programas. Estes dados e programas estão

27



em sua forma binária, que é o sistema que os computadores entendem (zeros e uns).

Se na memória tudo é representado como zeros e uns, como o computador consegue diferencias uma palavra de um número?

3.2 Tipos Primitivos em Java

Java é uma linguagem “tipada” estaticamente, ou seja, após que um determinado tipo tenha sido atribuído à uma variável, ela não mudará o seu tipo durante o restante da execução do programa. Isto é algo que previne o acontecimento de diversos bugs! Mas antes de falarmos sobre os tipos primitivos, é interessante entender o que são variáveis e qual sua importância. Imagine que você, em um determinado momento, tire uma fotografia instantânea do conteúdo da memória de um computador. Você poderia encontrar algo como mostrado a seguir:

Endereço de Memória Conteúdo da Memória (00010110)2 (16)16 10011100

(00010111)2 (17)16 11110000

(00011000)2 (18)16 00000101

(00011001)2 (19)16 00000000

... ... ...

(11111110)2 (FE)16 10000001

28



Na figura anterior podemos observar que cada endereço tem um valor em binário, e para facilitar, também tem um valor correspondente no sistema hexadecimal. Então já pensou o que você teria que fazer para colocar o valor de dois números na memória para depois somá-los? Uma possível solução seria:

1 – colocar o primeiro valor em um

endereço de memória (00010001);

2 – colocar o segundo valor em outro

endereço de memória (11100001);

3 – somar o conteúdo do primeiro endereço

de memória (00010001)2 com o conteúdo do

segundo endereço (11100001)2 e guardando o

resultado em um terceiro endereço de

memória (00010011)2.

Será que os passos descritos acima seriam fáceis de serem lembrados? E os números dos endereços? Você acha que seria fácil lembrá-los? É pouco provável!

É por esta dificuldade de lembrar em que posições de memória os dados foram guardados, que nos primórdios da computação os programadores não chegavam aos 35 anos! (brincadeirinha... mas alguns perderam os cabelos sim!). Para solucionar este problema iniciou-se a utilização de variáveis! Elas são a salvação da lavoura, ou melhor, a salvação dos nossos cabelos!

Uma variável nada mais é que uma palavra que é associada a uma posição de memória. Por que é claro que é mais fácil

29



lembrar-se de uma palavra do que de números em binário ou hexa. Veja a diferença da soma de dois números usando variáveis:

1 – colocar o primeiro valor na variável

A;

2 – colocar o segundo valor na variável B;

3 – somar o conteúdo da variável A com o

conteúdo da variável B e guardando o

resultado em uma terceira variável C.

Então, é mais fácil ou não trabalhar desta forma? Se você respondeu NÃO é aconselhável fazer um curso de Assembly ou é primo do Neo da Matrix. Em Java cada variável deve ter um tipo associado a ela o tipo de dado que ela guarda. Por exemplo, se eu quero uma variável para guardar o total de alunos de uma sala, essa variável deve ter associado a ela o tipo inteiro. Se eu quero guardar a média das notas de uma sala eu poderia associar a este minha variável o tipo real ou ponto flutuante. Em Java temos oito (8) tipos primitivos:

Tipos inteiros:

• byte (8 bits)

• short (16 bits)

• int (32 bits)

• long (64 bits)

30



Tipos reais (ponto flutuante): • float (32 bits)

• double (64 bits)

Tipo lógico

• boolean (1 bit)

Tipo caractere

• char (16 bits)

Java ainda assume que para constantes inteiras o tipo padrão é o “int” (3; 60; -10; -7) e para constantes de ponto flutuante o tipo padrão é o “double” (3.14; 0.1; 12.10).

3.3 Declarando variáveis

Agora que você já sabe a facilidade que o uso de variáveis trouxe para a vida dos programadores e já viu a lista com os oito tipos primitivos de Java, vamos agora aprender como declarar variáveis. Para declarar uma variável use:

<tipo> <variável>;

Exemplo: char genero;

int idade;

float media, salario;

Quanto maior for a quantidade de bits de um tipo, maior será o valor que ele poderá alcançar.

31



Também é possível atribuir um valor inicial para uma determinada variável na hora da sua declaração (inicialização).

<tipo> <variável> = <expressão/valor>;

Exemplo: char genero = ‘f’;

int x = 5, y = 10;

double total = 3.14 * 9.99 / 30;

Você pode atribuir a qualquer tempo um valor para uma variável previamente declarada. Veja o exemplo a seguir:

Exemplo: int i, j;

i = 10;

j = 12;

A seguir mais um código de fixação:

public class DeclarandoVariaveis{

public static void main(String[] args){

int i, j;

float valor = 2.12f;

double distancia = 32982.234;

char vogal = ‘a’;

boolean aberto = true;

System.out.println(valor);

System.out.println(distancia);

CUIDADO: O sinal de igual ( = ) em Java é utilizado para atribuição! Depois não diga que não

foi alertado!

32



System.out.println(vogal);

System.out.println(aberto);

i = 2011;

j = 7;

System.out.println(i);

System.out.println(j);

}

}

É importante saber que variáveis locais em Java sempre devem ser inicializadas antes de serem usadas.

3.4 Declarando Constantes Em Java também podemos utilizar em nossos programas algumas constantes. Uma constante, como o próprio nome sugere, possui um valor constante (diferentemente das variáveis em que o valor pode ser alterado). Para declararmos uma constante em Java precisamos fazer uso do modificador final. // variável de instância final

public final int UMA_CONSTANTE = 10;

// variável estática final

static final String OUTRA_CONSTANTE = “Pedro”;

Variáveis estáticas, de instância e locais podem ser final (constante), inclusive parâmetros. ATENÇÃO: uma variável final não precisa necessariamente ser inicializada em sua declaração, porém, uma vez inicializada, não pode ter seu valor alterado (blank final variables).

33



Exemplo: final int X;

X = 2; // a partir de agora não muda O padrão de escrita de constantes de Java é utilizar letras maiúsculas separadas por underscores ( _ ). Exemplo: MIN_VALUE, MAX_ QUERY_ROWS

3.5 Operadores

Java possui um conjunto bastante completo de operadores. Abaixo temos a relação dos mais utilizados:

Operadores Aritméticos:

( + ) – Soma;

( - ) – Subtração;

( * ) – Multiplicação;

( / ) – Divisão;

( % ) - Resto da Divisão . Operadores de Atribuição:

( = ) – Principal operador de atribuição;

( += ) – a += b a = a + b;

( -= ) – a –= b a = a – b;

( *= ) – a *= b a = a * b;

( /= ) – a /= b a = a / b;

( %= ) – a %= b a = a % b;

34



Operadores Unários:

( + ) – Sinal positivo;

( - ) – Sinal negativo (mudança de sinal). Operadores de Incremento e Decremento:

( ++ ) – Incrementa a variável em uma unidade;

( -- ) – Decrementa a variável em uma unidade. ATENÇÃO: os operadores de incremento e decremento podem ser usados antes da variável (pré-incremento) ou depois da variável (pós-incremento).

Exemplo de Pós-Fixado: int a = 4;

int b = a++; // b=4; a=5;

int c = a--; // c=5; a=4;

Exemplo de Pré-Fixado: int a = 4;

int b = ++a; // a=5; b=5;

int c = --a; // a=4; c=4;

Operadores de Comparação (devolvem um valor lógico):

( > ) - Maior que;

( < ) - Menor que;

( == ) - Igual;

( != ) - Diferente;

( >= ) - Maior ou igual que;

( <= ) - Menor ou igual que.

35



Operadores Lógicos:

( & ) - devolve true se ambos operandos forem true, avaliando ambos.

( | ) - devolve true se um dos operandos for true, avaliando ambos;

( ! ) - Negação;

( && ) - devolve true se ambos operandos forem true;

( || ) - devolve true se algum dos operandos for true.

3.6 Casting

Algumas vezes quando estamos programando existem situações que podem ocorrer perda de precisão (uma expressão de tipo maior está sendo atribuído a uma variável de tipo menor). Nestes casos é preciso realizar o que é chamado de “casting” explícito para que não ocorra erro de compilação.

Exemplo: long longValue = 99L;

int intValue2 = (int)longValue; // Ok!

int intValue1 = longValue; // ERRO!

Java também pode promover o tipo de uma expressão automaticamente para um tipo maior. Quando isto ocorre é chamado de “casting” implícito. Veja o exemplo abaixo:

36



Exemplo: long longValue;

int intValue = 10;

longValue = intValue;

3.7 Vamos Treinar

a) Escreva um programa que imprima o resultado das expressões abaixo:

3 – 2 – 1 + 2 + 1 + 3

2 + 6 – 3 / 7 x 9

2 x 3 – 4 x 5

3 % 4 – 8 b) Escreva um programa que declare, inicialize e imprima as

seguintes variáveis:

Inteiro i de 32 bits com valor 1;

Inteiro j de 64 bits com valor 2;

Ponto-flutuante p de 32 bits com valor 20.0;

Ponto-flutuante q de 64 bits com valor 30.0;

Boolean b com valor verdadeiro;

Caracter c com valor ‘k’.

4. JAVA TEM STRINGS?

Neste capítulo você descobrirá

onde foram parar as strings em

Java, já que elas não estão

listadas entre os tipos

primitivos vistos no capítulo

anterior. Onde estão?


38



No capítulo anterior a gente viu os oito tipos primitivos de Java, mas entre eles não foi visto nenhum que contemple as cadeias de caracteres (as famosas strings). Então ficou a pergunta no ar: Java tem strings? A resposta para esta pergunta é sim! Claro que Java tem strings, ela é uma linguagem poderosa! Porém as strings em Java são objetos e não tipos primitivos. É, você leu direito e não é erro de digitação... strings em Java são objetos. Bem, você vai ter que fazer um voto de fé, já que ainda não vimos nada sobre objetos. Prometo que antes do final do treinamento você já será um verdadeiro SHINOBI! Mas enquanto isto, vamos aprender a manipular strings em Java (mesmo sem saber o que são objetos). Tenha calma, não tenha pressa, será um passo de cada vez (embora no treinamento tenhamos algumas corridas).

4.1 Declarando Strings

Declarar strings em Java é muito simples, como pode ser visto a seguir:

String <variável>;

As strings em Java são representadas por uma cadeira de caracteres entre aspas duplas!

Exemplo: “Engenharia de Software”

39



Exemplo: String nome;

String curso = “Treinamento NINJA”;

É possível fazer concatenação de strings em Java utilizando o operador mais ( + ).

Exemplo: String nome = “Marcos” + “Vinicius”;

String data = 12 + “/outubro”;

A variável nome receberá “MarcosVinicius”. Já a variável

data receberá o valor “12/outubro” (ocorre casting implícito).

4.2 Alguns métodos úteis...

Como as strings em Java são objetos, elas possuem algumas ações especiais denominadas de métodos. Os mais utilizados estão descritos a seguir:

length(): retorna o tamanho de uma string;

Exemplo: String disc = “POO e Java";

System.out.print("tamanho="+disc.length());

As strings em Java possuem um toque mágico: transformam tudo em strings quando a

concatenação é utilizada!

40



charAt(n): retorna o caractere na posição n;

Exemplo: System.out.println("disciplina:" + disc);

System.out.print("primeiro caractere: ");

System.out.println(disc.charAt(0)); //‘P’

System.out.print("segundo caractere: ");

System.out.println(disc.charAt(1)); //‘O’

System.out.print("ultimo caractere: ");

System.out.println(disc.charAt(disc.length()-

1));//‘a’

4.3 Vamos Treinar

a) Escreva um programa que concatene as strings: “Tópicos”, “ de ”, “Linguagem” e mostre-as na tela.

b) Escreva um programa que imprima as letras em posições ímpares da frase: “Fortaleza Cidade do Sol”.

CUIDADO: As strings em Java iniciam sempre na posição de índice igual a zero (0)!

5. EXIBINDO E LENDO

DADOS

Neste capítulo veremos

como mostrar dados na

tela (console) e como ler

dados do teclado.


42



5.1 Exibindo Dados Em Java para escrever dados na saída padrão (monitor), use: System.out.print(“dados”); ou System.out.println(“dados”);

Obs: o println salta a linha após a impressão. O comando acima pode ser usado também com variáveis: int x = 20;

System.out.println( x );

Podem-se concatenar Strings com variáveis: System.out.println( “x = ” + x );

x = 20;

Escrevendo mais de um dado:

int x = 20;

int y = 30;

System.out.print( “x=” + x + “ e y=” + y );

Saída: x=20 e y=30

Escrevendo mais de um dado de outra maneira (printf):

Use System.out.printf com o % e o tipo do dado a ser impresso.

43



%d – decimal inteiro %tamanho.precisao f – ponto-flutuante %s – String %c – caractere %b – booleano

Exemplo com printf: int i = 10;

String s = "formatacao"

double d = 123.456;

char c = 'a';

boolean b = true;

double d2 = 789;

System.out.printf( "dados: %d - %s - %7.3f -

%c - %b \n", i, s, d, c, b );

Saída: dados: 10 - formatacao - 123,456 - a – true

5.2 Lendo Dados Para ler dados da entrada padrão, faça como descrito abaixo: import java.util.*;

public class Leitura {

public static void main(String args[ ]) {

// crie a variável de leitura dos dados

Scanner s = new Scanner ( System.in );

// use os métodos de leitura tipo desejado

System.out.print( "digite uma linha: " );

// lê a linha

String linha = s.nextLine();

System.out.print( "digite um numero: " );

44



// lê um inteiro

int i = s.nextInt() ;

System.out.print( "digite um numero: " );

// lê um pontoflutuante

double d = s.nextDouble();

5.3 Vamor treinar

a) Implementar um programa para calcular a área de um trapézio, onde: – h = altura, b = base menor, bMaior = base maior – area = (h * (b + bMaior)) / 2. Você deve ler do teclado os valores da altura e das duas bases e imprimir a área calculada.

b) Escreva um programa que leia duas strings do teclado

e compare se são iguais, imprimindo “verdadeiro” em caso de igualdade e “falso” caso contrário.

c) Escreva um programa que leia uma frase do teclado e

imprima:

• Seu tamanho • O primeiro e o último caractere • A palavra que começa na posição 3 e termina na posição 9, inclusive.

6. ESTRUTURAS DE

CONTROLE

Neste capítulo veremos que o destino de um programa em

execução em Java não precisa ser uma linha reta...

podemos adicionar curvas, retornos, desvios, etc.


46



6.1 Fluxo de Dados

Tudo o que fizemos até agora em Java foram sequências de comandos, onde o fluxo de execução seguia sempre de forma contínua, ou seja, do início ao fim, executando todos os comandos na ordem que foram inseridos. Será que trabalhando desta forma conseguimos elaborar qualquer programa? Não é preciso muito tempo para perceber que uma sequência única no fluxo de execução, sem a utilização de outros caminhos, tornaria impossível a construção de programas mais completos e complexos. Então vamos estudar as poderosas estruturas de controle de Java!

6.2 Estruturas Condicionais

A estrutura de controle condicional é a estrutura mais simples existente. Ela é utilizada quando é preciso decidir qual caminho o fluxo de execução deve seguir, de acordo com a análise de uma condição. A estrutura condicional sempre possui:

um teste, com uma expressão lógica; uma ação, que é realizada quando o resultado do teste

é verdadeiro.

47



E também pode ter: uma ação alternativa, que é realizada quando o

resultado do teste é falso. Sintaxe do Condicional if:

if ( < condição > ){

< ações >;

}

Representação em Diagrama UML:

Exemplo: public class Nota {

public static void main(String[] args) {

float nota;

Scanner sc = new Scanner(System.in);

nota = sc.nextFloat();

if (nota >= 8) {

System.out.println("Parabens!");

} } }

48



Sintaxe do Condicional if - else:

if ( < condição > ){

< ações >;

} else {

< outras ações >

}


Exemplo: public class NotasMelhorado {

public static void main(String[] args) {

float nota;

Scanner sc = new Scanner(System.in);

nota = sc.nextFloat();

if (nota >= 8) {

System.out.println("Parabéns!");

} else {

System.out.println(“Você chega lá!”);

}

}

}

49



Também existe outra estrutura condicional bastante interessante que permite a seleção da ação de acordo com diversas opções. Veja a seguir: Sintaxe da Seleção switch:

switch ( <expressão integral> ) {

case <label1>: <ações1>

case <label2>: <ações2>

...

default: <ações default>

}


Exemplo: switch ( valor ) {

case 2:

System.out.print(“(2)”);

case 1:


default:

System.out.print(“(default)”);

case 3:

System.out.print(“(3)” );

}

50



E se você não quiser que todo o fluxo continue a executar todos os “cases” abaixo até o final? O que fazer? Apelar pro CRTL+ALT+DEL? Claro que não! Existe algo bem mais elegante: break. Veja o exemplo abaixo:

switch ( valor ) {

case 2:


break;

case 1:


break;

default:

System.out.print(“(default)”);

break;

case 3:

System.out.print(“(3)” );

}


É importante observar que a partir do momento que uma opção “case” foi encontrada o fluxo

segue até o final executando tudo!

51



6.3 Vamos Treinar

a) Implemente um programa que receba um número de 1 a 7 e imprima o dia da semana correspondente. Atenção: utilize if-else.

b) Implemente um programa que receba

um número de 1 a 12 e imprima o mês correspondente. Quando o número estiver fora do intervalo permitido, a mensagem “mês inválido” deverá ser exibida. Atenção: utilize switch.

6.4 Estruturas de Repetição

As estruturas de controle de iteração fazem com que determinadas ações sejam repetidas até que uma determinada condição seja satisfeita.

Em Java temos:

while

do...while

for

52



Sintaxe while: neste tipo de estrutura a condição de

iteração é avaliada antes da execução do bloco do laço.

while ( <condição> ) {

<bloco do laço>

}


Exemplo:

int x = 0;

while ( x < 10){

System.out.println(x);

x++;

}

Sintaxe do..while: neste tipo de estrutura a condição de iteração é avaliada depois da primeira execução do bloco do laço. do {

<bloco do laço>

} while ( <condição> );

53




Exemplo: int x = 0; do {

System.out.println(x);

x++;

} while ( x == 0);

Sintaxe for: em Java o for é um laço que em sua estrutura contêm todos os parâmetros necessários para a repetição: inicialização, condição de repetição e incremento ou decremento.

for(<inic>;<condições>;<inc/dec>){

<bloco do laço>

}


Quando

54



trabalhamos com estruturas de repetição também podemos fazer uso de alguns comandos especiais de transferência. Em Java temos três estruturas de transferência:

break,

continue

return

break: pode ser usado em blocos com rótulos, laços de repetição e no switch, para transferir o fluxo para fora do contexto corrente, ou seja, para o bloco mais externo. Exemplo 1: for ( i=0; i<5 ; i++) {

if ( i == 3 ) {

break;

}

System.out.println( "i = " + i );

}

Exemplo 2: for ( i=0; i<4 ; i++) {

if ( i == 2 )

break;

for ( j=0; j<4; j++) {

if ( j == 2 )

break;

System.out.println( "j = " + j );

}


}

55



continue: Pode ser usado em laços de repetição for, while, e do-while, para interromper prematuramente o fluxo, avançando para a próxima iteração. Exemplo: for ( i=0; i<5 ; i++) {

if ( i == 3 ) {

continue;

}


}

return: É usado para parar a execução do método corrente e transferir o controle para o método que o chamou. Exemplo 1: private void calc() {

for ( i=0; i<5 ; i++) {

if ( i == 3 )

return;

} }

...

calc ();

Exemplo 2: private int somar(int a, int b){

int s = 0;

s = a + b;

return s;

}

...

int x = somar( 3, 4 );

56



6.5 Vamos pensar um pouco... O que será impresso na execução dos trechos abaixo: a) for(int i = 2; i < 5; i++) { switch ( i ) {

case 2 : continue;

case 3 : break;

default : break;

}

System.out.printf("i = %d\n", i);

}

b) for(int i = 2; i < 5; i++) { for(int j = 5; j > 2; j--) {

if(j > i) continue;

if(j < i) break;

System.out.printf("i=%d j=%d\n",i,j);

}

}

6.6 Vamos treinar

a) Escreva um laço while que execute 20 vezes,

imprimindo o valor da variável x que inicialmente está

com valor 10. Em seguida faça este mesmo laço só que

agora para um do-while.

b) Escreva um programa que imprima na tela a soma dos

números ímpares entre 1 e 30 e a multiplicação dos

números pares entre 1 e 30.

57



c) Escreva um programa que percorra dois laços de 0 a

10, um interno ao outro, imprimindo os contadores, e

quando estes forem iguais, o programa deve passar à

próxima interação do laço mais externo, caso

contrário, deve imprimir os valores dos contadores dos

dois laços.

7. ARRAYS... ISTO

MORDE?

Neste capítulo

aprenderemos como

manipular poderosas

estruturas através dos

Arrays.


59



Imaginemos que queiramos trabalhar com as notas dos alunos. Supondo que cada aluno deva ter cinco notas, podemos criar cinco variáveis do tipo int para armazenar as notas de um único aluno.

int n1, n2, n3, n4, n5;

Problemas:

É mais complicado trabalhar com um número grande de variáveis;

Passar as notas para um método exige a utilização

de muitos parâmetros;

A solução: utilização de arrays.

60



7.1 Arrays Definição de Array: Um array é estrutura de dados que define uma coleção ordenada de um número fixo de elementos de dados homogêneos (mesmo tipo). Em Java, arrays são objetos, portanto, precisamos criá-los antes de começarmos a usá-los. É importante novamente dizer que não é preciso arrancar os cabelos ou cortar os pulsos com essa história de objetos... jajá veremos o que são, como utilizá-los, como cria-los, entre outros. Espere só um pouco mais. Sintaxe para declaração de arrays: 1)tipo[] nomeDoArray; 2)tipo nomeDoArray[];

Onde: tipo pode ser um tipo primitivo (int, char, ...), classe ou interface. Sintaxe para criação de arrays: nomeDoArray = new tipo[ tamanho ];

IMPORTANTE: o tamanho do array não é fornecido na declaração, somente na criação. Exemplos: Para declarar um array de notas, fazemos: int notas[]; ou int[] notas;

61



CUIDADO: Em Java, uma vez criado um array, seu tamanho nunca muda!

Para criar o array de notas , fazemos: notas = new int[5];

Também podemos fazer os dois passos de uma vez só: int notas[] = new int[5];

Quando o array é criado, todos os elementos são inicializados para o valor default do tipo de dado: int a[] = new int[10]; // 10 int com valor 0

boolean b[] = new boolean[5]; // 5 false

Para saber o tamanho do array, usa-se o atributo length: // retorna o tamanho do array notas

notas.length;

Para acessar um elemento do array, fazemos: nomeDoArray[ índice ];

Exemplos:

notas[0] = 10;

notas[ notas.length-1 ] = 8;

System.out.println(“1a nota=“+notas[0] );

System.out.println(“última

nota=“+notas[notas.length-1]);

62



Podemos inicializar o array já na declaração fazendo: // já cria o array com o tamanho equivalente a

// quantidade de valores

tipo[] nomeDoArray = {valor1,valor2,...};

Exemplos: int notas [] = {10, 4, 5, 6, 8 };

String[] monitores={ “Marcos”, “Osvaldo”,

“Renata” };

7.2 Manipulando Arrays Podem-se usar os elementos do array separadamente: for (int i = 0; i < notas.length; i++ ) {

System.out.println( “nota=” + notas[ i ];

}

Ou o array todo: atribuição e passagem de parâmetro: calcularMedia ( notas );

int [] novasNotas = notas;

ATENÇÃO: Se houver uma tentativa de acesso indevido aos índices do array, uma exceção será gerada:

ArrayIndexOutOfBoundsException

7.3 Arrays Multidimensionais Arrays podem ter uma ou múltiplas dimensões (arrays de arrays). Por exemplo, sendo “e” um array de duas dimensões

63



com dois elementos na primeira e quatro na segunda (2x4), a implementação desse array em Java utilizará três objetos array, conforme o esquema abaixo:

Podemos definir arrays multidimensionais conforme a sintaxe: tipo [][][]…[] nomeDoArray;

ou tipo nomeDoArray [][][]…[] ;

Exemplos: int[][] mXnArray;

// é equivalente a int[] mXnArray[];

int [][] umArray;

// Array de duas dimensões

umArray = new int[4][5];

// Criando array 4x5 de inteiros

int [][] outroArray = new int[4][5];

// combinando declaração e criação

64



Inicializando Arrays Multidimensionais: double taxas[][] = { { 1,2,3 }, {4,5,6} };

Para acessar um elemento do array bidimensional, fazemos: nomeDoArray

[indice1][indice2][indice3]...[indiceN]

Exemplos: int [][] arr = new int [3][4];

arr[1][2] = 5;

arr[2][3] = 7;

System.out.println ( a[1][2] );

System.out.println ( a[2][3] );

Num array multidimensional, para saber o tamanho da primeira dimensão, usa-se o atributo length: int [][] meuArray = new int [4][5];

meuArray.length retorna o tamanho da primeira

dimensão = 4 Para varrer um array bidimensional, precisamos utilizar dois for’s: int arr[][] = new int[4][5];

for (int i = 0; i < arr.length; i++ )

for (int j = 0; j < arr[i].length; j++ )

System.out.println( arr[i][j] );

IMPORTANTE: na criação de arrays multidimensionais com o operador new, a profundidade dos arrays mais internos pode

65



ser omitida: double matrix[][] = new double[3][];

A inicialização poderia ser assim: for (int i = 0; i < matrix.length; ++i)

matrix[ i ] = new double[ i+1 ];

A representação da memória, nesse caso, seria:

7.4 Vamos treinar?

a) Escreva um programa com um laço “while” que inicializa um vetor de 50 inteiros com os valores de 50 a 99.

b) Escreva um programa que cria uma matriz

bidimensional de 20 x 10 elementos booleanos, inicializando as linhas pares com true e as linhas ímpares com false. Depois, imprima na tela todos os elementos da matriz.

66



c) Escreva um programa que receba via teclado três palavras e armazene-as num array de Strings. Depois, imprima o array.

d) Escreva um programa que declara, inicializa e depois

mostra na tela os seguintes arrays:

Um array contendo os nomes dos dias da semana;

Outro array bidimensinal contendo: em uma linha os meses (1, 2, ...) e em outra linha a quantidade de dias de cada mês do ano

e) Escreva um programa que cria um array de duas

dimensões, sendo a primeira dimensão de tamanho 3, e a segunda com tamanhos diferentes (2, 3 e 4), inicializando os elementos de cada linha com o índice da linha, por exemplo, os elementos da linha 0 recebem 0, os da linha 1 recebem 1...

f) Escreva um programa que cria uma matriz de duas

dimensões 2x3 e calcula a soma dos elementos cujos índices são pares.

8. CONCEITOS INICIAIS

DE ORIENTAÇÃO A

OBJETOS

Neste capítulo vamos

finalmente conhecer os

conceitos base para

Programação Orientada

a Objetos!


68



8.1 Introdução Hoje vivemos em uma época que somos completamente dependentes do uso dos computadores, e para que eles façam o que desejamos é preciso programá-los. O detalhe interessante é que um computador fala a língua dos dígitos binários, ou seja, zeros e uns (0 – 1). Imagine o trabalho que daria programar um sistema de uma instituição financeira somente utilizando binários... bem é melhor nem imaginar, só de pensar o coração dói. Para garantir a sanidade mental de programadores, começaram a serem desenvolvidas as linguagens de montagem. Elas substituíam as funções do código de máquina por mnemônicos, endereços de memória absolutos por identificadores. A linguagem de montagem, embora seja da segunda geração, ainda é considerada de baixo nível (Assembly). Com o passar do tempo surgiram as linguagens procedurais (alto nível). Elas utilizam uma sintaxe bastante parecida com a língua humana (inglês em sua grande maioria), e estão focadas nos procedimentos ou funções.

69



Embora as diversas linguagens desta 3ª geração difiram na sintaxe e recursos, elas têm em comum a existência de compilador ou interpretador (Cobol, Fortran, Pascal, Turbo Basic, etc). Na programação procedural ou estruturada é utilizada técnica da decomposição funcional (dividir um problema complexo em subproblemas). As grandes complicações da programação estruturada é que não temos uma ligação entre as ações (procedimentos e funções) e os dados.

8.2 Paradigma da Orientação a Objetos Ainda na década de 60, Alan Kay, um dos pais do paradigma da orientação a objetos, formulou a chamada analogia biológica: “como seria um sistema de software que funcionasse como um ser vivo?". Este paradigma praticamente suplantou o paradigma anterior.

No nosso corpo temos milhões de células. Cada célula possui uma função específica (de acordo com o tecido) e interage com outras células por meio de trocas de mensagens. Kay pensou como poderia construir agentes autônomos que

Um paradigma é uma forma de abordar um problema. Em software, um paradigma tem a ver com a

forma pela qual esse sistema é entendido e construído.

70



interagissem entre si. Com base nesta analogia, Alan Kay definiu os fundamentos da Orientação a Objetos:

1. Qualquer coisa é um objeto;

2. Objetos realizam tarefas através da requisição de serviços a outros objetos;

3. Cada objeto pertence a uma determinada classe. Uma

classe agrupa objetos similares;

4. A classe é um repositório para comportamento associado ao objeto;

5. Classes são organizadas em hierarquias.

8.3 Características da Orientação a

Objetos

Hierarquização:

após dividir um computador em gabinete, vídeo e teclado, é possível subdividir o gabinete em memórias RAM, ROM, disco, processador, etc.

é possível fazer o mesmo com sistemas aplicativos, hierarquizando-os via divisão em subsistemas.

71



Classificação:

enquadramento dos objetos em categorias (classes), conforme suas características e suas funções.

mamífero que mia é gato, que late é cachorro.

uma bicicleta e um automóvel são meios de transporte, tendo em vista sua funcionalidade.

Encapsulamento:

Consiste em separar os aspectos externos de um objeto, que são acessíveis para outros objetos, dos detalhes internos de implementação do objeto [Rumbaugh];

forma de esconder detalhes de armazenamento dos dados e implementação de operações, protegendo-os contra acesso indevido;

possibilita o uso de algo sem que se conheça como foi construído ou implementado;

usa-se carro com injeção eletrônica sem necessitar saber detalhes de implementação da mesma.

8.4 Objetos e Classes

Objeto: um objeto é uma entidade que possui um estado e um conjunto definido de operações definidas

72



para funcionar nesse estado. O estado é representado como um conjunto de atributos de objeto. As operações associadas ao objeto fornecem serviços a outros objetos (clientes) que solicitam esses serviços quando alguma computação é necessária.

Classe: os objetos são criados de acordo com uma

definição de classe de objeto. Uma definição de classe de objeto funciona tanto como uma especificação quanto como um modelo (template) para criação de objetos. Essa definição inclui declarações de todos os atributos e operações que devem ser associados a um objeto dessa classe.

Imagine o projeto de um carro com a classe e cada unidade produzida como os objetos desta classe.

Os objetos se comunicam por meio da solicitação de serviços de outros objetos e, se necessário, por meio da troca de informações para o fornecimento do serviço.

73



As cópias das informações necessárias para executar o serviço e os resultados da execução do serviço são passados como parâmetros. Fique ligado: Os dados e os métodos de cada objeto estão definidos na

classe. É como se a classe servisse de molde para a formação dos seus objetos.

A classe dita as propriedades e comportamento que seus

objetos devem ter.

Jogo Rápido: Classe vs Objetos Com base na planta de uma casa, diversas casas podem ser construídas: Cada casa construída terá seu endereço, sua cor, seu

proprietário, ... Propriedades;

A planta representa a Classe; As casas representam os Objetos.

OBSERVAÇÃO: quando partimos de uma classe para o objeto desta classe falamos de instanciação; e quando partimos de um objeto para sua classe de origem falamos de classificação.

74



8.5 Os Quatro Pilares da OO

Abstração pode ser entendida, de forma simples, como uma técnica para lidar com a complexidade no desenvolvimento de software. Com ela a gente identifica, em cada instante, o que é essencial, deixando detalhes secundários para depois.

Refinamento sucessivo de um problema é uma forma de abstração.

75



Herança, segundo Rumbaugh “é o compartilhamento de atributos e operações entre as classes baseado em uma relação hierárquica”. Já Yourdon afirma que “é qualquer mecanismo que permite a um objeto incorporar toda ou parte da definição de outro objeto como parte de sua própria definição”. Quando um casal constitui família e nasce um filho, este levará características genéticas dos pais, ou seja, ele receberá uma herança genética. Comparativamente, uma subclasse (filha) herda de sua superclasse (pai) tanto os atributos (propriedades) quanto as operações (métodos). Assim como um filho possui características próprias, uma subclasse também pode ter atributos e operações próprias, além dos que herda da classe mãe. Na Orientação a Objetos podemos encontrar dois tipos de herança: simples (uma única superclasse) ou múltipla (várias superclasses). Java só possui herança simples! IMPORTANTE:

Uma operação em uma subclasse pode

redefinir/sobrescrever (override) a operação de mesmo nome em uma classe ascendente (extensibilidade).

Objetos da subclasse comportam-se como objetos da superclasse.

76



Uma instância de uma subclasse é uma instância de todas as suas superclasses.

Abaixo é possível observar um exemplo de herança, onde “Conta Poupança” herda tudo de “Conta”, além de possuir atributos e métodos próprios:

Quando se fala de herança, sempre surge os conceitos de “Generalização” e “Especialização”.

Generalização: formação de superclasses a partir de outras classes; sempre é possível utilizar: ...é um..., ...é do tipo..., ...é um subconjunto de...

Especialização: identificação de subclasses a partir de

uma classe de objetos; cada subclasse tem características adicionais.

77



Veja a seguir um exemplo contendo “Generalização” e “Especialização”:

Encapsulamento: É qualquer mecanismo que nos permita “esconder” a implementação do objeto fazendo com que outros componentes os sistema não tenham conhecimento do conteúdo interno dos dados armazenados do objeto [Yourdon]. Ele protege os dados de um objeto contra o acesso direto de outros objetos. O acesso aos dados é feito somente pelos métodos.

Entenda que as operações formam uma camada protetora em torno do núcleo que contém os dados. Os dados só podem ser acessados somente pela classe. Quando se fala “encapsular” significa fazer os atributos tornarem-se privados.

O objeto que envia uma mensagem ao outro NÃO conhece a estrutura interna do receptor.

78



Acima na figura temos um objeto com seus métodos e atributos (públicos ou privados). Os métodos e atributos privados ficam no núcleo, estão encapsulados, e somente podem ser acessados pela própria classe; já os métodos e atributos públicos podem ser acessados por qualquer objeto do universo! Polimorfismo: É a capacidade de tratar uniformemente uma coleção de objetos, enviando-lhes a mesma mensagem e verificando diferentes reações. Veja o exemplo abaixo:

79



Propriedade pela qual um mesmo método possui comportamento diferente do objeto no qual foi executado. O mesmo método “Produzir Som” vai disparar um som diferente de acordo com o animal (objeto) selecionado. Outros exemplos de polimorfismo:

Calcular área (retângulo, triângulo, círculo);

Sacar dinheiro de conta (poupança, corrente, especial).

8.6 Jogo Rápido... Com base na figura abaixo veja se é possível construir uma hierarquia de classes:

9. CLASSES E OBJETOS

EM JAVA

Objetos droids:

atacar!


definir classes em Java e

criar objetos destas

classes. Também

aprenderemos sobre

atributos e métodos.

Que a força esteja com

você!


81



9.1 Flash back... O paradigma de orientação a objetos consiste basicamente em organizar o software como uma coleção de objetos que incorporam a estrutura de dados e o comportamento, e trocam mensagens entre si. O foco do sistema é voltado aos dados (objetos), não às funções, já que o comportamento muda mais que a estrutura de dados.

Veja abaixo a comparação entre a forma de pensar Orientada a Objetos (focada nos dados) com a Estruturada ou Procedural (focada nas funções):

Objetos: “um objeto é qualquer coisa, real ou abstrata, na qual nós armazenamos dados e as operações que manipulam os dados” [Martin].

Uma das grandes vantagens da OO é que as abstrações são mais próximas do mundo real.

82



“Um objeto, ou uma instância, é uma abstração de alguma coisa no domínio do problema, refletindo as capacidades do sistema de manter informações sobre ele, interagir com ele, ou ambos, um encapsulamento de valores de atributos e seus serviços exclusivo” [Yourdon]. Um objeto é uma entidade independente (lembra das células?), composta por:

Estado Interno: uma memória interna em que valores podem ser armazenados e modificados ao longo da vida do objeto (conjunto de atributos ou variáveis de instância).

Comportamento: conjunto de ações predefinidas (denominadas métodos) através das quais o objeto responderá a demanda de processamento por parte de outros objetos.

FIQUE LIGADO...

Procedimentos e Funções são representados em Java por métodos. A diferença está no tipo de retorno. Se o tipo de retorno for nulo, indicado pela palavra void, o método representa um procedimento. Caso contrário, ou seja, se existe um tipo de retorno, o método representa uma função.

83



9.2 Definindo classes em Java Suponha que precisemos trabalhar com um tipo de dados diferente dos tipos de dados primitivos já existentes em Java, data, por exemplo. (na API Java encontramos tipos para datas, mas vamos fazer de contas que eles não existem e precisamos criar o nosso... você nunca brincou de faz de contas não?) Mas antes de trabalharmos com variáveis do tipo Data, precisamos primeiro definir esse novo tipo de dados, conhecido como Tipo Agredado de Dados. Vamos criar o novo Tipo Agregado de Dados com os seguintes campos: dia, mes e ano. Veja abaixo: public class Data {

int dia;

int mes;

int ano;

}

Agora que a nossa classe Data foi criada, podemos utilizá-la em nossos programas. Veja o código a seguir:

Tipo Agregado de Dados é um tipo de dados definido pelo programador.

84



public class TesteData{


Data hoje;

}

}

Então para declarar uma variável com o tipo recém criado basta escrever: Tipo nomeVariável;

Data hoje;

ATENÇÃO: tipos primitivos em Java alocam (gastam) espaço na memória quando são declarados. Por outro lado, objetos NÃO alocam espaço em memória quando são declarados.

Após declarada a variável, a mesma não referencia nenhum lugar. Nesse caso, diz-se que ela tem referência nula

(representado pela palavra reservada null). É preciso, portanto, criar um objeto para que ela tenha algo referenciado!

9.3 Criando Objetos Em Java para criarmos um novo objeto fazemos uso do operador new. Veja a seguir:

Variáveis declaradas do tipo agregado NÃO contêm o dado e sim uma referência para o dado.

85



...

Data hoje;

hoje = new Data();

...

O operador new realmente cria o objeto e depois disso, a memória está alocada e diz-se que o objeto foi criado.

Criar um objeto Instanciar um objeto IMPORTANTE: A variável hoje é chamada variável de referência, pois referencia o objeto. Ela NÃO é o objeto em si. Já as propriedades de um objeto são chamadas de variáveis de instância, pois cada instância tem seus próprios valores para suas variáveis de instância.

9.4 Acessando variáveis de instância Para acessarmos as variáveis de instância do objeto

precisamos fazer uso do operador “ . “ (ponto). Veja a alteração abaixo do nosso programa (classe) que testa o tipo Data: public class TesteData{


Data hoje;

hoje = new Data();

hoje.dia = 12;

hoje.mes = 10;

hoje.ano = 2011;

}}

86



Somente após o objeto ter sido criado na memória é que foi possível colocar valores para as suas variáveis de instância dia, mês e ano. Antes não seria possível, pois a referência na variável hoje estava nula (null).

9.5 Métodos dos Objetos Vimos que os objetos podem ter propriedades (dia, mês e ano). Mas eles também podem ter ações, aos quais chamamos de métodos. Veja abaixo a melhoria da classe Data com a inclusão de um método: public class Data {

int dia;

int mes;

int ano;

void exibir() {

System.out.print(dia+“/”+mes+“/”+ano);

}}

Sintaxe de Métodos em Java: public tipoDeRetorno nomeDoMétodo(tipo1 parâmetro1,

tipo2 parâmetro2, ...) {

// aqui é colocado o corpo do método

}

O tipo de retorno pode ser:

qualquer tipo primitivo (int, long, float, ...); qualquer classe (String, …);

87



void, para o caso de não retornar nada (lembrando procedimento da estruturada).

Abaixo se pode observar um exemplo de passagem de parâmetros: public class DeclaracaoDeMetodos {

// declarando um método (como função)

public int soma ( int a, int b ){

int s = a + b;

return s;

}

// declarando um método (como procedimento)

public void imprimir ( int a ) {

System.out.println ( a );

}

}

Na classe DeclaracaoDeMetodos temos dois métodos. No primeiro método, chamado soma, temos como retorno um número inteiro, resultado da soma de dois valores que serão passados como argumentos para os parâmetros. Já no segundo método, de nome imprimir, não existe nenhum retorno, apenas a impressão do argumento que será passado para o parâmetro.

Parâmetros... Argumentos... qual a

diferença entre eles???

88



Veja abaixo um exemplo de como um determinado método que foi declarado é chamado: // executando o método

int x = 10;

int z = soma ( x , 20 );

// declarando o método

public int soma ( int a, int b )

{

int s = a + b;

return s;

}

A variável x e o valor 20 são argumentos que são passados para os parâmetros do método soma.

OBSERVAÇÕES IMPORTANTES PARA TIPOS PRIMITIVOS

O número de parâmetros passados deve ser igual ao da definição;

Cada argumento individualmente deve ter tipo compatível ao da definição (parâmetro);

Para tipos primitivos, a passagem é por valor, ou seja, o valor (e não o endereço) da variável é passado;

Cada chamada a um método cria suas próprias instâncias dos parâmetros formais;

Uma expressão pode ser usada como argumento.

89



Abaixo mais um exemplo de passagem de parâmetros:

public class PassagemPorValor {

public static void incrementar (int x){

x = x + 1;

System.out.println(“dentro: x=” + x);

}

public static void main (String [] args){

int y = 1;

System.out.println(“antes: y=” + y);

incrementar (y);

System.out.println(“depois: y=” + y);

}

}

Em Java, todos os argumentos são passados

por valor, isto significa que o valor (e não o endereço) da variável é passado.

Assim, as modificações no parâmetro formal (dentro do

método) não afetam o parâmetro real (valor externo).

Passagem de Parâmetros para Objetos: como foi visto, a passagem de parâmetros de tipos primitivos em Java é feita por valor, ou seja, uma cópia do valor original é feita: modificações no parâmetro formal não são refletidas no parâmetro real. Já para objetos, uma cópia da referência para o objeto é passada e não uma cópia do objeto. Analise o exemplo a seguir:

90



public static void somar(int[] x) {

x[2] = x[1] + x[0];

}

public static void main(String args[]){

int[] a = new int[3];

a[0] = 1;

a[1] = 10;

a[2] = 20;

System.out.println(“antes >”+ a[2]);

somar(a);

System.out.println(“depois >”+ a[2]);

}

Analisando o que aconteceu graficamente:

Passando Parâmetros para o Programa: parâmetros também podem ser passados para o programa. Eles são acessíveis no método main() como um array de String.

91



public class Classe {

public static void main(String args[]) {

for (int i=0; i<args.length; i++) {

System.out.println(i+“=“+args[i]);

}

}

}

9.6 A Referência “this” Muitas vezes, principalmente quando estamos trabalhando com parâmetros dos métodos, precisamos utilizar uma forma de diferenciar o nome de um parâmetro de um nome de uma variável de instância. Imagine que a classe abaixo fosse criada: public class Animal{

String nome;

public void setNome(String nome){

nome = nome;

}

Na linha em negrito se pode perceber que o compilador Java vai ficar confuso (assim como a gente ficaria): o parâmetro nome vai receber o próprio valor? Ou o parâmetro nome vai

receber a variável de instância nome? Ou ainda, a variável de instância nome vai recebe o parâmetro nome? Ou mais ainda, a variável de instância nome vai receber a própria variável de instância. Ufa! Realmente é um grande problema a se resolver!

Java utiliza a referência this para resolver o problema

92



descrito anteriormente de forma bastante simples e elegante.

O identificador this denotará o objeto no qual o método é chamado. Ele sempre representa o objeto corrente! Veja abaixo quando devemos fazer uso desta referência:

1) diferenciar nomes de parâmetros e variáveis de instância:

String nome;

public Estudante(String nome){

this.nome = nome;

}

2) pode ser usada para ativar métodos como uma

referência comum:

atribuirNota(int numProva){

this.atribuirNota(numProva, 0.0);

}

3) pode ser passada como parâmetro ou atribuída a outra

variável do mesmo tipo:

processar(this);

Estudante estudanteCorrente=this;

this só pode ser usada na classe de definição!

93



9.7 Acessibilidade Pública e Privada O estado interno dos objetos deve ser mantido sempre consistente. Por exemplo, não gostaríamos de ver em um programa o valor de uma data com o dia 30 de fevereiro (estado inconsistente). As variáveis de instância são as responsáveis pelo estado interno dos objetos. E o acesso direto a estas variáveis através de outras classes pode comprometer o estado interno dos objetos (situações inconsistentes). Então NÃO é recomendável também deixar que as classes clientes sejam responsáveis pelas validações das variáveis de instâncias de nossas classes. Quem tem que saber se uma data, por exemplo, está correta é a classe especializada em datas! Exemplo:

Para evitar que situações como essa ocorram, uma boa prática é impedir acesso direto às variáveis de instância dos objetos. Em Java isto é alcançado declarando todas as variáveis de instância com o modificador de acesso private, isto é, a

94



variável de instância passa a ser visível (ou acessível) somente dentro da própria classe onde é definida. public class Data {

private int dia;

private int mes;

private int ano;

...

Dessa forma, um acesso como mostrado a seguir vai acusar erro de compilação, impedindo que ocorra o acesso direto às variáveis de instância. public class Cliente

{

public static void main(String args[])

{

Data hoje = new Data();

hoje.mes = 15; // Erro de compilação!

...

Mas e agora como fazemos para atribuir valores às variáveis

dia, mes e ano da classe Data, se não temos acesso fora dela? Simples, basta criarmos métodos públicos para fazer isso! Um método público é declarado com o modificador de acesso public e torna o membro visível a partir de qualquer outra classe da galáxia ou até outros universos. Em Java existem algumas convenções que padronizam os nomes dos métodos de acesso às variáveis de instância. Eles são chamados de métodos get e set:

95



Métodos de alteração do valor → set

Métodos de obtenção do valor → get Por convenção o nome do método é formado utilizando-se a palavra get ou set seguido do nome da variável de instância:

setNomeDaVariavel

getNomeDaVariavel

Exemplo: setMes: para atrituir valor à variável de instância mes getMes: para obter o valor da variável instância mes

9.8 Métodos Construtores Construtores são métodos especiais que são chamados no momento da criação de um objeto. Eles servem para inicializar objetos de forma organizada, ou seja, servem para “setar” o estado inicial de um objeto quando ele é criado. Pode haver mais de um construtor por classe: overloading (veremos isto no próximo tópico... segura a curiosidade só mais um pouco!).

O modificador de acesso private vai permitir

fazer uso do encapsulamento!

96



Métodos Construtores possuem algumas restrições:

Devem ter o mesmo nome da classe;

Não possuem valor de retorno;

Podem ter modificadores de acessibilidade (public, ...);

São chamados somente quando o operador new é executado.

Exemplo: public class Data {

int dia;

int mes;

int ano;

public Data() {

ano = 2010; }

... }

Utilizando… public class Programa {


// construtor default – sem parâmetros


...

9.9 Sobrecarga de Métodos Em Java métodos podem ter o mesmo nome e diferentes listas de parâmetros. Este mecanismo é o que chamamos de sobrecarga de métodos ou overloading. Ele serve para

97



implementarmos uma das facetas do polimorfismo. Veja o exemplo abaixo: public class Data {

int dia;

int mes;

int ano;

void exibir() { ... }

int diasDoAno() { ... }

void incrementarAno() {

ano++; }

void incrementarAno( int anos ) {

ano += anos;

} }

Regra para Sobrecarga: métodos sobrecarregados NÃO podem ter a mesma assinatura e os parâmetros devem diferir em tipo, ordem ou número. OBSERVAÇÃO: Métodos Construtores também podem ser sobrecarregados. Veja o código a seguir: public class Data {

...

public Data() {

ano = 2004; }

public Data( int numAnos ) {

ano = numAnos; }

...

}

98



Utilizando… public class Programa {

public static void main (String args []) {


Data depois = new Data( 2005 );

...

9.10 Membros Estáticos Tanto variáveis quanto métodos podem usar o modificador static, passando a serem chamados de membros de classe. Eles são utilizados para representar propriedades da classe (variável) ou executar alguma tarefa de interesse da classe (método).

Os membros estáticos são criados e inicializados quando a classe é carregada. O padrão Java para membros estáticos é o mesmo usado para membros de instância (ex: umMetodoEstatico(), umaVariavelEstatica).

Variáveis Estáticas: você se lembra de que cada instância de uma classe tem seus próprios atributos ou propriedades, que são as variáveis de instância? Pois assim como uma instância tem suas propriedades, uma classe pode ter suas propriedades também! As propriedades estáticas pertencem às classes e são

Membros estáticos pertencem à classe e NÃO a uma instância específica!

99



compartilhadas por todas as instâncias de uma classe. Elas podem ser acessadas sem necessitar instanciar um novo objeto (pois se referem à classe e não a um objeto). As variáveis de classe ou estáticas são usadas como variáveis globais para os objetos daquela classe. Por exemplo, vamos supor que desejamos armazenar o número de datas já criadas, ou seja, o número de objetos da classe Data já criados. Essa informação NÃO pode ser tratada como uma variável de instância, pois cada instância teria um valor diferente pra ela. Devemos então representar essa ideia como uma variável de classe. Veja o código a seguir: public class Data

{

public static int numDatas = 0;

private int dia;

private int mes;

private int ano;

100



public Data() {

numDatas++;

dia = 1; mes = 1; ano = 1900;

}

public Data(int d, int m, int a) {

numDatas++;

dia = d; mes = m; ano = a;

} ...

A variável estática pode ser acessada: dentro da própria classe (usando seu nome) ou fora da classe (através de uma variável de referência de qualquer objeto de sua classe ou através do nome da classe). Exemplo: public class Cliente {



Data depois = new Data();

Data amanha = new Data();

// acesso usando um uma variável de

// referência de uma instância da classe

System.out.println(hoje.numDatas);

System.out.println(amanha.numDatas);

// acesso usando o nome da classe

System.out.println(Data.numDatas);

} }

Métodos Estáticos: os métodos também podem ser

estáticos (static), ou seja, podem pertencer à classe. Eles representam operações relativas a toda a classe e não a um objeto em particular.

101



Exemplo: public class Empregado

{

public void aumentarSalario() { ... }

public static void feriasColetivas()

{ ... }

}

Veja o exemplo de visibilidade de membros estáticos abaixo e diga se existe algum problema: public class Data {

private static int numDatas = 0;

private int dia;

Dentro da própria classe um método static só pode acessar membros static, NÃO pode acessar membros de instância. Já um método de instância pode acessar membros static bem como de instância. Fora da própria classe deve-se usar o nome da classe ou nome de uma variável de instância. Lembre-se que depende do modificador de acesso utilizado (mesma para membros de instância):

public → acessível ou private → inacessível

102



private int mes;

private int ano;

public static int getNumDatas() {

System.out.println( “dia = ” + dia );

return numDatas;

}

public void exibir() {

System.out.println(dia+“/”+mes+“/”+ano);

System.out.println( numDatas );

}}

A seguir um exemplo de código acessando membros estáticos: public class Cliente

{



Data depois = new Data();

Data amanha = new Data();

// acesso usando um uma variável de

// referência de uma instância da classe

System.out.println(hoje.getNumDatas());

System.out.println(amanha.getNumDatas());

// acesso usando o nome da classe

System.out.println(Data.getNumDatas());

} }

9.11 Vamos treinar?

a) Implementar um programa que receba cinco palavras da linha de comando e as mostre em ordem inversa em que foram digitadas.

103



b) Escreva um método estático para calcular a média dos

elementos de um array passado como parâmetro.

c) Escrever um método estático em Java chamado testarPrimo que receba como parâmetro um número inteiro e retorne true se N é um número primo ou false caso contrário. Depois disso, implementar um programa Primo que leia repetidamente da entrada padrão um número inteiro N, 1 < N < 1000, e execute o método testarPrimo para verificar se o número é primo ou não, imprimindo o resultado. O programa deve parar se o número for menor ou igual a 0 (zero).

d) Implementar uma classe Estudante com as seguintes propriedades:

– matricula (int) – nome (String) – sexo (char) – um array chamado ‘notas’ com 4 posições (double []), sendo uma para cada nota parcial.

e as seguintes operações:

– void exibir() : mostra os dados do Estudante; – void atribuirNota(int numProva, double nota) : coloca a nota no array na posição numProva-1; – double lerNota(int numProva) : procura no array e retorna a nota existente na posição numProva-1.

e) Implementar um programa chamado TesteEstudante

104



que realiza as seguintes operações:

– criar um estudante; – atribuir os valores 2004001, “Maria Silva” e ‘F’ para as variáveis de instância matricula, nome e sexo, respectivamente; – preencher o array de notas com os valores 7.0, 8.2, 6.0, 5.5; – exibir na tela os valores de todas as propriedades do estudante; – exibir na tela os valores de todas as notas do estudante; – realizar outras operações para praticar.

f) Aperfeiçoar a classe Estudante adicionando as

seguintes funcionalidades:

– criar um método sobrecarregado ao método atribuirNota já existente, para atribuir a nota 0.0 (zero) ao índice passado como parâmetro – atribuirNota(int indice); – criar um método sobrecarregado ao método exibir passando o título dos dados a seremexibidos – exibir(String titulo); – criar três construtores sobrecarregados:

um default (sem parâmetros), que

105



inicializa as variáveis de instância para os valores default (padrões);

outro que recebe somente nome e sexo do Estudante;

e um terceiro que recebe nome, sexo e matricula do Estudante.

g) Complementar o programa TesteEstudante com as

seguintes operações:

– criar três estudantes, cada um utilizando um construtor diferente:

sem parâmetros passando nome e sexo passando nome, sexo e matricula

– executar os métodos sobrecarregados para os estudantes acima:

atribuirNota(1, 7.0); atribuirNota(2, 5.0); atribuirNota(3); atribuirNota(4, 8.5); exibir(); exibir(“dados do estudante”).

h) Criar uma variável de classe (static) privada chamada numEstudantes para a classe Estudante que faça a contagem do número de estudantes já criados. Incrementar a variável de classe criada dentro dos métodos construtores.

106



i) Implementar um método de classe (static) público chamado getNumEstudantes que retorne o número de estudantes criados.

j) Incrementar o programa TesteEstudante para imprimir o número de estudantes criados, chamando o método getNumEstudantes a partir de variáveis de referência ou usando o nome da classe.

10. PACOTES

Neste capítulo você aprenderá como

organizar suas classes em pacotes e qual a importância deles.


108



10.1 Cadê o Meu Pacote? As classes de um mesmo diretório em Java são visíveis umas às outras. Mas como fazemos para visualizar classes de outros diretórios? Utilizar O esquema de pacotes serve para dois propósitos:

permitir o agrupamento de classes inter-relacionadas;

possibilitar a visualização de classes “empacotadas” em outros diretórios.

Um pacote serve para agrupar classes, interfaces e subpacotes inter-relacionados. Cada pacote está associado a um diretório do Sistema Operacional, mas nem todo diretório é um pacote. Também é importante saber que classes de pacotes diferentes podem ter o mesmo nome e que o uso de pacotes influencia na acessibilidade dos objetos.

Para declarar que o conteúdo de um arquivo pertence a determinado pacote, usa-se a cláusula package no início do arquivo: package faculdade;

Pacotes estão associados ao agrupamento de arquivos “.class” e não de arquivos “.java”. Cada pacote deve

ter o seu subdiretório a partir do CLASSPATH.

109



Supondo que o diretório C:\home está no CLASSPATH, as classes do pacote faculdade devem estar no diretório C:\home\faculdade. Em cada arquivo fonte desse mesmo pacote deve haver a mesma cláusula package no início.

10.2 Definindo Subpacotes Para definirmos subpacotes basta fazermos uso do operador ponto “ . “. Por exemplo, para declarar que o conteúdo de um arquivo pertence a determinado subpacote de um pacote, usa-se a cláusula package no início do arquivo com a seguinte sintaxe: package faculdade.classes;

Supondo que o diretório C:\home está no CLASSPATH, as

classes do subpacote faculdade.classes devem estar no diretório C:\home\faculdade\classes. Classes contidas em pacotes são identificadas prefixando-se o nome do pacote ao seu nome. Exemplo: faculdade.classes.Estudante

(classe Estudante contida no pacote faculdade.classes) java.awt.Button

(classe Button faz parte do pacote java.awt)

110



Observe que ponto (.) permite definir classes com mesmo nome em diferentes pacotes: java.sql.Date; é diferente de java.util.Date; As classes de um pacote podem ser utilizadas por outra classe da seguinte maneira: usando o nome da classe totalmente qualificado (especificando todo o caminho) ou a partir de um import usando o operador ponto (.). Exemplo 1 (nome totalmente qualificado): class TesteEstudante

{

faculdade.classes.Estudante e;

... Exemplo 2 (utilizando import): import faculdade.classes.Estudante;

class TesteEstudante

{

Estudante e;

...

Pode-se ainda usar o asterisco (*) para importar todas as classes de um mesmo pacote: import faculdade.classes.*;

ATENÇÃO: o asterisco (*) não importa subpacotes, somente as classes daquele pacote! Podem existir vários importações em um mesmo arquivo.

111



10.3 Nomeando Pacotes Há um esquema global de nomes para pacotes, que segue o padrão de nomes de domínio da Internet, escrevendo a URL das empresas de trás para frente, o que permite identificação única de classes em toda Internet. O objetivo é evitar conflito entre classes de fornecedores diferentes. Exemplo: Imagine que os pacotes que pertencerem à empresa SoftExport devem ter o seguinte formato: br.com.softexport.sql

As classes do subpacote sql estariam no diretório: \br\com\softexport\sql.

10.4 Acessibilidade de Pacotes

Além das acessibilidades pública (public) e privada

(private), há uma outra associada aos pacotes. É a acessibilidade padrão (default), que indica que somente classes dentro de um mesmo pacote podem ter acesso aos métodos e variáveis. Esse modificador é utilizado quando não se coloca nada em classes, métodos ou variáveis. Exemplo: long tamanho;

long getTamanho() {

return tamanho; }

112



NÃO ESQUECER: Para Classes e Interfaces só existe dois tipos de acessibilidade:

pública: a classe (ou interface) é visível de qualquer lugar. Deve-se usar a palavra-reservada public.

pacote ou default: a classe só é visível dentro do próprio pacote, não sendo enxergada fora dele, nem mesmo em seus subpacotes. Não usa nenhum modificador.

Exemplo: package br.com.softexport.sql;

public class Date

{ ... }

class TestDate

{ ... }

10.5 Vamos Treinar?

a) Trabalhar a aplicação de estudantes para usar pacotes. Para isso, defina a seguinte árvore de diretórios a partir do raiz (C:\)

113



O pacote deve começar a partir do diretório faculdade.

b) Coloque a classe Estudante no pacote

faculdade.classes e TesteEstudante no pacote faculdade.principal.

c) Importe o pacote faculdade.classes dentro da classe

TesteEstudante.

11. O QUE GANHEI DE

HERANÇA?

Aqui você ficará

sabendo o que as

classes fazem

para herdarem

tudo de seus pais.

Será que foram

boas filhas?

“Java is

Everywhere”

115



11.1 Introdução No capítulo anterior a gente criou uma classe chamada Estudante (você fez os exercícios não foi? ¬¬). Mas então, como faríamos para criar outros tipos de estudantes, que possuíssem propriedades e realizassem operações semelhantes ao estudante que já conhecemos apenas com algumas poucas diferenças? Poderíamos imaginar, por exemplo, em estudantes tutores, que realizam tutoria na universidade, e estudantes estagiários, que desenvolvem estágio em alguma empresa. Esses novos tipos de estudante possuem as mesmas propriedades e realizam as mesmas operações que o estudante comum, porém, também possuem novas propriedades e realizam novas operações.

Estudante Estudante Tutor Estudante Estagiário

11.2 Definindo nossas classes As nossas três classes (Estudante, EstudanteTutor e

EstudanteEstagiario) serão definidas conforme apresentado a seguir:

116



Estudante Propriedades:

o nome; o matricula; o sexo; o notas.

Operações: o exibir(); o atribuirNota(); o lerNota(); o calcularMedia().

Estudante Tutor Propriedades comuns:


Novas propriedades: o bolsa; o disciplina.

Operações comuns: o exibir(); o atribuirNota(); o lerNota(); o calcularMedia().

Novas operações: o tirarDuvidas(); o auxiliarProfessor().

117



Estudante Estagiário Propriedades comuns:


Novas propriedades: o empresa; o salario.

Operações comuns: o exibir(); o atribuirNota(); o lerNota(); o calcularMedia().

Nova operação: o trabalhar().

Enquanto isto, na cabeça do desenvolvedor da programação estruturadas...

118



Em uma programação tradicional, o desenvolvedor teria que definir diversas vezes os métodos que são comuns as classes Estudante, EstudanteTutor e EstudanteEstagiario. O reaproveitamento de código nesse caso se basearia no Copy & Paste (copiar e colar). O grande problema é que quando algum desses métodos precisarem ser alterados, todas as classes correspondentes precisarão ser alteradas. Resultado: manutenção difícil!

11.3 Vale a pena ver de novo... Herança de Classes é usada na Programação Orientada a Objetos para definir novas classes a partir de uma classe existente. A nova classe herda todos os membros (variáveis e métodos) da classe antiga sem precisar reescrever o código novamente. A nova classe é chamada de: subclasse, classe derivada, classe filha, etc. Já a classe antiga é chamada de: superclasse, classe base, classe mãe, classe pai, entre outras. A subclasse pode (e deve) acrescentar novo comportamento (métodos) e/ou propriedades (variáveis), e, em algumas situações, até mesmo mudar o comportamento herdado. Herança é utilizada caracteristicamente no processo de Especialização de funcionalidades mais gerais para situações

119



mais específicas, evitando que se tenha que iniciar a codificação do zero. Já a Generalização segue o processo inverso, isto é, parte de situações mais específicas para as mais gerais.

NÃO ESQUECER:

Herança define uma relação do tipo “é um” (ou relação superclasse-subclasse), enquanto agregação define uma relação do tipo “tem um” (ou relação todo-parte).

Existem dois tipos de Herança de Classes na Orientação a Objetos: Herança Simples (uma subclasse só pode ter uma superclasse imediata) e Herança Múltipla (uma classe pode ter várias superclasses imediatas).

Em Java, uma classe só pode herdar de, ou estender, uma única classe. Em outras palavras, uma classe só pode ter uma única superclasse imediata. Assim, Java só permite herança simples de classes, que é também chamada de herança linear de implementação, ou herança simples de implementação.

Agregação é outro mecanismo fundamental de reuso de código!

120



11.4 Aplicando Herança em Java Em Java, a superclasse é especificada por meio da cláusula extends no cabeçalho da subclasse. Veja o exemplo abaixo: public class Animal extends SerVivo{

...

}

A subclasse animal possui como superclasse SerVivo.

É importante observar que se não for especificada nenhuma cláusula extends, a classe herdará implicitamente da classe

java.lang.Object, que é a classe pai de todas as classes. A subclasse especifica apenas membros novos ou modificados, sendo o resto da definição herdada da superclasse. Vamos relembrar a classe Estudante: public class Estudante

{

// variaveis de instancia

private int matricula;

private String nome;

private char sexo;

private double notas[] = new double[4];

// metodos de instancia

public void exibir() { ... }

public void atribuirNota(int p,double n)

{ ... }

121



public double lerNota(int p) { ... }

public void calcularMedia() { ... }

}

Para estender da classe Estudante, cria-se um novo arquivo chamado EstudanteTutor.java com o seguinte código: public class EstudanteTutor extends Estudante{

// novas variáveis de instância

private double bolsa;

private String disciplina;

// as outras variáveis são herdadas

// novos métodos de instância

public void tirarDuvidas() { ... }

public void auxiliarProfessor() { ... }

// os outros métodos são herdados

}

E por fim, para representar o estagiário, cria-se um novo arquivo chamado EstudanteEstagiario.java com o seguinte código:

class EstudanteEstagiario extends Estudante{

// novas variáveis de instância

private double salario;

private String empresa;

// as outras variáveis são herdadas

// novo método de instância

public void trabalhar() { ... }

// os outros métodos são herdados

}

122



11.5 Mais Sobre o Mecanismo de

Herança Quando utilizamos herança em Java existem algumas coisas interessantes, como por exemplo:

Atributos e métodos privados são herdados, mas não podem ser acessados diretamente. Para acessá-los devem-se usar os métodos get (acessador) e set (alterador);

Uma instância de uma subclasse é uma instância de

todas as suas superclasses;

Exemplo:

EstudanteTutor et = new

EstudanteTutor();

Estudante e = et;

Estudante e2 = new EstudanteTutor();

VANTAGENS DO USO DA HERANÇA

Permite o reuso de código; Facilita a manutenção dos sistemas; Melhora o entendimento por parte da equipe de

desenvolvimento; Acaba com o antipadrão “Copy & Paste”.

123



Objetos da subclasse comportam-se como objetos da superclasse;

Exemplo:

EstudanteTutor et;

et = new EstudanteTutor();

et.auxiliarProfessor();

et.atribuirNota(1, 7.5);

et.lerNota(1);

Objetos da subclasse podem ser usados no lugar de

objetos da superclasse.

Exemplo:

class Turma {

String nome;

Estudante estudantes[];

estudantes = new Estudante[5];

private int numEstudantes = 0;

public void matricular(Estudante e){

estudantes[numEstudantes] = e;

numEstudantes++;

}

}

class Programa{


EstudanteTutor et;

et = new EstudanteTutor(“Pedro”);

Turma t;

t = new Turma(“POO Java”);

t.matricular( et );

}

}

124



11.6 Classes Finais Muito bom esse negócio de herança, mas existem casos que a gente não quer que ninguém estenda a nossa classe. São aqueles casos que a herança vai ficar com o além... Em Java quando queremos que ninguém estenda (herde) de uma determinada classe, a gente utiliza o modificador final. Veja o exemplo abaixo: final class Cachorro extends Animal {

...

}

Agora ninguém conseguirá estender a classe Cachorro. A classe já está perfeita e não é preciso mais nenhuma além dela (pensamento de quem implementou a classe).

11.7 Vamos treinar?

a) Desenhe um diagrama de classes UML que represente a seguinte hierarquia: – Funcionário tem nome, matrícula, sexo e data de nascimento e recebe salário; – Professor é um Funcionário que tem número de horas aula e leciona; – Contador é um Funcionário que tem inscrição no Conselho de Contabilidade (CC) e executa a contabilidade; – Coordenador é um Professor que tem cargo e é responsável por criar turmas.

125



b) Codifique classes em Java que implementem a hierarquia acima. Não esqueça dos métodos get e

set!

c) Implemente um programa para criar objetos das subclasses Professor e Coordenador e executar métodos herdados.

12. REDEFINIÇÃO DE

MÉTODOS

Neste capítulo

veremos que o

comportamento

herdado pode ser

alterado facilmente.


127



12.1 Mais Sobre Referência “this” Em Java é possível referenciar o objeto atual que está executando um determinado método. Para isto basta

fazer uso do identificador this. A referência this é passada como um parâmetro implícito quando um método de instância é chamado, representando sempre o objeto corrente e só pode ser usada na classe de definição. A referência this geralmente é usada para:

diferenciar nomes de parâmetros e variáveis de instância:

private String nome;

public Estudante( String nome ){

this.nome = nome; }

pode ser usada para ativar métodos como uma

referência comum:

void atribuirNota(int numProva){

this.abribuirNota(numProva,0.0);}

pode ser passada como parâmetro ou atribuída a outra

variável do mesmo tipo:

processar(this);

Estudante e = this;

128



12.2 O Construtor “this()” Toda classe instanciável possui pelo menos uma definição de construtor associada a ela, seja diretamente ou em uma superclasse (utilizando herança). Um construtor da superclasse imediata é sempre chamado, mesmo que implicitamente. Por isso dizemos que construtores não podem ser sobrescritos. Construtores podem ser apenas sobrecarregados, mas somente na mesma classe.

A chamada de método this() pode ser usada para encadear construtores sobrecarregados (não confundir com a referência this). A chamada this() só pode ser usada em definições de construtores, e, quando usada, deve sempre ser a primeira sentença no código do construtor. Veja a seguir: public Estudante(String nome,char sexo) {

this.sexo = sexo;

this.nome = nome;

}

public Estudante(String nome,char sexo,int

matricula){

this( nome, sexo );

Um construtor sem parâmetros é chamado de construtor default ou padrão.

129



this.matricula = matricula;

}

12.3 Nem Tudo Eu Faço Igual à Papai

Já vimos que quando fazemos herança, a subclasse herda tudo (propriedades e métodos) da superclasse . Mas o problema é que nem sempre a subclasse quer ter o comportamento que recebeu por herança igualzinho ao de seu pai. Na verdade, às vezes, a subclasse quer dar seu toque especial naquele comportamento herdado. Nestas horas precisamos fazer uso da sobrescrita. Analise o exemplo abaixo: class ContaCorrente{

int numero;

double saldo;

public void creditar(double valor){...}

public void debitar(double valor){

if ( valor <= saldo ) saldo -= valor;

}}

class ContaEspecial extends ContaCorrente{

130



private double limite;

public void debitar(double valor){

if (valor <= saldo + limite){

saldo=(valor>saldo)?0:saldo-valor;

limite -= (valor – saldo); }

} }

Se você tiver observado com bastante atenção as classes acima deve ter percebido que o método debitar() de ContaCorrente não serve para ContaEspecial, embora seja herdado. Quando especializamos o comportamento de uma dada classe, muitas vezes se faz necessário redefinir métodos em subclasses. Uma forma de fazer isso é através da redefinição ou sobrescrita (overriding) de métodos. A redefinição de métodos ocorre quando uma classe define um método usando o mesmo nome, tipo de retorno e argumentos de um método da superclasse (como foi o caso de ContaCorrente e

ContaEspecial). Um método sobrescrito é um método na subclasse com a mesma assinatura:

mesmo nome de método; mesmos parâmetros (mesmos nomes, mesmos tipos,

mesma quantidade e mesma ordem); mesmo tipo de retorno de um método na superclasse.

O que muda é somente a implementação que será diferente na subclasse. Mas saiba que visibilidade do método, pode ser aumentada.

private default protected public

131



Mais um exemplo: class A {

void f( ) {

System.out.println (“Classe A”);

}

}

class B extends A{

void f( ) {

System.out.println (“Classe B”);

}

}

Se o código abaixo for executado, com base nas classes acima, apareceria o que na tela? public class TesteSobrescrita1 {

public static void main(String args[ ]){

B b = new B ();

b.f();

A a = new A();

a.f();

a = b;

a.f();

}

}

12.4 A referência “super” A palavra-chave super pode ser usada no corpo de um método de instância em uma subclasse para acessar variáveis e invocar métodos herdados da superclasse. É geralmente usada para invocar métodos sobrescritos (overridden methods) ou acessar variáveis que foram ocultadas pela subclasse (shadowed variables). Só é possível acessar a

132



definição dos métodos da superclasse imediata!

Exemplo: class A {

void f( ) {

System.out.println( “Classe A” );

}

}

class B extends A {

void f( ) {

super.f();

System.out.println( “Classe B” );

}

}

public class TesteSobrescrita {

public static void main ( String args [ ] )

{

B b = new B ();

b.f();

A a = new A();

a.f();

a = b;

a.f();

}

}

12.5 O Construtor “super()”

super provê uma referência ao objeto corrente como uma instância de sua superclasse.

133



Em Java construtores não são herdados, mas podem ser acessados! A chamada super() invoca um construtor na superclasse imediata, com os mesmos parâmetros da chamada. Assim como na chamada this(), a chamada super() só pode ser usada em definições de construtores. ATENÇÃO: a chamada super(), quando usada, deve sempre ser a primeira sentença no código do construtor. Isto implica que só é possível utilizar this() ou super() de cada vez, nunca os dois! Exemplo: class Estudante {

public Estudante( String nome, char sexo,

int matricula) {

this.sexo = sexo;

this.nome = nome;

this.matricula = matricula;

} ...

}

class EstudanteTutor extends Estudante {

public EstudanteTutor(String nome,char sexo,

int matricula,double bolsa,String disciplina){

super( nome, sexo, matricula );

this.bolsa = bolsa;

this.disciplina = disciplina;

}}

134



12.6 Encadeamento de Construtores É importante observar que se a classe não definir nenhum construtor, seu construtor default será chamado quando da criação de objetos.

Se não for especificada uma chamada this() ou super() dentro do construtor, a JVM inclui implicitamente uma chamada ao construtor default da superclasse. Fique Ligado: é uma boa prática sempre implementar o construtor padrão de uma classe, por que se a super classe imediata não possuir construtor default, ocorrerá erro de compilação.

135



12.7 Métodos Finais Já aprendemos que as variáveis podem ter o modificador final, que as transforma em constantes, ou seja, uma vez que elas tenham sido inicializadas, não poderão ter seus valore alterados. Mas também é possível termos métodos com o modificador final. Quando isto acontece, o método não pode ser redefinido (overriding) em suas subclasses, ou seja, é a versão final do método (ninguém vai alterar o comportamento herdado de papai!). Exemplo: class Transporte {

final public void setNumPneus(int pneus){

noOfTyres = tyres;

}

}

class Carro extends Transporte {

public void setNumPneus(int pneus){

noOfTyres = 2 * tyres;

}

}

136



12.8 Vamos Treinar?

a) Alterar as subclasses EstudanteTutor e EstudanteEstagiario da superclasse

Estudante, implementando em seus construtores

chamadas aos construtores this() e super().

b) Sobrescrever os métodos necessários nas subclasses EstudanteTutor e EstudanteEstagiario (exibir, atribuirNota, etc.), chamando métodos da superclasse através da referência super, quando necessário.

13. REFERÊNCIA E CIA...

Vamos aprender a

manipular as variáveis

de referência de uma

forma mais poderosa

para implementar o

polimorfismo.


138



13.1 Manipulando Referências De maneira geral, o tratamento dado em Java para conversões de tipo para referências a objetos é análogo ao que acontece nas conversões de tipos primitivos. Conversões de tipo (classe) para referências a objetos podem ocorrer de duas formas:

Implicitamente: em atribuições e passagem de parâmetros;

Explicitamente: por meio de casting explícito.

EstudanteTutor et = new EstudanteTutor();

Estudante e = et;

Conversões de tipos mais específicos para tipos mais gerais (upcasting) são permitidas.

139



Exemplo de Upcasting: public class Programa {


// situação 1

Estudante e = et;

// situação 2

Turma t = new Turma();

t.matricular( et );

}

public class Turma {

...

public void matricular( Estudante e ) {...}

...

}

Já ao contrário, conversões de tipos mais gerais para tipos mais específicos (downcasting) exigem casting explícito. Isto vale para a hierarquia completa de herança, incluindo classes e interfaces.

13.2 Casting de Referências Em Java para fazer casting (conversão) da variavelDeReferencia do TipoDeOrigem para o TipoDeDestino, usa-se a seguinte sintaxe: TipoReferencia variavelDeReferencia = new

TipoDeDestino();

TipoDeDestino variavelDeDestino =

(TipoDeDestino) variavelDeReferencia;

O casting acima é possível SOMENTE se o objeto denotado pela variavelDeReferencia, em tempo de execução é:

140



uma instância da classe TipoDeDestino ou uma instância de uma subclasse dela.

Jogo Rápido: O código está correto? Ele faz o que? public class Turma {

...

public Estudante obterEstudante(int mat)

{...}

}

...

EstudanteTutor et;

et = new EstudanteTutor(111, “Pedro”, ‘M’);

Turma t = new Turma()

t.matricular( et );

EstudanteTutor et2 = t.obterEstudante( 111 );

Se você analisou o código com cuidado deve ter percebido (diga que percebeu...) que o método obterEstudante retorna uma referência

para um objeto do tipo Estudante, mas na última linha estamos tentando atribuir

a referência retornada (Estudante) à uma variável de referência do tipo EstudanteTutor, gerando um erro de

compilação, por que nem todo Estudante

é um EstudanteTutor. Para resolver o problema teríamos que alterar a linha para: EstudanteTutor et2 =

(EstudanteTutor) t.obterEstudante( 111 );

141



A figura abaixo faz todo o resumo sobre casting:

13.3 Operador instanceof O operador binário instanceof tem a seguinte sintaxe: variavelDeReferencia instanceof TipoDeDestino

Este operador retorna true se o objeto denotado pela

variavelDeReferencia, em tempo de execução, é:

uma instância da classe TipoDeDestino, ou uma instância de uma subclasse dela.

IMPORTANTE: em tempo de compilação é verificado se o tipo da variavelDeReferencia e o TipoDeDestino estão no mesmo ramo da hierarquia de classes. Caso contrário, acontecerá um erro de compilação.

142



Com base na hierarquia de classes abaixo, informe qual o valor retornado para cada um dos “instanceof”:

C c = new C();

c instanceof C __true___

c instanceof B _________

c instanceof A _________

c instanceof E _________

c instanceof D _________

c instanceof Object _________

13.4 Unindo casting e instanceof Para os nossos códigos ficarem mais seguros contra erros em tempo de execução podemos fazer uso da combinação de

casting e instanceof. Veja a seguir: ...


Turma t = new Turma()

t.matricular( et );

Estudante e = t.obterEstudante( 111 );

if ( e instanceof EstudanteTutor )

{

( (EstudanteTutor) e ).tirarDuvidas();

}

...

143



Com isto, agora o método tirarDuvidas()só é executado se o objeto real (que está na memória) for do tipo EstudanteTutor. Veja o trecho de código abaixo e tente explicar o que está errado: Estudante e = new Estudante();

EstudanteTutor et = (EstudanteTutor) e;

___________________________________________________ ___________________________________________________ ___________________________________________________

Tanto o casting quanto o operador instanceof requerem verificação:

em tempo de compilação: que avalia somente as referências, e;

em tempo de execução: que avalia o objeto propriamente dito.

144



13.5 Passagem de Parâmetros Como já foi visto, a passagem de parâmetros de tipos primitivos em Java é feita por valor, ou seja, uma cópia do valor original é feita. Isso significa que modificações no parâmetro formal não são refletidas no parâmetro real. Já para arrays (objetos), uma cópia da referência para o array é passada.

Então as mudanças ocorridas nos elementos de um array dentro de um método, se refletem no lugar onde o método foi chamado. Veja o exemplo:

public static void somar(int[] x) {

x[2] = x[1] + x[0];

}

public static void main (String args[]) {

int[] a = new int[3];

a[0] = 1;

a[1] = 10;

a[2] = 20;

System.out.println(“antes >”+ a[2]);

somar(a);

System.out.println(“depois >”+ a[2]);

}

Antes da chamada ao método somar(a), o valor armazenado no índice 2 do array é igual a 20. Após a chamada ao método o valor foi alterado para 11.

Para objetos, uma cópia da referência ao objeto é passada, e não uma cópia do objeto.

145



NÃO ESQUECER:

Apesar da passagem por parâmetros em Java ser por valor, pode-se ter aliasing quando uma referência a um objeto é passado como parâmetro, assim como acontece na atribuição de referências.

Exemplo: public static void main( String args[] ) {

Data hoje;

hoje = new Data();

funcao(hoje);

System.out.println( hoje.getMes() ); // 10

}

static void funcao( Data umaData ) {

umaData.setMes( 10 );

}

Assim que o objeto referenciado por hoje for criado, suas variáveis de instância estarão todas com o valor padrão para inteiros: zero. Quando o método funcao for chamado ele receberá uma referência do tipo Data, e em seguida alterará o

mês para 10. Essa alteração será sentida por hoje. ATENÇÃO: os valores dos campos do objeto podem ser alterados dentro do método chamado, porém, mudanças na

Quando uma alteração em uma variável afeta alguma outra, damos o nome de aliasing.

146



própria referência dentro do método não afetam a referência externa. Exemplo: public static void main( String args[] ){

Data hoje;

hoje = new Data();

funcao(hoje);

System.out.println( hoje.getMes() );

}

void funcao( Data umaData ){

umaData.setMes( 10 );

umaData = new Data();

umaData.setDia( 22 );

}

13.6 Vamos Treinar?

a) Criar uma classe chamada ‘Apresentador’ que possui um único método chamado apresentar(Estudante e), que recebe como argumento um Estudante e exibe seus dados, ou seja, chama o método exibir do objeto passado.

b) Codifique um programa para criar um apresentador e três estudantes (comum, monitor e estagiário) e passá-los ao apresentador para exibir seus dados. Observe o emprego do polimorfismo e da ligação dinâmica.

14. CLASSES ABSTRATAS

E INTERFACES


turbinar o

polimorfismo

aprendendo como

utilizar as classes

abstratas e interfaces


148



14.1 Classes Abstratas No projeto de uma hierarquia de classes, nem todas as classes são previstas de serem instanciadas. Algumas classes, na verdade, existem simplesmente para agrupar comportamentos similares. Observe o exemplo abaixo: Imagine se a gente criasse um objeto do tipo Animal. Que animal seria este? No mundo real temos animais desse tipo? Ou temos apenas cães, gatos, papagaios, entre outros? Você pode até dizer que cria um animal em casa, mas seu bichinho de estimação com certeza nascerá de alguma espécie, que pode ser Cachorro, Gato, Papagaio, ou outro qualquer, mas nunca da classe Animal. Essa é a ideia principal por trás do conceito de Classes Abstratas! Se, por outro lado, não existisse a classe abstrata (Animal),

as demais classes (Cachorro, Gato, Papagaio, etc.) continuariam a existir, mas não haveria nenhuma relação definida entre elas.

149



Para declarar uma classe qualquer como sendo abstrata, faça como o exemplo abaixo: public abstract class Animal{

...

}

A estratégia de usar classes abstratas é ter uma superclasse que dita o comportamento, enquanto as subclasses concretas têm a liberdade de prover a implementação que acharem relevantes. IMPORTANTE: onde se pode usar uma referência da superclasse Animal, mesmo ela sendo abstrata, os objetos

de quaisquer subclasses (Cachorro, Gato e Papagaio), podem ser utilizados.

14.2 Métodos Abstratos Métodos abstratos são aqueles que não têm implementação, somente o protótipo é fornecido. CUIDADO: Uma classe que possui um método abstrato não pode ser instanciada, pois ela é parcialmente definida. As subclasses de uma classe que possui métodos abstratos

Classes Abstratas são úteis no reuso, incrementando o mecanismo de polimorfismo.

150



devem implementar os métodos abstratos herdados da superclasse, caso contrário, também não poderão ser instanciadas. Um método abstrato usa o modificador abstract e possui apenas sua assinatura seguida de “;” . Exemplo: abstract public void comer();

abstract public int getNumeroDePneus();

NÃO ESQUECER:

Um classe abstrata não pode ser instanciada;

é especificada com a palavra-chave abstract ;

uma classe que possui algum método abstrato DEVE ser declarada abstrata;

a subclasse de uma classe abstrata DEVE prover a implementação dos métodos abstratos herdados, do contrário, também será uma classe abstrata;

uma classe pode ser declarada abstrata mesmo que não possua métodos abstratos. Isso evita que se instanciem objetos dessa classe;

Classes Abstratas podem herdar de classes abstratas e

não abstratas.

151



Exemplo de Classe Abstrata: abstract class Animal {

abstract public void comer();

abstract public void dormir();

abstract public void moverSe();

}

class Cachorro extends Animal {

public void comer() { ... }

public void dormir() { ... }

public void moverSe() { ... }

}

Alguns métodos NÃO podem ser declarados como sendo abstratos:

Construtores Estáticos Privados

Uma classe não pode ser abstrata e final ao mesmo

tempo.

152



14.3 Interfaces As classes Cachorro, Gato e Papagaio são, por essência, animais, por isso, podem ser agrupadas debaixo da

superclasse Animal. Imagine, agora, o que as classes Automovel, Televisao e MicroOndas têm em comum. Bem, a gente poderia pensar que elas possuem duas operações: ligar e desligar Mas é importante perceber que ainda que os nomes sejam os mesmos, as implementações serão completamente diferentes nas três classes! Quando temos um cenário como foi apresentado anteriormente torna-se adequado o uso das Interfaces. Interfaces, são, portanto, tipos especiais que declaram apenas nomes de operações que podem ser comuns a várias classes. É como se ela definisse um contrato, especificando somente os protótipos dos métodos (assinaturas), mas não suas implementações. No nosso exemplo, podemos ter uma interface chamada Operações que declara as operações ligar e desligar. Veja a seguir como é declarada uma interface em Java:

153



public interface Operacoes {

void ligar();

void desligar();

}

NÃO ESQUECER:

Os métodos de uma interface são por default: abstract e public. Embora não seja necessário declará-los como tal.

14.4 Implementando Interfaces As implementações das operações ficam a cargo das classes que irão implementar essa interface. Uma classe, ao implementar uma interface, pode seguir uma das duas situações descritas abaixo:

1) Deve prover uma implementação para cada uma das operações da interface.

2) Deve declarar a classe como abstrata. Exemplo: public class Automovel implements Operacoes {

public void ligar() {

girarChave();

acionarCombustao();

iniciarFuncionamentoDoMotor();

}

154



public void desligar() {

girarChaveAoContrario();

desativarFuncionamentoDoMotor();

}

public abstract class Televisao implements

Operacoes{

public void desligar() {

pressionarButao();

apagarImagem();

}

public class TelevisaoPlana extends Televisao{

public void ligar() {

pressionarButao();

capturarSinal();

jogarImagemNaTela(); }}

Uma classe pode implementar zero ou mais interfaces, listadas na cláusula implements;

Uma classe pode ao mesmo tempo estender de outra classe e implementar zero ou mais interfaces. Nesse caso, a cláusula extends vem antes da implements;

Uma interface pode estender de outras interfaces usando a cláusula extends;

Uma interface NÃO pode ser instanciada; Interfaces não possuem construtores.

155



14.5 Interfaces e Polimorfismo Uma referência de objeto de uma superclasse pode polimorficamente referenciar objetos do tipo da própria superclasse ou de qualquer subclasse. Como vimos, esta relação de herança em Java é linear, não permitindo herança múltipla de implementação (classes). TelevisaoPlana tvp =

new TelevisaoPlana();

Televisao tv = tvp;

As interfaces, assim como definições de classes, introduzem novos tipos que podem ser usados polimorficamente. Embora interfaces NÃO possam ser instanciadas, pode-se declarar variáveis do tipo definido por uma interface. Automovel auto =

new Automovel();

Operacoes op = auto;

156



Veja abaixo o quadro comparativo entre classes abstratas e interfaces:

14.6 Constantes em Interfaces Uma interface, além de operações, pode definir constantes. As constantes são acessíveis a qualquer cliente que a implemente ou estenda (só interfaces estendem de interfaces... não esqueça disto!) , seja classe ou interface. Todas as variáveis definidas em uma interface são por default (padrão):

public

static

final (constantes) Embora não seja necessário declará-las como tal.

157



Exemplo: interface Constantes {

double PI = 3.14;

String AREA_UNITS = " sq.cm.";

String LENGTH_UNITS = " cm.";

}

public class Client implements Constantes {


double radius = 1.5;

// (1) Acesso direto

System.out.println(“Area do circulo eh ” +

(PI*radius*radius) + AREA_UNITS);

// (2) Acesso prefixado com a interface

System.out.println(“Circunferencia do

circulo eh ” + (2*PI*radius) +

Constantes.LENGTH_UNITS); }

}

14.7 Vamos Treinar?

a) Codificar uma classe abstrata chamada Aparelho com dois métodos abstratos ligar() e desligar() e um método não abstrato exibir().

b) Criar duas subclasses Televisao e Microondas que herdam de Aparelhos e implementam os métodos ligar() e desligar() herdados da superclasse de acordo com suas especificidades, e redefinem o método exibir(), caso necessário.

c) Codificar um programa TesteAparelho que declara variáveis da superclasse Aparelho e usa-as com objetos

158



das subclasses Televisao e Microondas, ligando e desligando os objetos.

d) Codificar uma interface chamada Operacoes com os protótipos dos métodos ligar() e desligar().

e) Criar três classes Automovel, Televisao e Microondas

que implementam a interface Operacoes, provendo código para os métodos ligar() e desligar().

f) Codificar um programa TesteOperacoes que declara variáveis da interface Operacoes e usa-as com objetos das classes Automovel, Televisao e Microondas, ligando e desligando os objetos.

15. AGREGAÇÃO, LISTAS

E MAPEAMENTOS


conhecer como

podemos utilizar

agregação e como

criar coleções.


160



15.1 Agregação Além da herança, existe outro mecanismo fundamental de reuso de código, chamado agregação. Herança define uma relação do tipo “é um” (ou relação superclasse-subclasse), enquanto agregação define uma relação do tipo “tem um” (ou relação todo-parte). Exemplos:

Uma turma é composta de estudantes; Uma empresa é composta de departamentos; Um aparelho é composto de peças.

Sempre que tal situação acontecer, pode-se aplicar o conceito da agregação. Um objeto agregado é criado a partir de outros objetos constituintes, que são suas partes. Objetos em Java NÃO podem conter outros objetos. Eles podem ter apenas referências para outros objetos. Exemplo: public class Turma {

String nome;

int numEstudantes;


...

}

Da mesma forma que podemos ter arrays de tipos primitivos de dados, podemos ter arrays de objetos. Assim, arrays

161



podem representar grupo de dados do mesmo tipo primitivo, ou ainda, da mesma classe. Para declarar arrays de objetos e tipos primitivos basta fazer conforme é mostrado abaixo: double notas[];


Quando um array é criado, todos os seus elementos são automaticamente inicializados com os valores default (padrão) do tipo primitivo, ou com null, se forem objetos. Exemplo: double notas [] = new double[4];

Estudante estudantes[] = new Estudante[5];

Agora que o array de Estudante e de double foram criados, podemos manipular os seus elementos. Observe o código abaixo: notas[0] = 8.5;

estudantes[1] = new Estudante(“Maria”);

estudantes[1].setMatricula(120);

162



15.2 Coleções de Selos, Carros... Uma coleção (collection) permite que um grupo de objetos seja tratado como uma unidade, ou seja, objetos arbitrários podem ser armazenados, recuperados e manipulados como elementos de coleções. A hierarquia de classes e interfaces que trabalham com coleções é apresentada abaixo:

Em Java NÃO é possível redimensionar arrays. Caso seja necessário, use Listas!

163



As coleções estão disponíveis no pacote java.util e podem aparecer na forma de listas e conjuntos. As interfaces que representam coleções, listas e mapeamentos, estão descritas a seguir:

As estruturas de listas e mapeamentos mais utilizadas são:

ArrayList: arrays dinâmicos (o tamanho pode aumentar ou diminuir);

Vector: arrays dinâmicos sincronizados (thread-safe), ou seja, chamadas concorrentes a um objeto não comprometerão sua integridade;

HashMap: tabelas de pares chave-valor;

HashTable: tabelas de pares chave-valor

sincronizadas (thread-safe), ou seja, chamadas concorrentes a um objeto não comprometerão sua integridade.

164



15.3 Listas Listas são coleções que mantêm seus elementos em ordem (também chamado de sequência), e permitem elementos duplicados. Em uma lista não vazia, o primeiro elemento tem índice 0 e o último size()-1 (lembra de Strings, arrays? Sempre começando pelo índice zero!). Uma operação sob um índice que não existe gera uma exceção: IndexOutOfBoundsException (você vai amar o capítulo de exceções). Diferente dos arrays tradicionais de Java, uma Lista pode não ter um tipo determinado, ou seja, o primeiro elemento pode ser de um tipo diferente do segundo elemento. Porém, todos os elementos DEVEM ser objetos – tipos primitivos não são permitidos em listas! Exemplo: // declarando e criando a lista

ArrayList lista = new ArrayList();

// adicionando elementos na lista

lista.add(new Object());

lista.add(new Animal(“pato”));

lista.add(new Estudante(“Zezinho”));

lista.add(new Professor(“Marcos”));

lista.add(new Integer(“10”));

165



Veja a relação dos principais métodos disponíveis para listas:

int size(): retorna o tamanho da lista.

boolean isEmpty(): retorna true se a lista estiver vazia.

boolean add(Object element): adiciona um

objeto ao final da lista.

Object get(int index): retorna o elemento no índice especificado.

Object set(int index, Object element):

substitui o elemento no índice especificado com o parâmetro passado.

boolean contains(Object element):

166



verifica se o objeto passado como parâmetro é membro da coleção.

int indexOf(Object o): retorna o índice da

primeira ocorrência do elemento especificado na lista, se o elemento existir, caso contrário retorna -1.

void clear(): remove todos os elementos da lista.

Object remove(int index): remove o

elemento no índice especificado, reduzindo o tamanho da lista.

Para percorrer um ArrayList faça como o código exemplo abaixo: ...

public void print( ArrayList a )

{

for( int i = 0; i < a.size(); i++ )

{

System.out.println( a.get(i) );

}

}

}

Também existe uma outra forma mais elegante de percorrer um ArrayList: utilizar o padrão de software iterator!

Em Java existe uma interface chamada ListIterator. Ela é um iterator customizado (personalizado) para listas. Com a utilização do ListIterator, facilmente podemos percorrer listas em ambas as direções.

167



Exemplo: import java.util.*;

public class TesteArrayList3 {


List myList = new ArrayList();

myList.add(“1”);



ListIterator it = myList.listIterator();

while (it.hasNext()) {

System.out.println(it.next());

}

}

}

15.4 Listas Genéricas O método get(int index) do ArrayList retorna um

Object, portanto, pode ser necessário realizar conversões (casting) se o tipo destino for diferente de Object. Veja o código abaixo: public class TesteArrayList4 {

public void print( ArrayList al )

{

for( int i = 0; i < al.size(); i++ )

{

Estudante e = (Estudante)al.get(i);

e.exibir();

}

}}

A versão 1.5 do Java introduziu o conceito de listas de tipos específicos. Assim, o casting anterior não é mais necessário.

168



Para fazer uso desta maravilha do Java 5 use parênteses angulares ( <Tipo>) para definir o tipo de sua lista. Exemplo: public class TesteArrayList {

public void static main( String args [] ) {

ArrayList<Integer> li = new

ArrayList<Integer>();

li.add( new Integer(1) );

li.add( 2 );

for (int i=0; i < li.size(); i++) {

int n = li.get(i);

System.out.println( n );

}

} }

15.5 Mapeamentos Um Map (mapeamento) define mapeamentos de chaves para valores. Ele não permite chaves duplicadas, ou seja, as chaves são únicas e cada chave mapeia no máximo um valor. Em Java o HashMap é um dos mapeamentos mais utilizados. Exemplo: import java.util.*;

public class TesteHashMap {

public static void main( String args[] )

{

HashMap hm = new HashMap();

Estudante e = new Estudante( “Maria” );

EstudanteMonitor em =

new EstudanteMonitor( “João” );

hm.put( “A”, e );

169



hm.put( “B”, em );

hm.put( “C”, new Object());

hm.put( “D”, new Integer(“12”);

...

Perceba que tanto a chave como o valor devem ser objetos (Object).

Veja a relação dos principais métodos disponíveis para mapeamentos:

int size(): retorna o tamanho do mapeamentos.

boolean isEmpty(): retorna true se o mapeamento estiver vazio.

boolean put(Object key, Objetct value):

insere um mapeamento, isto é, um par “key, value”, também chamado de entrada.

170



Object get(Object key): retorna o valor para

o qual a chave (key) é mapeada ou null se nenhum mapeamento for encontrado.

Object remove(Object key): remove um objeto do mapeamento.

boolean containsKey(Object o): verifica se

a chave existe.

boolean containsValue(Object o): verifica se o valor existe.

void clear(): remove todos os elementos do

mapeamento. Para resgatar um objeto de um HashMap faça como o código exemplo abaixo: ...

// Buscando o estudante “1”

Estudante e1 = (Estudante)hm.get( “1” );

// Buscando o estudante “2”

EstudanteMonitor e2 =

(EstudanteMonitor)hm.get( “2” );

e1.exibir();

e2.exibir();

}

}

15.6 Mapeamentos Genéricos A versão 1.5 do Java também possui HashMaps de tipos

171



específicos. Veja o exemplo: public class TesteArrayList {

public void static main( String args [] ) {

HashMap<Integer, String> hm =

new HashMap<Integer, String>();

hm.put( 2, "Maria" );

hm.put( 7, "Pedro" );

hm.put( 5, "Madalena" );

String s = hm.get(7);

System.out.println( s );

}

}

NÃO ESQUECER:

Se você precisa acessar a lista sequencialmente, use um ArrayList.

Se você precisa acessar a lista aleatoriamente,

utilizando uma chave de busca, use HashMap.

15.7 Vamos Treinar?

a) Implementar uma classe Turma com as seguintes características: • Nome da turma; • Um array de estudantes de tamanho 10; • Um inteiro numEstundates para contar os estudantes matriculados na turma;

172



Inclua os seguintes métodos: • void matricular (Estudante e) – inclui estudante na turma; • void listar – mostra os dados de todos os estudantes da turma; • Estudante pesquisar (int matricula) – procura no array o estudante de matrícula igual ao parâmetro passado e o retorna; • void trancar (int matricula) – exclui estudante da turma; • void trancar (Estudante e) – exclui estudante da turma

b) Implementar um programa TesteTurma com as seguintes funcionalidades: • cria três estudantes diferentes (estudante, tutor e estagiário); • matricula os três estudantes; • lista os três estudantes; • pesquisar um dos estudantes e exibir seus dados; • excluir estudantes usando as duas maneiras diferentes.

c) Crie uma classe TurmaArrayList para funcionar com estrutura de dados redimensionável dinâmicamente (ArrayList, por exemplo) ao invés de array. É necessário modificar todos os métodos.

d) Escrever uma classe TesteHashMap que cria um map

173



de tipos específicos que tem como chaves números inteiros (Integer) representando as matrículas dos estudantes, e como valor os respectivos objetos da classe Estudante.

Crie três instâncias de estudante e os inclua no map. Depois, consulte o map utilizando a matrícula de algum estudante, exibindo os dados do estudante consultado.

16. NÃO FUI EU...


aprender como

dominar as possíveis

exceções que podem

ocorrer em um

programa.


175



16.1 Introdução Na execução de um programa, várias situações são passíveis de gerar erros. As operações podem gerar diferentes tipos de erros devido a: – Ambiente de execução • Ex: Acesso a arquivo; acesso à rede; falta de memória; entre outros. – Erros de programação • Ex: Dividir por zero; acessar um array fora dos limites de seu tamanho; entre outros. – Condições de negócio do programa • Ex: Retirar dinheiro de uma conta sem saldo; diminuir o salário de um funcionário; atribuir uma nota inválida a um aluno; entre outros. Na maioria das linguagens de programação, o tratamento de erros é feito geralmente através de testes condicionais, usando if por exemplo, com auxílio de variáveis booleanas. Vamos relembrar o tratamento de situações onde poderiam ocorrer erros durante a atribuição da nota de um estudante. void atribuirNota(int numProva, double nota) {

if ( nota >= 0 && nota <= 10.0 )

{

notas[numProva-1] = nota;

}

}

176



Se tentarmos atribuir uma nota inválida a uma prova, a atribuição não será realizada. Caso não se consiga efetuar a atribuição, como o método que chamou atribuirNota ficará sabendo da não realização da operação? void processarNota(e, numProva, nota)

{

e.atribuirNota(numProva, nota);

}

Vamos retornar, então, um valor booleano para indicar o sucesso ou não da operação. boolean atribuirNota(int numProva, double

nota){

if ( nota >= 0 && nota <= 10.0 ) {


return true;

} else return false;

}

Agora sim, com a nova versão do nosso método processarNota, podemos tratar esse valor booleano. void processarNota(e, numProva, nota)

{

if ( !e.atribuirNota(numProva, nota) ) {

System.out.println(“Nota Invalida!”);

}

PENSE RÁPIDO: e se o método processarNota não tratar o erro? O que pode acontecer?

177



16.2 Exceções em Java Java provê um mecanismo diferenciado, chamado de Exceções (Exceptions), que estrutura o tratamento de erros e garante robustez aos sistemas. Uma exceção é um sinal que indica a ocorrência de alguma condição excepcional. O compilador Java obriga o usuário da classe a tratar os possíveis erros que um método pode gerar (linguagem fortemente tipada). As exceções possui um cenário típico: tente fazer algo

faça alguma coisa 1;



capture se ocorrer uma exceção tipo 1:

faça um tratamento especial para exceção do

tipo 1;

capture se ocorrer uma exceção tipo 2:

faça um tratamento especial para exceção do

tipo 2;

...

finalmente:

faça algo final (sempre);

A primeira coisa a fazer para se criar uma exceção é definir uma classe que representa a exceção. Toda nova exceção deve herdar da classe Exception. public class NotaInvalidaException

extends Exception

{ }

178



Há um padrão para nomes de Exceções, onde os eles terminam sempre com a palavra “Exception”. A classe Exception representa as exceções que podem ser disparadas, capturadas e tratados pelos programas. Cada exceção específica é subclasse de Exception e contém informações sobre o problema ocorrido. Os principais métodos para exceções:

Exception(): construtor que cria uma exceção.

Exception(String msg): construtor que cria

uma exceção com a mensagem de erro ‘msg’.

String getMessage(): retorna a mensagem específica daquela exceção.

void printStackTrace(): imprime a pilha de

execução no momento em que ocorreu o erro. OBSERVAÇÃO: antes de criar uma nova classe de exceção é interessante verificar se já existe alguma igual ou similar à desejada na API Java. Observe o código abaixo: class TesteExcecao {

public static void main(String argv[]) {

int d1,d2;

d1 = 10;

d2 = 0;

System.out.println(d1/d2);

}

}

179



O código acima vai resultar no seguinte erro quando executado: Exception in thread "main"

java.lang.ArithmeticException: / by zero at

TesteExececao.main(TesteExececao.java:6)

Press any key to continue... Isso ocorre porque se tentou dividir um inteiro por zero, indicada na mensagem do sistema por ArithmeticException, uma exceção que já está disponível na linguagem Java, assim com uma série de outras exceções. Vamos conhecer a seguir um pouco da hierarquia de Exceções do Java:

180



16.3 A Cláusula throws Agora que já criamos a nossa exceção, devemos definir os métodos que podem dispará-la. Isto é feito usando a cláusula throws (dispara). Exemplo: void atribuirNota(int numProva, double nota)

throws NotaInvalidaException {

if ( nota >= 0 && nota <= 10.0 ) {


}

}

Assim, dizemos que o método atribuirNota pode disparar uma exceção, possibilidade essa que deve ser convenientemente tratada pelos métodos que chamam o método atribuirNota.

16.4 A Sentença throw Agora o próximo passo é disparar a exceção dentro do método atribuirNota, quando ela ocorrer. Isto é feito usando a sentença throw (disparar). Exemplo: void atribuirNota(int numProva, double nota)

throws NotaInvalidaException {

if ( nota >= 0 && nota <= 10.0 ) {


} else

throw new NotaInvalidaException(); }

181



Como exceções são classes, antes de disparar uma exceção, temos que criar o objeto. Eis o porquê da construção abaixo: throw new NotaInvalidaException();

Fazendo assim, todo método que chama o método

atribuirNota deve tratar a possibilidade de ser gerada uma exceção. Perceba a diferença:

throws: indica que o método pode disparar uma exceção;

throw: dispara a exceção.

16.5 O bloco try-catch Depois que criamos a nossa classe de exceção, sinalizamos os métodos que a podem disparar, e inserimos o momento em que o disparo acontece, temos agora que fazer a captura e o

tratamento com try - catch. Exemplo: void processarNota() {

try

{

Estudante e = new Estudante();

e.atribuirNota(1, 11.0);

}

catch (NotaInvalidaException e)

{

System.out.println(“Erro na atribuição de

182



nota!”);

}

}

O bloco try-catch possui ainda uma terceira parte opcional chamada finally. O bloco finally, quando existe, é sempre executado, ocorrendo ou não uma exceção. O bloco finally é geralmente usado para fechar conexões com banco de dados, resetar variáveis, enfim, ações que devem ser tomadas caso erros ocorram ou não. Exemplo: try {



} catch (NotaInvalidaException e) {

System.out.println(“Erro na atribuição

nota!”);

} finally {

System.out.println(“Sempre passa aqui!”);

}

Todas as exceções disparadas por um método têm que ser listadas na assinatura do método. Exemplo: void atribuirNota(int numProva, double nota)

throws NotaInvalidaException,

ProvaInvalidaException

{

if ( nota < 0.0 || nota > 10.0 )

throw new NotaInvalidaException();

else if ( numProva < 1 || numProva > 4 )

throw new ProvaInvalidaException();

183



else


}

16.6 Adicionando Informações nas

Exceções A gente viu que novos tipos de exceções podem ser criados estendendo-se a classe Exception ou suas subclasses. As novas exceções podem disponibilizar informações extras sobre o erro ocorrido para ajudar na solução. Lembre-se que exceções são classes, então podemos definir variáveis e métodos, permitindo assim prover mais informações sobre as causas do problema ocorrido e sua efetiva solução.

Java permite vários blocos catch, cada um tratando uma exceção específica, ou nenhum. No caso de tratar várias exceções usando vários blocos catch, as exceções mais específicas devem vir antes das mais genéricas, pois a primeira exceção que o sistema conseguir casar tem seu bloco catch executado.

184



Exemplo: public class NotaInvalidaException extends

Exception

{

private double notaInvalida;

public double getNotaInvalida() {

return notaInvalida;

}

public NotaInvalidaException( double nota ){

super(“Nota Invalida”);

notaInvalida = nota;

}

}

Agora o método que vai tratar a exceção pode fazer chamada aos métodos disponibilizados pela exceção como se estivesse usando um objeto comum:

void processarNota() {

try {



}

catch (NotaInvalidaException e) {

System.out.println( e.getMessage() );

System.out.println(“A nota inválida é

”+e.getNotaInvalida()); } }

16.7 Vamos Treinar?

a) Implementar a classe de exceção NotaInvalidaException armazenando também o número da prova.

185



b) Alterar o método atribuirNota para disparar uma exceção caso seja tentado atribuir uma nota inválida.

c) Alterar o programa TesteEstudante para criar um

estudante e tentar atribuir notas a ele, oferecendo um código seguro através do bloco try-catch-

finally.

d) Criar uma nova exceção chamada ProvaInexistenteException, que valida se o número da prova que se deseja atribuir está dentro dos limites do array de notas.

e) Alterar o método atribuirNota para também disparar uma exceção caso seja tentado atribuir uma nota a uma prova inexistente.

f) Alterar o programa TesteEstudate para proteger o

código contra erros de prova inexistente.

g) Implementar para a classe Turma o tratamento de erro das seguintes situações:

• Criar uma turma, mas o nome veio nulo; • Matricular o estudante, mas o estudante veio nulo; • Pesquisar estudante, mas não existe estudante com a matrícula passada como argumento; • Trancar estudante, mas não existe estudante com a matrícula igual àquela passada como argumento; • Trancar estudante, mas não existe estudante igual àquele passado como argumento.

186



h) Identifique outras situações na classe Estudante, suas subclasses e na classe Turma onde se poderia usar exceções.

17. MULTITAREFA COM

THREADS

Vivemos em um mundo em que

é preciso fazer muitas coisas ao

mesmo tempo. Neste capítulo

veremos como trabalhar com

multitarefa em nossos

programas.


188



17.1 Introdução Grande parte dos sistemas operacionais modernos suporta multitarefa. Um Sistema Multitarefa permite que várias atividades ocorram concorrentemente num computador, como por exemplo, ouvir música enquanto navega na Internet. Há dois tipos de Multitarefa:

Multitarefa Baseada em Processo: cada programa é um processo.

Multitarefa Baseada em Thread: cada programa

possui várias linhas de execução. A Multitarefa evita o desperdício de tempo da CPU, utilizando o tempo de forma racional. Quando temos vários processos concorrendo para o uso do processador, cada processo usará um pouco do tempo do processador e depois deverá cede a vez para outro processo da fila.

17.2 Threads

Um mesmo programa pode ser executado em múltiplas linhas de execução. Cada linha de execução dentro de um programa é chamado de thread e é executada separadamente.

189



Pense em threads como o suporte a multitarefa dentro de um mesmo programa. Por exemplo: no MS Word existe um thread que verifica a ortografia e permite que você continue digitando o texto (outro thread). Em tempo de execução, os threads de um programa usam o mesmo espaço de memória e, portanto, compartilham os dados e código. Java suporta multitarefa baseada em Thread e provê facilidades de alto nível para programação usando multitarefa.

Threads em Java tornam o ambiente de execução assíncrono, permitindo diferentes tarefas serem executadas concorrentemente. Existem duas maneiras de criar um thread em Java:

1) estender a classe Thread e escreva o método run();

2) implementar a interface Runnable e escreva o

método run(). A classe que estende Thread ou implementa Runnable, deve ter um método run() que implementará o comportamento da nova thread. O código no método run() define um caminho de execução independente que termina quando o método finaliza.

190



17.3 Estendendo de Thread A nova classe, que descende de Thread, deve sobrescrever o método run() para definir o código que será executado pela thread. Esta subclasse de Thread pode chamar os

construtores de Thread explicitamente em seus construtores para inicializar a thread. O método start() herdado de Thread é chamado sobre o objeto da nova subclasse para tornar a thread candidata a ser executada. Exemplo: public class HelloWorldThread extends Thread {

public void run() {

while ( true ){

System.out.println("Hello World of threads!");

} }

public static void main( String args[] ) {

HelloWorldThread t = new HelloWorldThread();

t.start();

while ( true ){

System.out.println( "Thread 1" );

}

}}

A classe Thread apresenta vários construtores, dentre eles: Thread(), Thread(Runnable runner) e Thread(Runnable runner, String

nomeDaThread).

191



O nome da thread pode ser obtido através do método getName().

17.4 Implementando Runnable Agora vamos ver o procedimento para criar um thread implementando a interface Runnable: Assim como foi quando estendemos a classe Thread, a nova

classe também deve prover um método run() que será executado pela thread.

Um objeto da classe Thread deve ser criado. Um objeto da nova classe que implementou Runnable então deve ser passado como argumento para um construtor da classe Thread. O método start() é chamado sobre o objeto da classe Thread criado no passo acima. Isso ativa a nova thread. O

método start() retorna o controle para thread principal imediatamente após a nova thread ter sido disparada. Exemplo: public class HelloWorldRunnable implements

Runnable {

public void run(){

while ( true ){

System.out.println("Hello World of threads!");

}}

192



public static void main( String args[] ) {

HelloWorldRunnable runner = new

HelloWorldRunnable();

Thread t = new Thread( runner );

t.start();

while ( true ){

System.out.println( "Thread 1" );

}

}}

Vantagens de implementar Runnable ao invés de Estender Thread:

Pensando em orientação a objetos, provavelmente é mais interessante implementar Runnable do que

estender Thread. Estender de Thread significa que a subclasse não pode estender de outra classe, enquanto implementando Runnable não perde essa possibilidade de extensão.

Uma classe pode ter somente a intenção de ser executável como uma thread, e portanto herdar todas as características da classe Thread seria excessivo.

17.5 Estados de Thread Um thread ao longo de sua vida no mundo digital pode passar por diversos estados, como pode ser observado na figura a seguir:

193



Pronto para Executar: um thread não vai diretamente para o estado de execução após ser criada (start()) ou após deixar algum dos estados de “não execução”. Ele primeiro vai para o estado de “pronto para executar”, significando que agora é candidato a ser executado pelo sistema. Tudo vai depender do escalonador. Uma chamada ao método estático yield() da classe Thread suspende a execução do thread corrente, levando-o ao estado de “pronto para executar”, e liberando o processador para outros threads. Uma vez no estado de “pronto para executar”, ele aguardará sua vez para fazer uso da CPU novamente.

Executando: o processador está realmente executando o thread. Lembre-se que é o escalonador de threads quem decide qual thread entrará nesse estado.

194



Morto: um thread chega ao estado de “morto” ao completar sua execução.

Não Execução: um thread pode sair do estado de

“execução” e entrar em um dos estados de “não execução”, dependendo da transição. O thread vai permanecer nesse estado até alguma transição especial movê-la para o estado de “pronto para executar”.

Não Execução – Esperando: estando em execução, um thread pode chamar o método wait() definido na classe Object para por a si mesmo em estado de espera. Esse thread deve ser notificado (notify()) por outro thread para mover-se para o estado de “pronto para executar”.

Não Execução – Dormindo: uma chamada ao método

estático sleep(tempo ms) da classe Thread leva o thread corrente ao estado de dormência. Ele irá acordar após transcorrido o tempo determinado de dormência, e migrará para o estado de “pronto para

195



executar”.

Não Execução – Bloqueado: um thread em execução, ao chamar uma operação requisitando algum recurso bloqueado, mover-se-á para o estado de “bloqueado”. Um thread também bloqueia se falhar ao tentar adquirir um monitor de um objeto.

17.6 Alterando a Prioridade Threads podem ter prioridades que são usadas pelo escalonador para determinar como elas serão tratadas. O thread com maior prioridade geralmente é colocada para rodar antes dos demais. Prioridades são valores inteiros que podem assumir:

1: menor prioridade, indicada pela constante Thread.MIN_PRIORITY;

10: maior prioridade, indicada pela constante Thread.MAX_PRIORITY;

196



5: se nenhuma prioridade é indicada, o thread assume o valor default definido pela constante

Thread.NORM_PRIORITY;

qualquer outro valor entre Thread.MIN_PRIORITY e Thread.MAX_PRIORITY.

Para trabalhar com a prioridade de um thread, devem-se usar os seguintes métodos:

setPriority() : altera a prioridade da thread;

getPriority() : lê a prioridade da thread.

17.7 Sincronização Threads compartilham o mesmo espaço de memória, ou seja, podem compartilhar recursos. Quando utilizamos múltiplos threads em um aplicativo podem ocorrer problemas: se dois threads acessam a mesma variável ou o mesmo objeto ao mesmo tempo, e tentam mudar seu valor, o que fazer? Há situações onde é desejável ter

Em Java um thread herda a prioridade de seu pai!

197



somente um thread acessando um recurso compartilhado. O nome disto chama-se sincronização. Veja o exemplo de código abaixo e tente identificar algum problema: class Banco {

public void transferir(Conta ctaOrigem,

Conta ctaDestino, double valor ) {

if (ctaOrigem.getSaldo() < valor )

return;

ctaOrigem.debitar( valor );

ctaDestino.creditar( valor );

}

...

}

O problema do código acima é causado pela não atomicidade do método transferir. A execução do método pode ser parada pela metade para que outro thread assuma o controle. Temos então que criar uma espécie de semáforo para obter acesso ininterrupto (exclusivo) ao método.

Em Java, isso é feito através da instrução synchronized. Existem duas maneiras nas quais um código pode ser sincronizado:

Métodos sincronizados: usa o modificador synchronized e somente um thread executará o método que foi definido sincronizado de cada vez.

198



Exemplo: class Banco {

public synchronized void transferir(

Conta ctaOrigem, Conta ctaDestino,

double valor ) {


return;



}

...

}

Blocos sincronizados: também utiliza a instrução

synchronized mas agora somente um thread executará o bloco que foi definido sincronizado por vez. Exemplo: class Banco {

public void transferir(

Conta ctaOrigem, Conta ctaDestino,

double valor ) {

synchronized ( this ) {


return;



}

}...

199



17.8 Cuidado com os Deadlocks! Os métodos ou blocos sincronizados podem causar uma situação de impasse conhecida como deadlock. Um deadlock ocorre quando um thread bloqueia o acesso a um objeto e fica esperando por outro objeto, que por sua vez está bloqueado por outro thread que está esperando o desbloqueio do objeto anterior. Para evitar deadlocks, algumas dicas podem ser seguidas:

1) Mantenha bloqueios o menor tempo possível;

2) Considere o uso de blocos syncronized ao invés de métodos syncronized;

3) Tente escrever código que não precise de mais de um bloqueio ao mesmo tempo;

4) Crie e use um grande lock ao invés de pequenos locks. Use essa técnica de forma que você tenha exclusões mútuas.

200



17.9 Vamos Treinar?

a) Escreva uma aplicação que imprima os números pares de 0 a 1000 em um thread e os ímpares em outro.

b) Crie uma aplicação que dado um número, calcule o fatorial em um thread e a série de fibonacci em outro thread, imprimindo o resultado de ambos no console.

BIBLIOGRAFIA

DEITEL, H. M.; DEITEL, P.J. - Java Como Programar. São Paulo: 8ª. Edição. Editora Pearson- Prentice Hall, 2005.

SIERRA, K., BATES, B. Use a Cabeça! Java. Rio de

Janeiro: Alta Books, 2006.

___________________. SCJP: Certificação Sun para programador Java 5. Rio de Janeiro: Alta Books, 2007.

ninja academy - curso java básico

Documents