Informatica Programacao Orientada A Objeto1 PDF

Escola Estadual de
Educao Profissional - EEEP

Ensino Mdio Integrado Educao Profissional
Curso Tcnico em Informtica
Programao
Orientada a Objeto I
Governador
Cid Ferreira Gomes
Vice Governador
Francisco Jos Pinheiro
Secretria da Educao
Maria Izolda Cela de Arruda Coelho
Secretrio Adjunto
Maurcio Holanda Maia
Secretrio Executivo
Antnio Idilvan de Lima Alencar
Assessora Institucional do Gabinete da Seduc

Cristiane Carvalho Holanda
Coordenadora de Desenvolvimento da Escola

Maria da Conceio vila de Misquita Vins
Coordenadora da Educao Profissional SEDUC

Thereza Maria de Castro Paes Barreto
Escola Estadual de Educao Profissional [EEEP] Ensino Mdio Integrado Educao Profissional
ndice
Apresentao...............................................................................................................................6
Lio 1.........................................................................................................................................9
1. Objetivos.................................................................................................................................9
2. Explorando o Java...................................................................................................................9
2.1. Um pouco da histria...........................................................................................................9
2.2. O que uma tecnologia JAVA?............................................................................................9
2.2.1. Uma linguagem de programao......................................................................................9
2.2.2. Um ambiente de desenvolvimento..................................................................................10
2.2.3. Um ambiente de aplicao..............................................................................................10
2.2.4. Um ambiente de distribuio..........................................................................................10
2.3. Algumas Caractersticas do JAVA......................................................................................10
2.3.1. Mquina Virtual Java......................................................................................................10
2.3.2. Garbage Collection..........................................................................................................11
2.3.3. Segurana de cdigo.......................................................................................................11
2.4. Fases do Java programa.....................................................................................................11
3. Primeiro Programa Java........................................................................................................12
3.1. Utilizando a Console e um editor de texto.........................................................................12
3.2. Erros...................................................................................................................................15
3.2.1 Erros de Sintaxe...............................................................................................................15
3.2.2 Erros em tempo de execuo (Erros de run-time)............................................................16
4. Usando NetBeans..................................................................................................................16
5. Exerccios..............................................................................................................................24
5.1 Melhorando o Hello World!................................................................................................24
5.2. A rvore.............................................................................................................................24
Lio 2.......................................................................................................................................26
1. Objetivos...............................................................................................................................26
2. Entendendo meu primeiro programa em Java.......................................................................26
3. Comentrios em Java............................................................................................................27
3.1. Comentrio de linha...........................................................................................................27
3.2. Comentrio de bloco..........................................................................................................28
3.3. Comentrio estilo Javadoc.................................................................................................28
4. Instrues e Bloco em Java...................................................................................................28
5. Identificadores em Java.........................................................................................................30
6. Palavras-chave em Java........................................................................................................30
7. Tipos de Dados em Java........................................................................................................31
7.1. Boolean..............................................................................................................................31
7.2. Character............................................................................................................................31
7.3. Integer................................................................................................................................31
7.4. Float-Point..........................................................................................................................31
8. Tipos de Dados Primitivos....................................................................................................32
8.1. Lgico................................................................................................................................32
8.2. Inteiro.................................................................................................................................32
8.3. Inteiro Longo......................................................................................................................33
8.4. Nmero Fracionrio...........................................................................................................33
9. Variveis................................................................................................................................34
9.1. Declarando e inicializando Variveis.................................................................................34
9.1. Declarando e inicializando Variveis.................................................................................34
9.2. Exibindo o valor de uma Varivel......................................................................................35
Informtica - Programao Orientada a Objetos I 1
9.3. System.out.println( ) e System.out.print( ).........................................................................35

9.4. Referncia de Variveis e Valor das Variveis...................................................................36
10. Operadores..........................................................................................................................36
11. Operadores de Incremento e Decremento...........................................................................39
12. Operadores Relacionais.......................................................................................................40
13. Operadores Lgicos............................................................................................................42
13.1. && (e lgico) e & (e binrio)..........................................................................................42
13.2. || ( ou lgico) e | ( ou binrio)...........................................................................................43
13.3. ^ (ou exclusivo binrio)...................................................................................................45
13.4. ! (negao)........................................................................................................................46
14. Operador Condicional ( ?: )................................................................................................46
15. Precedncia de Operadores.................................................................................................47
16. Exerccios............................................................................................................................48
16.1. Declarar e mostrar variveis............................................................................................49
16.2. Obter a mdia entre trs nmeros....................................................................................49
16.3. Exibir o maior valor.........................................................................................................49
16.4. Precedncia de operadores...............................................................................................49
Lio 3.......................................................................................................................................51
1. Objetivos...............................................................................................................................51
2. BufferedReader para capturar dados.....................................................................................51
3. Classe Scanner para capturar dados......................................................................................53
4. Utilizando a JOptionPane para receber dados.......................................................................54
5. Exerccios..............................................................................................................................55
5.1. As 3 palavras (verso Console)..........................................................................................55
5.2. As 3 palavras (verso Interface Grfica)............................................................................55
1. Objetivos...............................................................................................................................57
2. Estruturas de controle de deciso..........................................................................................57
2.1. Declarao if......................................................................................................................57
2.2. Declarao if-else...............................................................................................................58
2.3. Declarao if-else-if...........................................................................................................60
2.4. Erros comuns na utilizao da declarao if......................................................................61
2.6. Exemplo para switch..........................................................................................................64
3. Estruturas de controle de repetio.......................................................................................64
3.1. Declarao while................................................................................................................64
3.2. Declarao do-while..........................................................................................................66
3.3. Declarao for....................................................................................................................67
4. Declaraes de Interrupo...................................................................................................68
4.1. Declarao break................................................................................................................69
4.1.1. Declarao unlabeled break............................................................................................69
4.1.2. Declarao labeled break................................................................................................69
4.2. Declarao continue...........................................................................................................70
4.2.1. Declarao unlabeled continue.......................................................................................70
4.2.2. Declarao labeled continue...........................................................................................70
4.3. Declarao return...............................................................................................................71
5. Exerccios..............................................................................................................................71
5.1. Notas..................................................................................................................................71
5.2. Nmero por Extenso..........................................................................................................72
5.3. Cem vezes..........................................................................................................................72
5.4. Potncias............................................................................................................................72
Lio 5.......................................................................................................................................73
1. Objetivos...............................................................................................................................73
2. Introduo a Array................................................................................................................73
3. Declarando Array..................................................................................................................73
4. Acessando um elemento do Array.........................................................................................74
5. Tamanho do Array.................................................................................................................76
6. Arrays Multidimensionais.....................................................................................................76
7. Exerccios..............................................................................................................................77
7.1. Dias da semana...................................................................................................................77
7.2. Maior nmero.....................................................................................................................77
7.3. Entradas de agenda telefnica............................................................................................77
Lio 6.......................................................................................................................................79
1. Objetivos...............................................................................................................................79
2. Argumentos de linha de comando.........................................................................................79
2. Argumentos de linha de comando.........................................................................................79
3. Argumentos de linha de comando no NetBeans...................................................................80
4. Exerccios..............................................................................................................................85
4.1. Argumentos de Exibio....................................................................................................85
4.2. Operaes aritmticas........................................................................................................85
Lio 7.......................................................................................................................................86
1. Objetivos...............................................................................................................................86
2. Introduo Programao Orientada a Objeto.....................................................................86
3. Classes e Objetos..................................................................................................................87
3.1. Diferenas entre Classes e Objetos....................................................................................87
3.2. Encapsulamento.................................................................................................................87
3.3. Atributos e Mtodos de Classe...........................................................................................88
3.4 Instncia de Classe..............................................................................................................88
4. Mtodos.................................................................................................................................89
4.1. O que so mtodos e porque usar mtodos?......................................................................89
4.2. Chamando Mtodos de Objeto e Enviando Argumentos...................................................89
4.3. Envio de Argumentos para Mtodos..................................................................................90
4.3.1. Envio por valor................................................................................................................90
4.3.2. Envio por referncia........................................................................................................91
4.4. Chamando mtodos estticos.............................................................................................92
4.5. Escopo de um atributo........................................................................................................93
5. Casting, Converso e Comparao de Objetos.....................................................................95
5.1. Casting de Tipos Primitivos...............................................................................................95
5.2. Casting de Objetos.............................................................................................................96
5.3. Convertendo Tipos Primitivos para Objetos e Vice-Versa.................................................97
5.4. Comparando Objetos..........................................................................................................98
5.5. Determinando a Classe de um Objeto..............................................................................100
6. Exerccios............................................................................................................................101
6.1. Definindo termos..............................................................................................................101
6.2. Java Scavenger Hunt........................................................................................................101
Lio 8.....................................................................................................................................103
1. Objetivos.............................................................................................................................103
2. Definindo nossas classes.....................................................................................................103
3. Declarando Atributos..........................................................................................................104
3.1. Atributos de Objeto..........................................................................................................105
3.2. Atributos de Classe ou Atributos Estticos......................................................................106
4. Declarando Mtodos...........................................................................................................106
4.1. Mtodos assessores..........................................................................................................107

4.2 Mtodos Modificadores....................................................................................................108
4.3. Mltiplos comandos return..............................................................................................108
4.4. Mtodos estticos.............................................................................................................109
4.5. Exemplo de Cdigo Fonte para a classe StudentRecord..................................................109
5. this.......................................................................................................................................111
6. Overloading de Mtodos.....................................................................................................111
7. Declarando Construtores.....................................................................................................113
7.1. Construtor Padro (default)..............................................................................................113
7.2. Overloading de Construtores............................................................................................113
7.3. Usando Construtores........................................................................................................114
7.4. Utilizando o this()............................................................................................................115
8. Pacotes.................................................................................................................................116
8.1. Importando Pacotes..........................................................................................................116
8.2. Criando pacotes................................................................................................................116
8.3. Definindo a varivel de ambiente CLASSPATH.............................................................117
9. Modificadores de Acesso....................................................................................................118
9.1. Acesso padro...................................................................................................................118
9.2. Acesso pblico.................................................................................................................118
9.3. Acesso protegido..............................................................................................................119
9.4. Acesso particular..............................................................................................................119
10. Exerccios..........................................................................................................................119
10.1. Registro de Agenda........................................................................................................119
10.2. Agenda...........................................................................................................................120
Lio 9.....................................................................................................................................121
1. Objetivos.............................................................................................................................121
2. Herana...............................................................................................................................121
2.1. Definindo Superclasses e Subclasses...............................................................................121
2.2. super.................................................................................................................................123
2.3. Override de Mtodos........................................................................................................124
2.4. Mtodos final e Classes final...........................................................................................125
4. Mtodos...............................................................................................................................125
3. Polimorfismo.......................................................................................................................125
4. Classes Abstratas.................................................................................................................127
5. Interfaces.............................................................................................................................129
5.1. Porque utilizar Interfaces?...............................................................................................129
5.2. Interface vs. Classe Abstrata............................................................................................129
5.3. Interface vs. Classe..........................................................................................................129
5.4. Criando Interfaces............................................................................................................130
5.5. Relacionamento de uma Interface para uma Classe.........................................................131
5.6. Herana entre Interfaces...................................................................................................132
6. Exerccios............................................................................................................................132
6.1. Estendendo StudentRecord..............................................................................................132
6.2. A classe abstrata Shape....................................................................................................132
Lio 10...................................................................................................................................133
1. Objetivos.............................................................................................................................133
2. O que so Excees (Exception)?.......................................................................................133
3. Tratando Excees..............................................................................................................133
4. Exerccios............................................................................................................................135
4.1. Capturando Excees 1....................................................................................................135
4.2. Capturando Excees 2....................................................................................................136

Apndice A..............................................................................................................................137
1. Objetivos.............................................................................................................................137
2. Instalando Java no Ubuntu Dapper.....................................................................................137
3. Instalando Java no Windows...............................................................................................138
4. Instalando NetBeans no Ubuntu Dapper.............................................................................139
5. Instalando NetBeans no Windows......................................................................................139

Apresentao
Autor
Florence Tiu Balagtas
Equipe
Joyce Avestro
Florence Balagtas
Rommel Feria
Reginald Hutcherson
Rebecca Ong
John Paul Petines
Sang Shin
Raghavan Srinivas
Matthew Thompson
Necessidades para os Exerccios
Sistemas Operacionais Suportados
NetBeans IDE 5.5 para os seguintes sistemas operacionais:
Microsoft Windows XP Profissional SP2 ou superior

Mac OS X 10.4.5 ou superior
Red Hat Fedora Core 3
Solaris 10 Operating System (SPARC e x86/x64 Platform Edition)
NetBeans Enterprise Pack, poder ser executado nas seguintes plataformas:
Microsoft Windows 2000 Profissional SP4

Solaris 8 OS (SPARC e x86/x64 Platform Edition) e Solaris 9 OS (SPARC e x86/x64 Pla-
tform Edition)
Vrias outras distribuies Linux
Configurao Mnima de Hardware
Nota: IDE NetBeans com resoluo de tela em 1024x768 pixel
Sistema Operacional Processador Memria HD Livre
Microsoft Windows 500 MHz Intel Pentium III

workstation ou equivalente
512 MB 850 MB
Linux 500 MHz Intel Pentium III
512 MB 450 MB
Solaris OS (SPARC) UltraSPARC II 450 MHz 512 MB 450 MB
Solaris OS (x86/x64
Platform Edition)
AMD Opteron 100 Srie 1.8 GHz 512 MB 450 MB
Mac OS X PowerPC G4 512 MB 450 MB
Configurao Recomendada de Hardware
Sistema Operacional Processador Memria HD Livre
Microsoft Windows 1.4 GHz Intel Pentium III

1 GB 1 GB
Linux 1.4 GHz Intel Pentium III
1 GB 850 MB
Solaris OS (SPARC) UltraSPARC IIIi 1 GHz 1 GB 850 MB
Solaris OS (x86/x64
Platform Edition)
AMD Opteron 100 Series 1.8 GHz 1 GB 850 MB
Mac OS X PowerPC G5 1 GB 850 MB
Requerimentos de Software
NetBeans Enterprise Pack 5.5 executando sobre Java 2 Platform Standard Edition Development Kit 5.0 ou superior (JDK 5.0,
verso 1.5.0_01 ou superior), contemplando a Java Runtime Environment, ferramentas de desenvolvimento para compilar,
depurar, e executar aplicaes escritas em linguagem Java. Sun Java System Application Server Platform Edition 9.
Para Solaris, Windows, e Linux, os arquivos da JDK podem ser obtidos para sua plataforma em
http://java.sun.com/j2se/1.5.0/download.html
Para Mac OS X, Java 2 Plataform Standard Edition (J2SE) 5.0 Release 4, pode ser obtida diretamente da Apple's Developer
Connection, no endereo:
http://developer.apple.com/java ( necessrio registrar o download da JDK).
Para mais informaes:
http://www.netbeans.org/community/releases/55/relnotes.html
Colaboradores que auxiliaram no processo de traduo e reviso

Alexandre Mori Hugo Leonardo Malheiros Ferreira Mauro Regis de Sousa Lima
Alexis da Rocha Silva Ivan Nascimento Fonseca Namor de S e Silva
Aline Sabbatini da Silva Alves Jacqueline Susann Barbosa Nres Chaves Rebouas
Allan Wojcik da Silva Jader de Carvalho Belarmino Pedro Antonio Pereira Miranda
Andr Luiz Moreira Joo Aurlio Telles da Rocha Pedro Henrique Pereira de Andrade
Andro Mrcio Correa Louredo Joo Paulo Cirino Silva de Novais Renato Alves Flix
Antoniele de Assis Lima Joo Vianney Barrozo Costa Renato Barbosa da Silva
Antonio Jose R. Alves Ramos Jos Augusto Martins Nieviadonski Reyderson Magela dos Reis
Aurlio Soares Neto Jos Leonardo Borges de Melo Ricardo Ferreira Rodrigues
Bruno da Silva Bonfim Jos Ricardo Carneiro Ricardo Ulrich Bomfim
Bruno dos Santos Miranda Kleberth Bezerra G. dos Santos Robson de Oliveira Cunha
Bruno Ferreira Rodrigues Lafaiete de S Guimares Rodrigo Pereira Machado
Carlos Alberto Vitorino de Almeida Leandro Silva de Morais Rodrigo Rosa Miranda Corra
Carlos Alexandre de Sene Leonardo Leopoldo do Nascimento Rodrigo Vaez
Carlos Andr Noronha de Sousa Leonardo Pereira dos Santos Ronie Dotzlaw
Carlos Eduardo Veras Neves Leonardo Rangel de Melo Filardi Rosely Moreira de Jesus
Cleber Ferreira de Sousa Lucas Mauricio Castro e Martins Seire Pareja
Cleyton Artur Soares Urani Luciana Rocha de Oliveira Sergio Pomerancblum
Cristiano Borges Ferreira Lus Carlos Andr Silvio Sznifer
Cristiano de Siqueira Pires Lus Octvio Jorge V. Lima Suzana da Costa Oliveira
Derlon Vandri Aliendres Luiz Fernandes de Oliveira Junior Tsio Vasconcelos da Silveira
Fabiano Eduardo de Oliveira Luiz Victor de Andrade Lima Thiago Magela Rodrigues Dias
Fbio Bombonato Manoel Cotts de Queiroz Tiago Gimenez Ribeiro
Fernando Antonio Mota Trinta Marcello Sandi Pinheiro Vanderlei Carvalho Rodrigues Pinto
Flvio Alves Gomes Marcelo Ortolan Pazzetto Vanessa dos Santos Almeida
Francisco das Chagas Marco Aurlio Martins Bessa Vast Mendes da Silva Rocha
Francisco Marcio da Silva Marcos Vinicius de Toledo Wagner Eliezer Roncoletta
Gilson Moreno Costa Maria Carolina Ferreira da Silva Nolyanne Peixoto Brasil Vieira
Givailson de Souza Neves Massimiliano Giroldi Paulo Afonso Corra
Gustavo Henrique Castellano Mauricio Azevedo Gamarra Paulo Jos Lemos Costa
Hebert Julio Gonalves de Paula Mauricio da Silva Marinho Paulo Oliveira Sampaio Reis
Heraldo Conceio Domingues Mauro Cardoso Mortoni
Auxiliadores especiais
Reviso Geral do texto para os seguintes Pases:
Brasil Tiago Flach
Guin Bissau Alfredo C, Bunene Sisse e Buon Olossato Quebi ONG Asas de Socorro
Coordenao do DFJUG
Daniel de Oliveira JU GLeader responsvel pelos acordos de parcerias
Luci Campos - Idealizadora do DFJUG responsvel pelo apoio social
Fernando Anselmo - Coordenador responsvel pelo processo de traduo e reviso,
disponibilizao dos materiais e insero de novos mdulos
Regina Mariani - Coordenadora responsvel pela parte jurdica
Rodrigo Nunes - Coordenador responsvel pela parte multimdia
Srgio Gomes Veloso - Coordenador responsvel pelo ambiente (Moodle)
Agradecimento Especial
John Paul Petines Criador da Iniciativa
Rommel Feria Criador da Iniciativa

Lio 1
1. Objetivos
Nesta seo, vamos discutir os componentes bsicos de um computador, tanto em relao a hardwa-
re como a software. Tambm veremos uma pequena introduo sobre linguagens de programao e
sobre o ciclo de vida do desenvolvimento. Por fim, mostraremos os diferentes sistemas numricos e
as converses entre eles.
Ao final desta lio, o estudante ser capaz de:
Identificar os diferentes componentes de um computador.
Conhecer as linguagens de programao e suas categorias.
Entender o ciclo de vida de desenvolvimento de programas e aplic-lo na soluo de problemas.
Conhecer os diferentes sistemas numricos e as converses entre eles.
2. Explorando o Java
2.1. Um pouco da histria
Java foi criado em 1991 por James Gosling da Sun Microsystems. Inicialmente chamada OAK(Carva-
lho), em homenagem uma rvore de janela do Gosling, seu nome foi mudado para Javadevido a
existncia de uma linguagem com o nome OAK.
Figura 1: James Gosling criador do Java
A motivao original do Java era a necessidade de uma linguagem indepen-

dente de plataformaque podia ser utilizada em vrios produtos eletrnicos,
tais como torradeiras e refrigeradores. Um dos primeiros projetos desenvo-
lvidos utilizando Java era um controle remoto pessoal chamado *7 (Star
Seven).
Ao mesmo tempo, a World Wide Web e a Internet foram ganhando popula-

ridade. Gosling achava que a linguagem Java poderia ser usada para pro-
gramao da Internet.
2.2. O que uma tecnologia JAVA?
2.2.1. Uma linguagem de programao
Como linguagem de programao, Java pode ser utilizado para criar to-
dos os tipos de aplicaes existentes, de programas de Inteligncia Arti-
ficial para Robs at programas para aparelhos celulares.
2.2.2. Um ambiente de desenvolvimento
Como ambiente de desenvolvimento, a tecnologia Java fornece um grande conjunto deferramentas:

um compilador, um interpretador, um gerador de documentao, ferramenta de empacotamento de
classes de arquivos e outros.
2.2.3. Um ambiente de aplicao
Aplicaes de tecnologia Java so tipicamente programas de propsito geral que executam sobreu-
ma mquina onde o Java Runtime Environment instalado.
2.2.4. Um ambiente de distribuio
H dois ambientes de distribuio principais: Primeiro, o JRE, fornecido atravs do Java 2 Software
Development Kit (SDK), contm um conjunto completo de arquivos de classes para todos pacotes de
tecnologia Java. Outro ambiente de distribuio o navegador web, ou seja, o browser. Os navega-
dores web atuais fornecem interpretao tecnologia e ambiente Java em tempo de execuo.
Figura 3: JDK e JRE
2.3. Algumas Caractersticas do JAVA
2.3.1. Mquina Virtual Java
A Mquina Virtual Java uma mquina imaginria que implementada atravs de um softwaree-
mulador em uma mquina real. A JVM prov especificaes de plataforma de hardware na qual com-
pila-se todo cdigo de tecnologia Java. Essas especificaes permitem que o software Javaseja uma
plataforma independente pois a compilao feita por uma mquina genricaconhecida como JVM.
O bytecode uma linguagem de mquina especial que pode ser entendida pela Mquina Virtual
Java (JVM). O bytecode independente de qualquer hardware de computador particular. Assim,
qualquer computador com o interpretador Java pode executar um programa Java compilado, no im-
portando em que tipo de computador o programa foi compilado.
2.3.2. Garbage Collection
Muitas linguagens de programao permitem ao programador alocar memria durante o tempo de

execuo. Entretanto, aps utilizar a memria alocada, deve existir uma maneira para desalocar o
bloco de memria de forma que os demais programas a utilizem novamente. Em C, C++ e outras
linguagens o programador o responsvel por isso. Isso, s vezes, pode ser difcil j que instncias
podem ser esquecidas de serem desalocadas da memria pelos programadores e resultar no que
chamamos de escapes da memria.
Em Java, o programador no possui a obrigao da retirar uma varivel criada das reas de mem-
ria, isto feito por uma parte da JVM especfica que chamamos de Garbage Collection. O Garbage
Collection o grande responsvel pela liberao automtica do espao em memria.
Isso acontece automaticamente durante o tempo de vida do programa Java.
2.3.3. Segurana de cdigo
Segurana do Cdigo alcanada em Java atravs da implementao da Java Runtime Environment

(JRE). A JRE roda cdigos compilados para a JVM e executa o carregamento de classes (atravs do
Class Loader), verificao de cdigo (atravs do verificador de bytecode) e finalmente o cdigo exe-
cutvel.
O Class Loader responsvel por carregar todas as classes necessrias ao programa Java. Isso adi-
ciona segurana atravs da separao do namespace entre as classes do sistema de arquivos local e
aquelas que so importadas pela rede. Isso limita qualquer ao de programas que podem causar
danos, pois as classes locais so carregadas primeiro. Depois de carregar todas as classes, a quanti-
dade de memria que o executvel ir ocupar determinada. Isto acrescenta,
novamente, uma proteo ao acesso no autorizado de reas restritas ao cdigo pois a quantidade
de memria ocupada determinada em tempo de execuo.
Aps carregar as classes e definir a quantidade de memria, o verificador de bytecode verifica o for-
mato dos fragmentos de cdigo e pesquisa nestes fragmentos por cdigos ilegais que possam violar
o direito de acesso aos objetos.
Depois que tudo isso tiver sido feito, o cdigo finalmente executado.
2.4. Fases do Java programa
A figura seguinte descreve o processo de compilao e execuo de um programa Java. O primeiro

passo para a criao de um programa Java escrever os programas em um editor de texto. Exem-
plos de editores de texto que podem ser utilizados: bloco de notas, vi, emacs, etc.Esses arquivos
so armazenados no disco rgido com a extenso .java.
Figura 1: Fases de um Programa Java.
Aps o programa Java ter sido criado e salvo, compile o programa utilizando o Compilador Java. A
sada desse processo um arquivo de bytecode com extenso .class. O arquivo .class ento lido
pelo Interpretador Java que converte os bytecodes em linguagem de mquina do computador que se
est usando.
Tarefa Ferramenta utilizada Sada
Escrever o programa Qualquer editor de texto Arquivo com extenso .java Compilar o programa
Compilador Java Arquivo com extenso .class (Java bytecode). Executar o programa Interpretador
Java Sada do programa
Tabela 1: Resumo das fases de um programa Java.
3. Primeiro Programa Java

Antes de explicar o que o programa significa, vamos escrev-lo e execut-lo.
3.1. Utilizando a Console e um editor de texto

Neste exemplo utilizaremos um simples editor de texto, que pode ser o gedit do Linux ou o notepad
do Windows, para editar o cdigo fonte. Em seguida ser necessrio abrir uma janela terminal para
compilar e executar os programas.
Passo 1: executar um editor de texto
Accessories Text Editor. Para

Para iniciar um editor de texto no Linux selecione Applications
iniciar um editor de texto no Windows selecione Start Programs Accessories Notepad.
Passo 2: Abrir a janela de console
Para abrir o terminal no Linux, selecione Applications Accessories Terminal. Para abrir o ter-
minal no Windows, selecione Start Run... e na janela que se apresenta, digite cmd e pressione o
boto OK.
Passo 3: Escrever as instrues utilizando o Editor de Texto
Digite as seguintes instrues no editor de textos:

public class Hello
{
/**
* Meu primeiro programa Java
*/
public static void main(String[] args) {
// Mostra na tela o texto "Hello world"
System.out.println("Hello world!");
}
}
Passo 4: Salvar o programa Java
Chamaremos o programa de "Hello.java" e o colocaremos em uma pasta denominada "myJavaPro-

grams". Caso esta pasta no tenha sido criada, retorne janela de terminal aberta e insira as se-
guintes instrues:
Para o Linux:
$ md myJavaPrograms
Para o Windows:
C:\> md myJavaPrograms
Retorne ao Editor de textos e salve o programa. Para abrir a caixa de dilogo salvar selecione aop-
o "File" localizada na barra de menus e depois clique na opo "Save". Selecione a nova pasta cria-
da como myJavaPrograms para entrar nela. A pasta deve estar vazia porque ainda no salvamos
nada dentro dela.
Na caixa de texto "Name", digite o nome do programa (Hello.java), e depois clique no boto salvar.
ATENO: Para o Notepad no Windows, mude o Tipo para "All Files" (em Save as Type).
Aps salvar o arquivo observe que o ttulo da janela mudou de "Untitled" para "Hello.java", caso de-
seje alterar novamente o arquivo basta edit-lo e depois salv-lo novamente clicando em File
Save.
Passo 5: Entrar na pasta que contm o programa
O prximo passo deve ser o de compilar o programa. Inicialmente, precisamos entrar na pasta que o
contm. Retorne janela do terminal.
Em Linux:
Normalmente, quando abrimos uma janela terminal, ela vai diretamente para sua pasta home (iden-
tificada por $). Para ver o que tem dentro do diretrio digite ls (LS em minscula, significando "List
Sources") e pressione ENTER. Isso far com que sejam listados os arquivos e pastas da pasta home.
Verifique a existncia de uma pasta chamada "myJavaPrograms", criada a pouco, sendo esta olocal
em que foi salvo o programa "Hello.java". Mudaremos o contexto para esta pasta.
Para entrar nesta pasta devemos utilizar o comando: cd [nome da pasta]. O comando "cd" significa
"Change Directory". Digitaremos:
$ cd myJavaPrograms
Agora que estamos dentro da pasta onde o arquivo do programa est, poderemos ento compil-lo.
Certifique-se de que o arquivo est realmente dentro desta, executando o comando ls (LS em mi-
nscula) novamente.
Em Windows:
Normalmente, quando abrimos uma janela terminal ela vai diretamente para sua pasta raiz
(identificada por C:\). Para conhecer o contedo do diretrio digite dir (significando "directory") e
pressione ENTER. Isso far com que sejam listados os arquivos e pastas da pasta principal. Verifique
a existncia de uma pasta chamada "myJavaPrograms", criada a pouco, sendo esta o local em que
foi salvo o programa "Hello.java". Mudaremos o contexto para esta pasta.
Para entrar nesta pasta devemos utilizar o comando: cd [nome da pasta]. O comando "cd" significa
"Change Directory". Digitaremos:
C:\>cd myJavaPrograms
Agora que estamos dentro da pasta onde o arquivo do programa est, poderemos ento compil-lo.
Certifique-se de que o arquivo est realmente dentro desta, executando o comando dir novamente.
Passo 6: Compilar o programa
Para compilar o programa, utilizamos o comando: javac [Nome do Arquivo]. Ou seja:
javac Hello.java
Durante a compilao, criado o arquivo: [Nome do Arquivo].class, neste caso, Hello.class, que
contm o cdigo em linguagem de mquina (chamado de bytecode).
Passo 7: Executar o programa
Assumindo que no ocorreu problemas na compilao (caso tenha ocorrido qualquer problema refa-
a os passos realizados), estamos prontos para executar o programa.
Para executar o programa, utilizamos o comando: java [nome do arquivo sem a extenso].
No caso do exemplo, digite:
java Hello
Veremos na mesma tela, em que foi executado o comando, a seguinte mensagem:
Hello world!
3.2. Erros
Vimos um pequeno programa Java, geralmente no encontraremos qualquer problema para compilar
e executar esses programas, entretanto nem sempre este o caso, como mencionamos na primeira
parte deste curso, ocasionalmente encontramos erros durante esse processo.
Como mencionamos antes, h dois tipos de erros: o primeiro pode ocorrer durante a compilao,
chamado de erro de sintaxe, o segundo pode ocorrer durante a execuo, chamado runtime error.
3.2.1 Erros de Sintaxe
Os erros de sintaxe normalmente so erros de digitao, ocasionados pelo programador que podeter
se equivocado e digitar uma instruo errada, ou por esquecimento de alguma parte da instruo,
por exemplo, um ponto e vrgula. O Compilador tenta isolar o erro exibindo a linha de instruo e
mostrando o primeiro caractere incorreto naquela linha, entretanto, um erro pode no estar exata-
mente neste ponto. Outros erros comuns so a troca de letras, troca de letras maiscula por mins-
cula (a linguagem Java completamente case-sensitive, ou seja, o caractere "a" completamente
diferente do caractere "A", e o uso incorreto da pontuao.
Vamos retornar ao exemplo, o programa Hello.java. Intencionalmente, escreveremos a palavrachave
"static" de forma errada e omitiremos o ponto-e-vrgula em uma instruo e a deixaremos errada.
public class Hello
{
/**
* Meu primeiro programa Java
*/
public statict void main(String[] args) {
// A linha abaixo foi retirado o ;
System.out.println("Hello world!")
}
}
Salve o programa e execute os passos necessrios para compil-lo. Observe a mensagem de erro
gerada ao se tentar compilar novamente o programa:
Hello.java:6: <identifier> expected
public statict void main(String[] args) {
^
Hello.java:10: ';' expected
}
^
1 error
A primeira mensagem de erro sugere que existe um erro na linha 6 do programa apontado para
apalavra void, entretanto esta palavra est correta. O erro na palavra anterior statict que deveser
digitada como static.
A segunda mensagem de erro sugere que faltou um ponto-e-vrgula na linha 10, entretanto, esta
contm simplesmente o comando de fechar o bloco do mtodo main. O erro est exatamente na li-
nha anterior. Como regra, ao encontrar muitas mensagens de erros devemos corrigir o primeiro erro
da lista e tente novamente compilar o programa. Deste modo reduziremos o nmero total de men-
sagens de erro dramaticamente, pois podem existir o que chamamos de erros derivados, ou seja,
um erro que tem por causa a instruo anterior.
3.2.2 Erros em tempo de execuo (Erros de run-time)
Os erros em tempo de execuo so erros que no aparecero at que tentemos executar o progra-
ma. Os programas so compilados com sucesso, mas apresentaro respostas erradas, quepodem ter
como causa se o programador no obedeceu uma lgica coerente ou no caso em erro de estruturas
do programa.
4. Usando NetBeans
Construmos o programa sem utilizar nenhum recurso sofisticado, iremos aprender como fazertodo o
processo da seo anterior utilizando uma IDE. Nesta parte da lio utilizaremos o NetBeans que
um Ambiente de Desenvolvimento Integrado (IDE - Integrated Development Environment).
Um ambiente de desenvolvimento integrado um software aplicativo que possui uma interface cons-
trutora, um editor de texto, um editor de cdigo, um compilador e/ou interpretador e umdepurador.
Passo 1 : executar o NetBeans
Existem duas formas de executar o NetBeans: a primeira utilizando a linha de comandos de uma
janela terminal e segunda selecionar o cone de atalho encontrado na janela da rea de trabalho.
Para executar o NetBeans por intermdio da linha de comando, abra uma janela terminal (Os passos
para abrir a janela terminal foram discutidos anteriormente) e digite:
Figura 1: Executando o NetBeans pela linha de comandos
Para o Windows, este comando deve ser executado na pasta em que o NetBeans foi instalado, por
exemplo:
C:\Program Files\netbeans-5.5\bin>netbeans
A segunda maneira de executar o NetBeans clicando no cone de atalho encontrado na rea de tra-
balho do computador.
Depois de abrir a IDE NetBeans ser mostrada a interface grfica GUI, conforme Figura 3:
Passo 2: construir o projeto

Clique em File New Project, depois de fazer isso, uma janela de dilogo aparecer. Neste momen-
to deve-se clicar em "Java Application" e em seguida clicar no boto "Next >".
Figura 3: Janela de Welcome do NetBeans
Ser mostrada uma nova janela de dilogo, conforme a figura 5.
Troque o local da aplicao clicando no boto "Browse...". Aparecer uma janela de dilogo para lo-
calizao do diretrio. D um clique duplo no seu diretrio home.
Figura 5: Inserindo as informaes do projeto
Figura 6: Acertando a Localizao do Projeto
O contedo da raiz do diretrio ser apresentado. D um clique duplo no diretrio MYJAVAPRO-

GRAMS e depois d um clique no boto "Open".
Veja que a localizao do projeto mudou para /home/florence/MYJAVAPROGRAMS. Finalmente, no
campo "Create Main Class", digite "Hello", que ser o nome da classe principal, e em seguida clique
no boto "Finish".
Figura 7: Definindo o Nome da Classe Principal
Passo 3: escrever os detalhes do programa
Antes de escrever o programa descreveremos a janela principal. Como mostrado na figura 8, auto-
maticamente, o NetBeans cria um cdigo bsico para o programa Java. Poderemos adicionar as de-
claraes neste cdigo gerado. No lado esquerdo da janela visualizamos uma lista de pastas e arqui-
vos que o NetBeans gerou antes de criar o projeto. Tudo se encontra dentro da sua pasta MYJAVA-
PROGRAMS, onde foi configurado o local do projeto. No lado direito, visualizamos o cdigo gerado.
Modifique o cdigo gerado pelo NetBeans, por hora ignoraremos as outras partes das instrues dis-
cutindo os detalhes destas posteriormente. Insira a seguinte instruo:
Isto significa que voc deseja que seja mostrada a mensagem "Hello world!" na sada padro do
computador, em seguida seja feito um salto de linha. Poderamos substituir esta instruo por duas
equivalentes:
System.out.print("Hello");
System.out.println(" world!");
O mtodo print() faz com que no seja provocado o salto de linha, utilizaremos para este exemplo a
primeira instruo. Insira esta instruo aps a linha de comentrio (que ser desprezada pelo com-
pilador):
//TODO code application logic here.
Figura 8: Viso do projeto criado
Passo 4 : compilar o projeto
Para compilar o programa, a partir do Menu Principal selecione Build Build Main Project, ou utilize
a tecla de atalho F11, ou utilize o boto de atalho para compilar o cdigo.
Figura 10: Boto de Atalho para executar o Projeto
Figura 9: Inserindo sua instruo
Se no existir erros no programa, veremos a mensagem de sucesso na janela de sada.

Passo 5: Executar o projeto
Para executar o programa, clique em Run Run Main Project, ou utilize a tecla de atalho F6, ouuti-
lize o boto de atalho para executar o programa.
Figura 11: Verificando o Sucesso da Compilao

Figura 12: Executando o projeto
O resultado final do programa, ser mostrado na janela de sada.

Figura 13: Resultado final da execuo do projeto
5. Exerccios
5.1 Melhorando o Hello World!
Utilizando o NetBeans crie uma classe chamada [SeuNome], o programa dever mostrar comoresul-
tado a mensagem:
Welcome to Java Programming [SeuNome]!!!
5.2. A rvore
Utilizando o NetBeans, crie uma classe chamada TheTree. O programa dever mostrar asseguintes
linhas na sada:
I think that I shall never see,
[Eu acho que nunca verei,]
a poem as lovely as a tree.
[um poema to adorvel quanto uma rvore.]
A tree whose hungry mouth is pressed
[Uma rvore cuja boca faminta pressionada]
Against the Earths sweet flowing breast.
[Contra a Terra fluindo em seu seio docemente.]
Lio 2
1. Objetivos
Nesta lio iremos discutir um pouco da histria de Java e o que a tecnologia Java. Tambm ire-
mos discutir as fases de um programa Java.

Descrever as caractersticas da tecnologia Java como a JVM - Mquina Virtual Java, Garbage Collec-
tion e segurana do cdigo;
Descrever as diferentes fases de um programa Java.
2. Entendendo meu primeiro programa em Java

Tentaremos compreender este primeiro programa.
public class Hello
{
/**
* Meu primeiro programa em Java
*/
// Exibir a mensagem "Hello world" na tela
}
}
Esta primeira linha do cdigo:
public class Hello
Indica o nome da classe, que neste caso Hello. Em Java, todo e qualquer cdigo dever serescrito
dentro da declarao de uma classe. Fazemos isso usando a palavra-chave class. Alm disso, a clas-
se usa um identificador de acesso public, indicando que a classe acessvel para outras classes de
diferentes pacotes (pacotes so colees de classes). Trataremos de pacotes e identificadores de
acesso mais tarde, ainda neste mdulo.
A prxima linha contm uma chave {. Indica o incio de um bloco de instrues. Neste programa po-
sicionamos a chave na linha aps a declarao da classe, entretanto, poderamos tambm coloc-la
na mesma linha em que a declarao foi feita. Ento, o cdigo seria escrito da seguinte forma:
public class Hello
{
ou
public class Hello {
As prximas 3 linhas indicam um comentrio em Java. Um comentrio uma explicao do progra-
mador usada na documentao de uma parte do cdigo. Este comentrio no propriamente uma
parte do cdigo, usado apenas para fins de documentao do programa.
uma boa prtica de programao adicionar comentrios relevantes ao cdigo.

/**
* Meu primeiro programa em Java
*/
Um comentrio pode ser indicado pelos delimitadores /* e */. Qualquer coisa entre estes
delimitadores ignorado pelo compilador Java e tratado como comentrio. A prxima linha,
que tambm pode ser escrita da seguinte forma:

public static void main(String[] args)
{
indica o nome de um mtodo no programa que o mtodo principal main. O mtodo main o ponto
de partida para qualquer programa feito em Java. Todo e qualquer programa escrito em Java, com
exceo de Applets, inicia com o mtodo main. Certifique-se de que a assinatura do mtodo (confor-
me descrita acima) est correta.
A linha seguinte tambm um comentrio em Java,

// exibe a mensagem "Hello world" na tela
At agora, j aprendemos duas maneiras de fazer comentrios em Java. Uma posicionar o comen-
trio entre /* e */, e a outra colocar // antes do comentrio. A linha de instruo abaixo,
escreve o texto "Hello World!" na tela. O comando System.out.println( ), escreve na sadapadro do

computador o texto situado entre aspas duplas. As ltimas duas linhas, que contm somente uma
chave em cada, simbolizam, respectivamente, o fechamento do mtodo main e da classe.
Dicas de programao :
1. Os programas em Java devem sempre conter a terminao .java no nome do arquivo.
2. O nome do arquivo deve sempre ser idntico ao nome da classe pblica. Ento, por exemplo,
se o nome da classe pblica Hello o arquivo dever ser salvo com o nome: Hello.java.
3. Inserir comentrios sobre o que a classe ou mtodo realiza, isso facilitar o entendimento de
quem posteriormente ler o programa, incluindo o prprio autor.
3. Comentrios em Java
Comentrios so notas escritas pelo programador para fins de documentao. Estas notas no fazem
parte do programa e no afetam o fluxo de controle. Java suporta trs tipos de comentrios: comen-
trio de linha estilo C++, comentrio de bloco estilo C e um comentrio estilo Javadoc (utilizado
compor a documentao do programa).
3.1. Comentrio de linha
Comentrios com estilo em C++ se iniciam por "//". Todo e qualquer texto colocado aps as // ig-
norado pelo compilador e tratado como comentrio. Por exemplo:
// Este um comentrio estilo C++ ou comentrio de linha
3.2. Comentrio de bloco
Comentrios com estilo em C, tambm chamados de comentrios multi-linhas, se iniciam com /* e

terminam com */. Todo o texto posto entre os dois delimitadores tratado como comentrio. Dife-
rente do comentrio estilo C++, este pode se expandir para vrias linhas. Por exemplo:
/*
* Este um exemplo de comentrio
* estilo C ou um comentrio de bloco
*
*/
3.3. Comentrio estilo Javadoc

Este comentrio utilizado na gerao da documentao em HTML dos programas escritos em
Java. Para se criar um comentrio em estilo Javadoc deve se iniciar o comentrio com /** e
termin-lo com */. Assim como os comentrios estilo C, este tambm pode conter vrias
linhas. Este comentrio tambm pode conter certas tags que do mais informaes
documentao. Por exemplo:
/**
Este um exemplo de um comentrio especial usado para \n
gerar uma documentao em HTML. Este utiliza tags como:
@author Florence Balagtas
@version 1.2
*/
Este tipo de comentrio deve ser utilizado antes da assinatura da classe:

public class Hello {
Para documentar o objetivo do programa ou antes da assinatura de mtodos:

Para documentar a utilidade de um determinado mtodo.
4. Instrues e Bloco em Java

Uma instruo composta de uma ou mais linhas terminadas por ponto-e-vrgula. Um exemplo de
uma simples instruo pode ser:
System.out.println("Hello world");
Um bloco formado por uma ou mais instrues agrupadas entre chaves indicando que formam
uma s unidade. Blocos podem ser organizados em estruturas aninhadas indefinidamente. Qualquer
quantidade de espaos em branco permitida. Um exemplo de bloco pode ser:
System.out.print("Hello ");
System.out.println("world");
Dicas de programao:
1. Na criao de blocos, a chave que indica o incio pode ser colocada ao final da linha anterior ao
bloco, como no exemplo:
public static void main(String [] args) {
ou na prxima linha, como em:
public static void main(String [] args)
{
2. uma boa prtica de programao organizar as instrues que sero colocadas apso incio de
um bloco, como por exemplo:
public static void main(String [] args) {
System.out.println("world");
}
5. Identificadores em Java
Identificadores so representaes de nomes de variveis, mtodos, classes, etc. Exemplos de iden-
tificadores podem ser: Hello, main, System, out. O compilador Java difere as letras maisculas de
minsculas (case-sensitive). Isto significa que o identificador Hello no o mesmo que hello. Os
identificadores em Java devem comear com uma letra, um underscore _, ou um sinal de cifro
$. As letras podem estar tanto em maisculo quanto em minsculo. Os caracteres subseqentes
podem usar nmeros de 0 a 9. Os identificadores no podem ter nomes iguais s palavras-chave ou
palavras reservadas do Java, como: class, public, void, int, etc. Discutiremos mais sobre estas pala-
vras mais tarde.
Dicas de programao:
1. Para nomes de classes, a primeira letra deve ser maiscula. Nomes de mtodos ou variveis de-
vem comear com letra minscula. Por exemplo:
ExemploDeNomeDeUmaClasse
exemploDeNomeDeUmMetodo
2. No caso de identificadores com mais de uma palavra, a primeira letra de cada palavra, com ex-
ceo da primeira, deve vir em maisculo. Por exemplo:
charArray fileNumber - className
3. Evite o uso de undescores no incio de um identificador. Por exemplo:
_NomeDeClasse.
6. Palavras-chave em Java
Palavras-chave so identificadores que, em Java, foram pr-definidas para propsitos especficos.
No se pode usar esses identificadores como nomes de variveis, mtodos, classes, etc. A seguir, te-
mos a lista com as palavras-chave em Java.
Figura 1: Palavras-Chave em Java
Ao longo dos tpicos seguintes, iremos abordar os significados destas palavras-chave e comoso
usadas nos programas em Java.
Nota: true, false e null no so palavras-chave, porm, so palavras-reservadas, e, da mesma ma-

neira, no permitido seu uso na atribuio a nomes de variveis, mtodos ou classes.
7. Tipos de Dados em Java

Java possui 4 tipos de dados. Estes tipos de dados so divididos em: boolean, character, integer e
float-point.
7.1. Boolean
Um dado boolean poder assumir somente dois valores: true ou false.
7.2. Character
Os characters so representaes da tabela Unicode. Um smbolo da tabela Unicode um valor de

16 bits que pode substituir os smbolos da tabela ASCII (que possuem 8 bits). A tabela Unicode per-
mite a insero de smbolos especiais ou de outros idiomas. Para representar um caractere usam-se
aspas simples. Por exemplo, a letra "a" ser representada como 'a'. Para representar caracteres es-
peciais, usa-se a "\" seguido pelo cdigo do caractere especial. Por exemplo, '\n' para o caractere de
nova linha, '\'' representar o character ' (aspas simples) e '\u0061' representao Unicode do smbo-
lo 'a'.
7.3. Integer
Os dados do tipo integer vm em diferentes formatos: decimal (base 10), hexadecimal (base 16), e
octal (base 8). Ao usar estes diferentes tipos de dados Integer nos programas necessrio seguir
algumas notaes preestabelecidas. Para dados decimais no existe notao, basta escrever o n-
mero. Os nmeros hexadecimais devero ser precedidos por "0x" ou "0X". E os octais devero ser
precedidos por "0".
Por exemplo, considere o nmero 12. Sua representao em decimal apenas o nmero 12, sem
nenhuma notao adicional, enquanto que sua representao em hexadecimal 0xC (pois o nmero
12 em hexadecimal representado pela letra C), e em octal ele representado por 014. O valor pa-
dro para tipos de dados Integer o tipo int. Um int um valor, com sinal, de 32 bits.
Em alguns casos pode ser necessrio forar o dado Integer a ser do tipo long, para fazer isso basta
colocar a letra "l" (L minscula) ou "L" aps o nmero. Um dado do tipo long um valor com sinal
de 64 bits. Falaremos mais sobre os tipos de dados mais tarde.
7.4. Float-Point
Os tipos de float-point representam dados Integer com parte fracionria. Um exemplo o nmero
3.1415 (lembrando que o padro ingls utiliza o "." como divisor da parte fracionria).
Esses tipos podem ser expressos em notao cientfica ou padro. Um exemplo de notao padro
o nmero 583.45 enquanto que em notao cientfica ele seria representado por 5.8345e2. O valor
padro para um dado ponto-flutuante o double, que um valor de 64 bits.
Se for necessrio usar um nmero com uma preciso menor (32 bits) usa-se o float, que finaliza-
do pela letra "f" ou "F" acrescida ao nmero em questo, por exemplo, 583.45f.
8. Tipos de Dados Primitivos

A linguagem Java possui 8 tipos de dados primitivos. Eles so divididos nas seguintes representa-
es:
Tabela 1: Representaes dos dados primitivos
8.1. Lgico
O tipo boolean pode representar dois estados: true (verdadeiro) ou false (falso). Um exemplo :
boolean resultado = true;
No exemplo demonstrado acima, declarado um atributo chamado resultado do tipo boolean e atri-
budo a este o valor verdadeiro.
8.2. Inteiro
Os inteiros em Java podem ser representados em 5 formas, como j foi visto, e estas so: decimal,
octal, hexadecimal, ASCII e Unicode. Como por exemplo:
2 // valor 2 em decimal
077 // 0 indica que ele est representado em octal.
0xBACC // 0x indica que ele est representado em hexadecimal.
'a' // representao ASCII
'\u0061' // representao Unicode
O dado do tipo char um inteiro especial, sendo exclusivamente positivo e representa um nico
Unicode. Ele deve ser, obrigatoriamente, colocado entre aspas simples (''). Sua representao como
inteiro pode ser confusa para o iniciante, entretanto, o tempo e a prtica faro com que se acostume
com este tipo. Por exemplo:
char c = 97; // representa o smbolo 'a'
byte b = 'a'; // em inteiro representa o nmero 97
possvel definir para qualquer inteiro nas formas mostradas. O que difere o tipo char dosdemais in-
teiros que a sua sada sempre ser mostrada como um valor ASCII. Enquanto que os inteiros se-
ro sempre mostrados por nmeros decimais. Por exemplo:
char c = 97;
byte b = 'a';
System.out.println("char = " + c + " - byte = " + b);
Resultar:
char = a - byte = 97
Um cuidado deve ser tomado quanto aos inteiros: qualquer operao efetuada entre eles ter sem-
pre como resultado um tipo int. Por exemplo:
byte b1 = 1;
byte b2 = 2;
byte resultado = b1 + b2;
Esta instruo final causar um erro de compilao, devendo ser modificada para:
int resultado = b1 + b2;
8.3. Inteiro Longo
Os inteiros tm por padro o valor representado pelo tipo primitivo int. Pode-se represent-loscomo
long adicionando, ao final do nmero, um "l" ou "L". Os tipos de dados inteiros assumem valores nas
seguintes faixas:
Tabela 2: Tipos e faixa de valores dos Inteiros e Inteiro Longo

Dicas de programao:
1. Para declarar um nmero como sendo um long prefervel usar L maisculo, pois, se este es-
tiver em minsculo, pode ser difcil distingu-lo do dgito 1.
8.4. Nmero Fracionrio
Os dados do tipo ponto-flutuante possuem o valor double como padro. Os nmeros flutuantes pos-
suem um ponto decimal ou um dos seguintes caracteres:
E ou e // expoente
F ou f // float
D ou d // double
So exemplos,
3.14 // tipo double
6.02E23 // double com expoente
2.718F // float
123.4E+306D // double
No exemplo acima, o nmero 23 aps o E implicitamente positivo. equivalente a 6.02E+23. Os

dados de tipo ponto-flutuante podem assumir valores dentro das seguintes faixas:
Tabela 3: Tipos e faixa de valores dos Nmero Fracionrios
9. Variveis
Uma varivel um espao na memria usado para armazenar o estado de um objeto.Uma varivel
deve ter um nome e um tipo. O tipo da varivel indica o tipo de dado que ela pode conter. O nome
das variveis deve seguir as mesmas regras de nomenclatura que os identificadores.
9.1. Declarando e inicializando Variveis
A seguir, vemos como feita a declarao de uma varivel:

<tipo do dado> <nome> [= valor inicial];
nota: os valores colocados entre < > so obrigatrios, enquanto que os valores contidos entre [ ]
so opcionais.
Aqui vemos um exemplo de programa que declara e inicializa algumas variveis:

public class VariableSamples {
public static void main( String[] args ){
// declara uma varivel com nome result e tipo boolean
boolean result;
// declara uma varivel com nome option e tipo char

char option;
// atribui o smbolo C para a varivel
option = 'C';
// declara uma varivel com nome grade e tipo double

// e a inicializa com o valor 0.0
double grade = 0.0;
}
}
Dicas de programao:
1. sempre prefervel que se inicialize uma varivel assim que ela for declarada.
2. Use nomes com significado para suas variveis. Se usar uma varivel para armazenar a nota de
um aluno, declare-a com o nome 'nota' e no simplesmente com uma letra aleatria 'x'.
3. prefervel declarar uma varivel por linha, do que vrias na mesma linha. Por exemplo:
int variavel1;
int variavel2;
E no:
int variavel1, variavel2;
9.2. Exibindo o valor de uma Varivel
Para exibirmos em qualquer dispositivo de sada o valor de uma varivel, fazemos uso dos seguintes
comandos:
System.out.println()
System.out.print()
Aqui est um simples programa como exemplo:

public class OutputVariable {
int value = 10;
char x;
x = 'A';
System.out.println(value);
System.out.println("The value of x = " + x );
}
}
A sada deste programa ser a seguinte:
10
The value of x = A
9.3. System.out.println( ) e System.out.print( )
Qual a diferena entre os comandos System.out.println( ) e o System.out.print( )? O primeiro faz

iniciar uma nova linha aps ser exibido seu contedo, enquanto que o segundo no.
Considere as seguintes instrues:

System.out.print("world!");
Essas instrues apresentaro a seguinte sada:

Hello world!
Considere as seguintes:
System.out.println("Hello ");
System.out.println("world!");
Estas apresentaro a seguinte sada:

Hello
world!
9.4. Referncia de Variveis e Valor das Variveis
Iremos diferenciar os dois tipos de variveis suportados pelo Java. Estes podem ser de referncia ou
de valor. As variveis de valor, ou primitivas, so aquelas que armazenam dados no exato espa-
ode memria onde a varivel est. As variveis de referncia so aquelas que armazenam o ende-
reo de memria onde o dado est armazenado. Ao declarar uma varivel de certa classe (varivel
de classe), se declara uma varivel de referncia a um objeto daquela classe. Por exemplo, vamos
supor que se tenha estas duas variveis do tipo int e da classe String.
int num = 10;
String nome = Hello;
Suponha que o quadro abaixo represente a memria do computador, com seus endereos de mem-
ria, o nome das variveis e os tipos de dados que ele pode suportar.
Endereo de memria Nome da varivel Dado

1001 num 10
: :
1563 nome Endereo (2000)
:
::
2000 "Hello"
A varivel (do tipo int) num o dado o atual valor contido por ela e, a referncia da varivel (do tipo
string) nome somente armazenado o endereo de memria que contm o valor da varivel.
10. Operadores
Em Java temos diferentes tipos de operadores. Existem operadores aritmticos, operadores rela-
cionais, operadores lgicos e operadores condicionais. Estes operadores obedecem a uma ordem
de precedncia para que o compilador saiba qual operao executar primeiro, no caso de uma sen-
tena possuir grande variedade destes.
10.1. Operadores Aritmticos
Aqui temos a lista dos operadores aritmticos que podem ser utilizados na criao de expresses
matemticas:
Tabela 4: Operadores aritmticos e suas funes
Aqui temos um programa que exemplifica o uso destes operadores:

public class ArithmeticDemo {
// alguns nmeros
int i = 37;
int j = 42;
double x = 27.475;
double y = 7.22;
System.out.println("Variables values...");
System.out.println(" i = " + i);
System.out.println(" j = " + j);
System.out.println(" x = " + x);
System.out.println(" y = " + y);
// adio dos nmeros

System.out.println("Adding...");
System.out.println(" i + j = " + (i + j));
System.out.println(" x + y = " + (x + y));
// subtrao dos nmeros

System.out.println("Subtracting...");
System.out.println(" i - j = " + (i - j));
System.out.println(" x - y = " + (x - y));
// multiplicao dos nmeros

System.out.println("Multiplying...");
System.out.println(" i * j = " + (i * j));
System.out.println(" x * y = " + (x * y));
// diviso dos nmeros

System.out.println("Dividing...");
System.out.println(" i / j = " + (i / j));
System.out.println(" x / y = " + (x / y));
// resto da diviso
System.out.println("Comuting the remainder...");
System.out.println(" i % j = " + (i % j));
System.out.println(" x % y = " + (x % y));
// misturando operaes
System.out.println("Mixing types...");
System.out.println(" j + y = " + (j + y));
System.out.println(" i * x = " + (i * x));
}
}
e como sada, temos:
Variables values...
i = 37
j = 42
x = 27.475
y = 7.22
Adding...
i + j = 79
x + y = 34.695
Subtracting...
i - j = -5
x - y = 20.255
Multiplying...
i * j = 1554
x * y = 198.37
Dividing...
i/j=0
x / y = 3.8054
Comuting the remainder...
i % j = 37
x % y = 5.815
Mixing types...
j + y = 49.22
i * x = 1016.58
Nota: Quando um nmero de tipo inteiro e um outro de nmero fracionrio so usados numa nica
operao, o resultado ser dado pela varivel de maior tipo, no caso, valor de nmero fracionrio. O
nmero inteiro implicitamente convertido para o nmero fracionrio antes da operao ter incio.
11. Operadores de Incremento e Decremento

Alm dos operadores aritmticos bsicos, Java d suporte ao operador unrio de incremento (++) e
ao operador unrio de decremento (--). Operadores de incremento ou decremento aumentam ou di-
minuem em 1 o valor da varivel. Por exemplo, a expresso,
count = count + 1; // incrementa o valor de count em 1
equivalente a,
count++;
Tabela 5: Operadores de incremento e decremento
Como visto na tabela acima, os operadores de incremento e decremento podem ser usadostanto an-
tes como aps o operando. E sua utilizao depender disso. Quando usado antes do operando, pro-
voca acrscimo ou decrscimo de seu valor antes da avaliao da expresso em que ele aparece. Por
exemplo:
int i = 10,
int j = 3;
int k = 0;
k = ++j + i; //resultar em k = 4+10 = 14
Quando utilizado depois do operando, provoca, na varivel, acrscimo ou decrscimo do seuvalor
aps a avaliao da expresso na qual ele aparece. Por exemplo:
int i = 10,
int j = 3;
int k = 0;
k = j++ + i; //resultar em k = 3+10 = 13
Dicas de programao:
1. Mantenha sempre as operaes incluindo operadores de incremento ou decremento de forma

simples e de fcil compreenso.
12. Operadores Relacionais

Os operadores relacionais so usados para comparar dois valores e determinar orelacionamento en-
tre eles. A sada desta avaliao ser fornecida com um valor lgico: true ou false.
Tabela 6: Operadores relacionais
O programa a seguir, mostra a utilizao destes operadores:

public class RelationalDemo {
// alguns nmeros
int i = 37;
int j = 42;
int k = 42;
System.out.println("Variables values...");
System.out.println(" i = " + i);
System.out.println(" j = " + j);
System.out.println(" k = " + k);
// maior que
System.out.println("Greater than...");
System.out.println(" i > j = " + (i > j)); //false
System.out.println(" j > i = " + (j > i)); //true
System.out.println(" k > j = " + (k > j)); //false
// maior ou igual a
System.out.println("Greater than or equal to...");
System.out.println(" i >= j = " + (i >= j)); //false
System.out.println(" j >= i = " + (j >= i)); //true
System.out.println(" k >= j = " + (k >= j)); //true
// menor que
System.out.println("Less than...");
System.out.println(" i < j = " + (i < j)); //true
System.out.println(" j < i = " + (j < i)); //false
System.out.println(" k < j = " + (k < j)); //false
// menor ou igual a
System.out.println("Less than or equal to...");
System.out.println(" i <= j = " + (i <= j)); //true
System.out.println(" j <= i = " + (j <= i)); //false
System.out.println(" k <= j = " + (k <= j)); //true
// igual a
System.out.println("Equal to...");
System.out.println(" i == j = " + (i == j)); //false
System.out.println(" k == j = " + (k == j)); //true
// diferente
System.out.println("Not equal to...");
System.out.println(" i != j = " + (i != j)); //true
System.out.println(" k != j = " + (k != j)); //false
}
}
A seguir temos a sada deste programa:
Variables values...
i = 37
j = 42
k = 42
Greater than...
i > j = false
j > i = true
k > j = false
Greater than or equal to...
i >= j = false
j >= i = true
k >= j = true
Less than...
i < j = true
j < i = false
k < j = false
Less than or equal to...
i <= j = true
j <= i = false
k <= j = true
Equal to...
i == j = false
k == j = true
Not equal to...
i != j = true
k != j = false
13. Operadores Lgicos

Operadores lgicos avaliam um ou mais operandos lgicos que geram um nico valor final true ou
false como resultado da expresso. So seis os operadores lgicos: && (e lgico), & (e binrio), ||
(ou lgico), | (ou binrio), ^ (ou exclusivo binrio) e ! (negao).
A operao bsica para um operador lgico :

x1 op x2
Onde x1 e x2 podem ser expresses, variveis ou constantes lgicas, e op pode tanto ser &&, &, ||,
| ou ^.
13.1. && (e lgico) e & (e binrio)
Tabela 7: Tabela para && e &
A diferena bsica do operador && para & que o && suporta uma avaliao de curto-circuito (ou
avaliao parcial), enquanto que o & no. O que isso significa?
Dado o exemplo:
exp1 && exp2
o operador e lgico ir avaliar a expresso exp1, e, imediatamente, retornar um valor false se a
operao exp1 for falsa. Se a expresso exp1 resultar em um valor false o operador nunca avaliar
a expresso exp2, pois o valor de toda a expresso ser falsa mesmo que o resultado isolado de
exp2 seja verdadeiro. J o operador & sempre avalia as duas partes da expresso, mesmo que a pri-
meira tenha o valor false.

public class TestAND {
public static void main( String[] args ) {
int i = 0;
int j = 10;
boolean test = false;
// demonstrao do operador &&

test = (i > 10) && (j++ > 9);
System.out.println(i);
System.out.println(j);
System.out.println(test);
// demonstrao do operador &

test = (i > 10) & (j++ > 9);
}
}
Como resultado, o programa produzir a seguinte sada:
0
10
false
0
11
false
Note que o comando j++, na linha contendo &&, nunca ser executado, pois o operador no o ava-
lia, visto que a primeira parte da expresso (i>10) retorna um valor booleano false.
13.2. || ( ou lgico) e | ( ou binrio)
Tabela 8: Tabela para || e |
A diferena bsica entre os operadores || e |, que, semelhante ao operador &&, o || tambm su-
porta a avaliao parcial. O que isso significa?
Dada a expresso,
exp1 || exp2
o operador ou lgico ir avaliar a expresso exp1, e, imediatamente, retornar um valorlgico true
para toda a expresso se a primeira parte for avaliada como verdadeira. Se a expresso exp1 resul-
tar em verdadeira a segunda parte exp2 nunca ser avaliada, pois o valor final da expresso ser
true independentemente do resultado da segunda expresso.

public class TestOR {
int i = 0;
int j = 10;
boolean test = false;
// demonstrao do operador ||
test = (i < 10) || (j++ > 9);
// demonstrao do operador |
test = (i < 10) | (j++ > 9);
}
}
0
10
true
0
11
true
Note que a expresso j++ nunca ser avaliada na instruo que usa o operador ||, pois a
primeira parte da expresso (i<10) j retorna true como valor final da expresso.
13.3. ^ (ou exclusivo binrio)
Tabela 9: Tabela para o operador ^
O resultado de uma expresso usando o operador ou exclusivo binrio ter um valor true somente
se uma das expresses for verdadeira e a outra falsa. Note que ambos os operandos so necessaria-
mente avaliados pelo operador ^.
O programa a seguir, mostra a utilizao deste operador:

public class TestXOR {
boolean val1 = true;
System.out.println(val1 ^ val2);
val1 = false;
val2 = true;
val1 = false;
val2 = false;
val1 = true;
val2 = false;
}
}
false
true
false
true
13.4. ! (negao)
Tabela 10: Tabela para o operador !
O operador de negao inverte o resultado lgico de uma expresso, varivel ou constante, ou seja,
o que era verdadeiro ser falso e vice-versa. O programa a seguir, mostra a utilizao deste opera-
dor:
public class TestNOT {
boolean val2 = false;
System.out.println(!val1);
System.out.println(!val2);
}
}
false
true
14. Operador Condicional ( ?: )

O operador condicional tambm chamado de operador ternrio. Isto significa que ele tem 3 argu-
mentos que juntos formam uma nica expresso condicional. A estrutura de uma expresso utilizan-
do um operador condicional a seguinte:
exp1?exp2:exp3
Onde exp1 uma expresso lgica que deve retornar true ou false. Se o valor de exp1 for verdadei-
ro, ento, o resultado ser a expresso exp2, caso contrrio, o resultado ser exp3. O programa a
seguir, mostra a utilizao deste operador:
public class ConditionalOperator {
String status = "";
int grade = 80;
//status do aluno
status = (grade >= 60)?"Passed":"Fail";
//print status
System.out.println( status );
}
}
Passed
Veremos na Figura 2 um fluxograma que demonstra como o operador condicional funciona.
Figura 2: Fluxograma utilizando o operador condicional
Veremos outro programa que tambm utiliza o operador condicional:

public class ConditionalOperator {
int score = 0;
char answer = 'a';
score = (answer == 'a') ? 10 : 0;
System.out.println("Score = " + score );
}
}
Score = 10
15. Precedncia de Operadores

A precedncia serve para indicar a ordem na qual o compilador interpretar os diferentes tiposde
operadores, para que ele sempre tenha como sada um resultado coerente e no ambguo.
Ta-
belTabela 11: Precedncia de operadores
No caso de dois operadores com mesmo nvel de precedncia, ter prioridade o que estivermais
esquerda da expresso. Dada uma expresso complexa como:
6%2*5+4/2+88-10
O ideal seria fazer uso de parnteses para reescrev-la de maneira mais clara:
((6%2)*5)+(4/2)+88-10
Dicas de programao:
1. Para evitar confuso na avaliao de suas expresses matemticas, deixe-as o
mais simples possvel e use parnteses.
16. Exerccios
16.1. Declarar e mostrar variveis
Dada a tabela abaixo, declare as variveis que se seguem de acordo com seus tipos correspondentes
e valores iniciais. Exiba o nomes e valor das variveis.
O resultado esperado do exerccio :

number = 10
letter = a
result = true
str = hello
16.2. Obter a mdia entre trs nmeros
Crie um programa que obtenha a mdia de 3 nmeros. Considere o valor para os trs nmeroscomo
sendo 10, 20 e 45. O resultado esperado do exerccio :
nmero 1 com o valor 10
A mdia 25
16.3. Exibir o maior valor
Dados trs nmeros, crie um programa que exiba na tela o maior dentre os nmeros informados.
Use o operador ?: que j foi estudado nesta sesso (dica: ser necessrio utilizar dois operadores ?:
para se chegar ao resultado). Por exemplo, dados os nmeros 10, 23 e 5, o resultado esperado do
exerccio deve ser:
O maior nmero 23
16.4. Precedncia de operadores
Dadas as expresses abaixo, reescreva-as utilizando parnteses de acordo com a forma comoelas
so interpretadas pelo compilador.
1. a / b ^ c ^ d e + f g * h + i
2. 3 * 10 *2 / 15 2 + 4 ^ 2 ^ 2
3. r ^ s * t / u v + w ^ x y++
Lio 3
1. Objetivos
Agora que j estudamos alguns conceitos bsicos e escrevemos alguns cdigos simples, vamos fazer
as aplicaes ficarem mais interativas comeando com a captura de dados digitados pelo usurio.
Nesta lio, discutiremos trs modos de obter dados de entrada (input). O primeiro atravs do uso
da classe BufferedReader do pacote java.util; o segundo, atravs do uso da nova classe Scanner no
mesmo pacote; e, por fim, envolveremos a utilizao da interface grfica utilizando JOptionPane.

Criar cdigos para a captura de dados pelo teclado.
Usar a classe BufferedReader para captura, atravs de uma janela de console, dos dados digitados
no teclado.
Utilizar a classe Scanner para captura, atravs de uma janela de console, dos dados digitados no
teclado.
Utilizar a classe JOptionPane para captura, atravs da uma interface grfica, dos dados digitados no
teclado.
2. BufferedReader para capturar dados

Primeiramente, utilizaremos a classe BufferedReader do pacote java.io para capturar dados de en-
trada atravs do teclado. Passos para capturar os dados digitados, tomemos por base o programa
visto na lio anterior:
1. Digite a seguinte instruo no incio do programa:
import java.io.*;
2. Adicione as seguintes instrues no corpo do mtodo main:
BufferedReader dataIn = new BufferedReader(
new InputStreamReader(System.in));
3. Declare uma varivel temporria do tipo String para gravar os dados digitados pelo usurio e cha-
me o mtodo readLine() que vai capturar linha por linha do que o usurio digitar.
Isso dever ser escrito dentro de um bloco try-catch para tratar possveis excees.
try {
String temp = dataIn.readLine();
} catch (IOException e) {
System.out.println("Error in getting input");
}
Abaixo, segue o programa completo:
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
public class GetInputFromKeyboard {
BufferedReader dataIn = new BufferedReader(new InputStreamReader(System.in));
String name = "";
System.out.print("Please Enter Your Name:");
try {
name = dataIn.readLine();
System.out.println("Error!");
}
System.out.println("Hello " + name +"!");
}
}
Faremos uma anlise deste programa linha por linha:
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
Estas linhas acima mostram que estamos utilizando as classes BufferedReader, InputStreamReader e
IOException cada qual dentro do pacote java.io. Essas APIs ou Interfaces de Programao de Aplica-
es (Application Programming Interface) contm centenas de classes pr-definidas que se pode
usar nos programas. Essas classes so organizadas dentro do que chamamos de pacotes.
Pacotes contm classes que se relacionam com um determinado propsito. No exemplo, o pacote ja-
va.io contm as classes que permitem capturar dados de entrada e sada. Estas linhas poderiam ser
reescritas da seguinte forma:
import java.io.*;
que importar todas as classes encontradas no pacote java.io, deste modo possvel utilizar todas
classes desse pacote no programa.
As prximas linhas:
j foram discutidas na lio anterior. Isso significa que declaramos uma classe nomeada GetInpu-
tFromKeyboard e, em seguida, iniciamos o mtodo principal (main).
Na instruo:
BufferedReader dataIn = new BufferedReader(new InputStreamReader(System.in));
declaramos a varivel dataIn do tipo BufferedReader. No se preocupe com o significado da sintaxe,

pois ser abordado mais frente.
A seguir, declaramos a varivel name do tipo String:

String name = "";
na qual armazenaremos a entrada de dados digitada pelo usurio. Note que foi inicializada como
uma String vazia "". uma boa prtica de programao inicializar as variveis quando declaradas.
Na prxima instruo, solicitamos que o usurio escreva um nome:

System.out.print("Please Enter Your Name:");
As seguinte linhas definem um bloco try-catch:
try {
System.out.println("Error!");
}
que asseguram, caso ocorram excees sero tratadas. Falaremos sobre o tratamento de excees
na ltima parte deste curso. Por hora, necessrio adicionar essas linhas para utilizar o mtodo
readLine() e receber a entrada de dados do usurio.
Em seguida:
capturamos a entrada dos dados digitados pelo usurio e as enviamos para a varivel String criada
anteriormente. A informao guardada na varivel name.
Como ltima instruo:

System.out.println("Hello " + name + "!");
montamos a mensagem final para cumprimentar o usurio.
3. Classe Scanner para capturar dados

Vimos uma maneira para obter dados de entrada atravs do teclado. O JDK 5.0 lanou uma nova
classe chamada Scanner que engloba diversos mtodos para facilitar este servio.
Abaixo, segue o programa completo utilizando esta classe:

import java.util.Scanner;
public class GetInputFromScanner{
Scanner sc = new Scanner(System.in);
System.out.println("Please Enter Your Name:");
String name = sc.next();
}
}
Compare-o com o programa visto anteriormente. Percebe-se que fica mais simples conseguir ames-
ma funcionalidade. Inicialmente, definimos a chamada ao pacote que contm a classe Scanner:
import java.util.Scanner;
Em seguida, as instrues que define a classe e o mtodo main:

public class GetInputFromScanner{
Definimos uma varivel, denominada sc, que ser criada a partir da classe Scanner e direcionada
para a entrada padro:
Scanner sc = new Scanner(System.in);
De forma semelhante, mostramos uma mensagem solicitando informao do usurio:

System.out.println("Please Enter Your Name:");
Utilizamos a varivel sc para chamarmos o mtodo que far o recebimento dos dados digitados:
String name = sc.nextLine();
A classe Scanner possui diversos mtodos que podem ser utilizados para realizar este servio. Os
principais mtodos que podemos utilizar, neste caso, so:
Mtodo Finalidade
next() Aguarda uma entrada em formato String
nextInt() Aguarda uma entrada em formato Inteiro
nextByte() Aguarda uma entrada em formato Inteiro
nextLong() Aguarda uma entrada em formato Inteiro Longo
nextFloat() Aguarda uma entrada em formato Nmero Fracionrio
nextDouble() Aguarda uma entrada em formato Nmero Fracionrio
Tabela 1: Mtodos da Classe Scanner para obter dados
Por fim, mostramos o resultado e encerramos o mtodo main e a classe:

}
}
4. Utilizando a JOptionPane para receber dados

Um outro modo de receber os dados de entrada utilizar a classe JOptionPane, que pertenceao pa-
cote javax.swing. A JOptionPane possui mtodos que conseguem criar caixas de dilogo na qual o
usurio pode informar ou visualizar algum dado.
Dado o seguinte cdigo:

import javax.swing.JOptionPane;
String name = "";
name = JOptionPane.showInputDialog("Please enter your name");
String msg = "Hello " + name + "!";
JOptionPane.showMessageDialog(null, msg);
}
}
esta classe apresentar o seguinte resultado:

Figura 1: Aguardando dados no JOptionPane Figura 2: Digitando florence no JOptionPane
A primeira instruo:
import javax.swing.JOptionPane;
mostra que estamos importando a classe JOptionPane do pacote javax.swing. Poderamos, de forma
semelhante, escrever estas instrues do seguinte modo:
import javax.swing.*;
A instruo seguinte:
name = JOptionPane.showInputDialog("Please enter your name");
cria uma caixa de entrada que exibir um dilogo com uma mensagem, um campo de texto para re-
ceber os dados do usurio e um boto OK, conforme mostrado na figura 1. O resultado ser arma-
zenado na varivel do tipo String name.
Na prxima instruo, criamos uma mensagem de cumprimento, que ficar armazenada na varivel
msg:
String msg = "Hello " + name + "!";
Finalizando a classe, exibiremos uma janela de dilogo que conter a mensagem e o boto de OK,
conforme mostrado na figura 3.
JOptionPane.showMessageDialog(null, msg);
5. Exerccios
5.1. As 3 palavras (verso Console)
Utilizando a classe BufferedReader ou Scanner, capture trs palavras digitadas pelo usurio e mos-
tre-as como uma nica frase na mesma linha. Por exemplo:
Palavra 1: Goodbye
Palavra 2: and
Palavra 3: Hello
Goodbye and Hello
5.2. As 3 palavras (verso Interface Grfica)
Utilizando a classe JOptionPane, capture palavras em trs caixas de dilogos distintas e mostre-as
como uma nica frase. Por exemplo:
Figura 4: Primeira Palavra Figura 5: Segunda Palavra
Figura 6: Terceira Palavra Figura 7: Mostrando a Mensagem

Lio 4
1. Objetivos
Nas lies anteriores, foram mostrados programas seqenciais, onde as instrues foram executadas
uma aps a outra de forma fixa. Nesta lio, discutiremos estruturas de controle que permitem mu-
dar a ordem na qual as instrues so executadas.

Usar estruturas de controle de deciso (if e switch) que permitem a seleo de partes especficas
do cdigo para execuo
Usar estruturas de controle de repetio (while, do-while e for) que permitem a repetio da exe-
cuo de partes especficas do cdigo
Usar declaraes de interrupo (break, continue e return) que permitem o redirecionamento do
fluxo do programa
2. Estruturas de controle de deciso

Estruturas de controle de deciso so instrues em linguagem Java que permitem que blocos espe-
cficos de cdigo sejam escolhidos para serem executados, redirecionando determinadas partes do
fluxo do programa.
2.1. Declarao if
A declarao if especifica que uma instruo ou bloco de instrues seja executado se, esomente se,
uma expresso lgica for verdadeira. A declarao if possui a seguinte forma:
if (expresso_lgica)
instruo;
ou:
if (expresso_lgica) {
instruo1;
instruo2
...
}
onde, expresso_lgica representa uma expresso ou varivel lgica.

Figura 1: Fluxograma da declarao
If
Por exemplo, dado o trecho de cdigo:

int grade = 68;
if (grade > 60) System.out.println("Congratulations!");
ou:
int grade = 68;
if (grade > 60) {
System.out.println("Congratulations!");
System.out.println("You passed!");
}
Dicas de programao:
1. Expresso lgica uma declarao que possui um valor lgico. Isso significa que a execuo
desta expresso deve resultar em um valor true ou false.
2. Coloque as instrues de forma que elas faam parte do bloco if. Por exemplo:
// instruo1;
// instruo2;
}
2.2. Declarao if-else
A declarao if-else usada quando queremos executar determinado conjunto de instruesse a

condio for verdadeira e outro conjunto se a condio for falsa.
Possui a seguinte forma:

if (expresso_lgica)
instruo_caso_verdadeiro;
else
instruo_caso_falso;
Tambm podemos escrev-la na forma abaixo:

instruo_caso_verdadeiro1;
instruo_caso_verdadeiro2;
...
} else {
instruo_caso_falso1;
instruo_caso_falso2;
...
}

int grade = 68;
if (grade > 60)
System.out.println("Congratulations! You passed!");
else
System.out.println("Sorry you failed");
ou:
int grade = 68;
if (grade > 60) {
System.out.print("Congratulations! ");
System.out.println("You passed!");
} else {
System.out.print("Sorry ");
System.out.println("you failed");
}
Figura 2: Fluxograma da declarao if-else
Dicas de programao:
1. Para evitar confuso, sempre coloque a instruo ou instrues contidas no bloco if ou if-else
entre chaves {}.
2. Pode-se ter declaraes if-else dentro de declaraes if-else, por exemplo:
...
} else {
...
}
} else {
...
}
2.3. Declarao if-else-if
A declarao else pode conter outra estrutura if-else. Este cascateamento de estruturaspermite ter
decises lgicas muito mais complexas.
A declarao if-else-if possui a seguinte forma:

if (expresso_lgica1)
instruo1;
else if(expresso_lgica2)
instruo2;
else
instruo3;
Podemos ter vrias estruturas else-if depois de uma declarao if. A estrutura else opcional e
pode ser omitida. No exemplo mostrado acima, se a expresso_lgica1 verdadeira, o programa
executa a instruo1 e salta as outras instrues. Caso contrrio, se a expresso_lgica1 falsa, o
fluxo de controle segue para a anlise da expresso_lgica2.
Se esta for verdadeira, o programa executa a instruo2 e salta a instruo3. Caso contrrio, se a
expresso_lgica2 falsa, ento a instruo3 executada.
Figura 3: Fluxograma da declarao if-else-if
Observe um exemplo da declarao if-else-if no seguinte trecho de cdigo:

public class Grade {
double grade = 92.0;
if (grade >= 90) {
System.out.println("Excellent!");
} else if((grade < 90) && (grade >= 80)) {
System.out.println("Good job!");
} else if((grade < 80) && (grade >= 60)) {
System.out.println("Study harder!");
} else {
System.out.println("Sorry, you failed.");
}
}
}
2.4. Erros comuns na utilizao da declarao if
1. A condio na declarao if no avalia um valor lgico. Por exemplo:

// ERRADO
int number = 0;
if (number) {
// algumas instrues aqui
}
a varivel number no tem valor lgico.
2. Usar = (sinal de atribuio) em vez de == (sinal de igualdade) para comparao. Por exemplo:
// ERRADO
int number = 0;
if (number = 0) {
}
3. Escrever elseif em vez de else if.

// ERRADO
int number = 0;
if (number == 0) {
} elseif (number == 1) {
}
2.5. Declarao switch
Outra maneira de indicar uma condio atravs de uma declarao switch. A construo switch
permite que uma nica varivel inteira tenha mltiplas possibilidades de finalizao.
A declarao switch possui a seguinte forma:

switch (varivel_inteira) {
case valor1:
instruo1; //
instruo2; // bloco 1
... //
break;
case valor2:
instruo1; //
instruo2; // bloco 2
... //
break;
default:
instruo1; //
instruo2; // bloco n
... //
break;
}
onde, varivel_inteira uma varivel de tipo byte, short, char ou int. valor1, valor2, e assim por
diante, so valores constantes que esta varivel pode assumir.
Quando a declarao switch encontrada, o fluxo de controle avalia inicialmente a varivel_inteira e

segue para o case que possui o valor igual ao da varivel. O programa executa todas instrues a
partir deste ponto, mesmo as do prximo case, at encontrar uma instruo break, que interrompe-
r a execuo do switch.
Se nenhum dos valores case for satisfeito, o bloco default ser executado. Este um bloco opcional.
O bloco default no obrigatrio na declarao switch.
Notas:
1. Ao contrrio da declarao if, mltiplas instrues so executadas sem a necessidade das cha-
ves que determinam o incio e trmino de bloco {}.
2. Quando um case for selecionado, todas as instrues vinculadas ao case sero executadas.
Alm disso, as instrues dos case seguintes tambm sero executadas.
3. Para prevenir que o programa execute instrues dos outros case subseqentes, utilizamos a
declarao break aps a ltima instruo de cada case.
Dicas de Programao:
1. A deciso entre usar uma declarao if ou switch subjetiva. O programador pode decidir com
base na facilidade de entendimento do cdigo, entre outros fatores.
2. Uma declarao if pode ser usada para decises relacionadas a conjuntos, escalas de variveis
ou condies, enquanto que a declarao switch pode ser utilizada para situaes que envolvam
varivel do tipo inteiro. Tambm necessrio que o valor de cada clusula case seja nico.
Figura 4: Fluxograma da declarao switch
2.6. Exemplo para switch

public class Grade {
int grade = 92;
switch(grade) {
case 100:
System.out.println("Excellent!");
break;
case 90:
System.out.println("Good job!");
break;
case 80:
System.out.println("Study harder!");
break;
default:
System.out.println("Sorry, you failed.");
}
}
}
Compile e execute o programa acima e veremos que o resultado ser:
Sorry, you failed.
pois a varivel grade possui o valor 92 e nenhuma das opes case atende a essa condio. Note
que para o caso de intervalos a declarao if-else-if mais indicada.
3. Estruturas de controle de repetio

Estruturas de controle de repetio so comandos em linguagem Java que permitem executar partes
especficas do cdigo determinada quantidade de vezes. Existem 3 tipos de estruturas de controle de
repetio: while, do-while e for.
3.1. Declarao while
A declarao while executa repetidas vezes um bloco de instrues enquanto uma determinada con-
dio lgica for verdadeira.
A declarao while possui a seguinte forma:

while (expresso_lgica) {
instruo1;
instruo2;
...
}
Figura 5: Fluxograma da declarao while
As instrues contidas dentro do bloco while so executadas repetidas vezes enquanto o valorde ex-
presso_lgica for verdadeira.

int i = 4;
while (i > 0){
System.out.print(i);
i--;
}
O cdigo acima ir imprimir 4321 na tela. Se a linha contendo a instruo i-- for removida,teremos
uma repetio infinita, ou seja, um cdigo que no termina. Portanto, ao usar laos while, ou qual-
quer outra estrutura de controle de repetio, tenha a certeza de utilizar uma estrutura de repetio
que encerre em algum momento.
Abaixo, temos outros exemplos de declaraes while:
Exemplo 1:
int x = 0;
while (x<10) {
System.out.println(x);
x++;
}
Exemplo 2:
// lao infinito
while (true)
System.out.println("hello");
Exemplo 3:
// a instruo do lao no ser executada
while (false)
3.2. Declarao do-while
A declarao do-while similar ao while. As instrues dentro do lao do-while sero executadas
pelo menos uma vez.
A declarao do-while possui a seguinte forma:

do {
instruo1;
instruo2;
...
} while (expresso_lgica);
Figura 6: Fluxograma da declarao do-while
Inicialmente, as instrues dentro do lao do-while so executadas. Ento, a condio naexpres-

so_lgica avaliada. Se for verdadeira, as instrues dentro do lao do-while sero executadas
novamente. A diferena entre uma declarao while e do-while que, no lao while, a avaliao da
expresso lgica feita antes de se executarem as instrues nele contidas enquanto que, no lao
do-while, primeiro se executam as instrues e depois realiza-se a avaliao da expresso lgica,
ou seja, as instrues dentro em um lao do-while so executadas pelo menos uma vez.
Abaixo, temos alguns exemplos que usam a declarao do-while:
Exemplo 1:
int x = 0;
do {
System.out.println(x);
x++;
} while (x<10);
Este exemplo ter 0123456789 escrito na tela.
Exemplo 2:
// lao infinito
do {
} while(true);
Este exemplo mostrar a palavra hello escrita na tela infinitas vezes.
Exemplo 3:
// Um lao executado uma vez
do
System.out.println(hello);
while (false);
Este exemplo mostrar a palavra hello escrita na tela uma nica vez.
Dicas de programao:
1. Erro comum de programao ao utilizar o lao do-while esquecer o ponto-evrgula
(;) aps a declarao while.
do {
...
} while (boolean_expression) // ERRADO -> faltou ;
2. Como visto para a declarao while, tenha certeza que a declarao do-while
poder terminar em algum momento.
3.3. Declarao for
A declarao for, como nas declaraes anteriores, permite a execuo do mesmo cdigo uma quan-
tidade determinada de vezes.
A declarao for possui a seguinte forma:
for (declarao_inicial; expresso_lgica; salto) {
instruo1;
instruo2;
...
}
onde:
declarao_inicial inicializa uma varivel para o lao
expresso_lgica compara a varivel do lao com um valor limite
salto atualiza a varivel do lao
Figura 7: Fluxograma da declarao for
Um exemplo para a declarao for :

for (int i = 0; i < 10; i++) {
}
Neste exemplo, uma varivel i, do tipo int, inicializada com o valor zero. A expresso lgica "i
menor que 10" avaliada. Se for verdadeira, ento a instruo dentro do lao executada. Aps
isso, a expresso i ter seu valor adicionado em 1 e, novamente, a condio lgica ser avaliada.
Este processo continuar at que a condio lgica tenha o valor falso.
Este mesmo exemplo, utilizando a declarao while, mostrado abaixo:

int i = 0;
while (i < 10) {
i++;
}
4. Declaraes de Interrupo
Declaraes de interrupo permitem que redirecionemos o fluxo de controle do programa. A lingua-
gem Java possui trs declaraes de interrupo. So elas: break, continue e return.
4.1. Declarao break
A declarao break possui duas formas: unlabeled (no identificada - vimos esta forma com a decla-
rao switch) e labeled (identificada).
4.1.1. Declarao unlabeled break
A forma unlabeled de uma declarao break encerra a execuo de um switch e o fluxo de controle
transferido imediatamente para o final deste. Podemos tambm utilizar a forma para terminar de-
claraes for, while ou do-while.
Por exemplo:
String names[] = {"Beah", "Bianca", "Lance", "Belle",
"Nico", "Yza", "Gem", "Ethan"};
String searchName = "Yza";
boolean foundName = false;
for (int i=0; i < names.length; i++) {
if (names[i].equals(searchName)) {
foundName = true;
break;
}
}
if (foundName) {
System.out.println(searchName + " found!");
} else {
System.out.println(searchName + " not found.");
}
Neste exemplo, se a String Yza for encontrada, a declarao for ser interrompida e o controle do
programa ser transferido para a prxima instruo abaixo da declarao for.
4.1.2. Declarao labeled break
A forma labeled de uma declarao break encerra o processamento de um lao que identificado
por um label especificado na declarao break.
Um label, em linguagem Java, definido colocando-se um nome seguido de dois-pontos, como por
exemplo:
teste:
esta linha indica que temos um label com o nome teste.
O programa a seguir realiza uma pesquisa de um determinado valor em um array bidimensional.

Dois laos so criados para percorrer este array. Quando o valor encontrado, um labeled break
termina a execuo do lao interno e retorna o controle para o lao mais externo.
int[][] numbers = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
int searchNum = 5;
boolean foundNum = false;
searchLabel: for (int i=0; i<numbers.length; i++) {
for (int j=0; j<numbers[i].length; j++) {
if (searchNum == numbers[i][j]) {
foundNum = true;
break searchLabel;
}
} // final do lao j
} // final do lao i
if (foundNum) {
System.out.println(searchNum + " found!");
} else {
System.out.println(searchNum + " not found!");
}
A declarao break, ao terminar a declarao for, no transfere o controle do programa aofinal de

seu lao, controlado pela varivel j. O controle do programa segue imediatamente para a declarao
for marcada com o label, neste caso, interrompendo o lao controlado pela varivel i.
4.2. Declarao continue
A declarao continue tem duas formas: unlabeled e labeled. Utilizamos uma declarao continue
para saltar a repetio atual de declaraes for, while ou do-while.
4.2.1. Declarao unlabeled continue
A forma unlabeled salta as instrues restantes de um lao e avalia novamente a expresso lgica
que o controla.
O exemplo seguinte conta a quantidade de vezes que a expresso "Beah" aparece no array.
String names[] = {"Beah", "Bianca", "Lance", "Beah"};
int count = 0;
for (int i=0; i < names.length; i++) {
if (!names[i].equals("Beah")) {
continue; // retorna para a prxima condio
}
count++;
}
System.out.println(count + " Beahs in the list");
4.2.2. Declarao labeled continue

A forma labeled da declarao continue interrompe a repetio atual de um lao e salta para a repe-
tio exterior marcada com o label indicado.
outerLoop: for (int i=0; i<5; i++) {
for (int j=0; j<5; j++) {
System.out.println("Inside for(j) loop"); // mensagem1
if (j == 2)
continue outerLoop;
}
System.out.println("Inside for(i) loop"); // mensagem2
}
Neste exemplo, a mensagem 2 nunca ser mostrada, pois a declarao continue outerloop inter-
romper este lao cada vez que j atingir o valor 2 do lao interno.
4.3. Declarao return
A declarao return utilizada para sair de um mtodo. O fluxo de controle retorna para a declara-
o que segue a chamada do mtodo original. A declarao de retorno possui dois modos: o que re-
torna um valor e o que no retorna nada.
Para retornar um valor, escreva o valor (ou uma expresso que calcula este valor) depois da palavra
chave return. Por exemplo:
return ++count;
ou
return "Hello";
Os dados so processados e o valor devolvido de acordo com o tipo de dado do mtodo. Quando
um mtodo no tem valor de retorno, deve ser declarado como void. Use a forma de return que no
devolve um valor. Por exemplo:
return;
Abordaremos as declaraes return nas prximas lies, quando falarmos sobre mtodos.
5. Exerccios
5.1. Notas
Obtenha do usurio trs notas de exame e calcule a mdia dessas notas. Reproduza a mdia dos
trs exames. Junto com a mdia, mostre tambm um :-) no resultado se a mdia for maior ou igual
a 60; caso contrrio mostre :-(
Faa duas verses deste programa:

1. Use a classe BufferedReader (ou a classe Scanner) para obter as notas do usurio, e System.out
para mostrar o resultado.
2. Use JOptionPane para obter as notas do usurio e para mostrar o resultado.
5.2. Nmero por Extenso
Solicite ao usurio para digitar um nmero, e mostre-o por extenso. Este nmero dever variar en-
tre 1 e 10. Se o usurio introduzir um nmero que no est neste intervalo, mostre:
"nmero invlido".
Faa duas verses deste programa:
1. Use uma declarao if-else-if para resolver este problema
2. Use uma declarao switch para resolver este problema
5.3. Cem vezes
Crie um programa que mostre seu nome cem vezes. Faa trs verses deste programa:
1. Use uma declarao while para resolver este problema
2. Use uma declarao do-while para resolver este problema
3. Use uma declarao for para resolver este problema
5.4. Potncias
Receba como entrada um nmero e um expoente. Calcule este nmero elevado ao expoente.
Faa trs verses deste programa:
1. Use uma declarao while para resolver este problema
2. Use uma declarao do-while para resolver este problema
3. Use uma declarao for para resolver este problema

Lio 5
1. Objetivos
Nesta lio, abordaremos Array em Java. Primeiro, definiremos o que array e, ento, discutiremos
como declar-los e us-los.

Declarar e criar array
Acessar elementos de um array
Determinar o nmero de elementos de um array
Declarar e criar array multidimensional
2. Introduo a Array
Em lies anteriores, discutimos como declarar diferentes variveis usando os tipos de dados primiti-
vos. Na declarao de variveis, freqentemente utilizamos um identificador ou um nome e um tipo
de dados. Para se utilizar uma varivel, deve-se cham-la pelo nome que a identifica.
Por exemplo, temos trs variveis do tipo int com diferentes identificadores para cada varivel:
int number1;
int number2;
int number3;
number1 = 1;
number2 = 2;
number3 = 3;
Como se v, inicializar e utilizar variveis pode torna-se uma tarefa tediosa, especialmente se elas
forem utilizadas para o mesmo objetivo. Em Java, e em outras linguagens de programao, pode-se
utilizar uma varivel para armazenar e manipular uma lista de dados com maior eficincia. Este tipo
de varivel chamado de array.
Um array armazena mltiplos itens de um mesmo tipo de dado em um bloco contnuo de memria,
dividindo-o em certa quantidade de posies. Imagine um array como uma varivel esticada que
tem um nome que a identifica e que pode conter mais de um valor para esta mesma varivel.
Figura 1: Exemplo de um array de inteiros
3. Declarando Array
Array precisa ser declarados como qualquer varivel. Ao declarar
um array, defina o tipo de dados deste seguido por colchetes []
e pelo nome que o identifica. Por exemplo:
int [] ages;
ou colocando os colchetes depois do identificador. Por exemplo:

int ages[];
Depois da declarao, precisamos criar o array e especificar seu

tamanho. Este processo chamado de construo (a palavra,
em orientao a objetos, para a criao de objetos). Para se construir um objeto, precisamos utilizar
um construtor. Por exemplo:
// declarao
int ages[];
// construindo
ages = new int[100];
ou, pode ser escrito como:

// declarar e construir
int ages[] = new int[100];
No exemplo, a declarao diz ao compilador Java que o identificador ages ser usado comoum
nome de um array contendo inteiros, usadopara criar, ou construir, um novo array contendo 100 ele-
mentos.
Em vez de utilizar uma nova linha de instruo para construir um array, tambm possvel automa-
ticamente declarar, construir e adicionar um valor uma nica vez.
Exemplos:
// criando um array de valores lgicos em uma varivel
// results. Este array contm 4 elementos que so
// inicializados com os valores {true, false, true, false}
boolean results[] ={ true, false, true, false };
// criando um array de 4 variveis double inicializados

// com os valores {100, 90, 80, 75};
double []grades = {100, 90, 80, 75};
// criando um array de Strings com identificador days e

// tambm j inicializado. Este array contm 7 elementos
String days[] = {"Mon","Tue","Wed","Thu","Fri","Sat","Sun"};
Uma vez que tenha sido inicializado, o tamanho de um array no pode ser modificado, pois arma-
zenado em um bloco contnuo de memria.
4. Acessando um elemento do Array

Para acessar um elemento do array, ou parte de um array, utiliza-se um nmero inteirochamado de
ndice.Um ndice atribudo para cada membro de um array, permitindo ao programa e ao progra-
mador acessar os valores individualmente quando necessrio. Os nmeros dos ndices so sempre
inteiros. Eles comeam com zero e progridem seqencialmente por todas as posies at o fim do
array. Lembre-se que os elementos dentro do array possuem ndice de 0 a tamanhoDoArray-1.
Por exemplo, dado o array ages que declaramos anteriormente, temos:

// atribuir 10 ao primeiro elemento do array
ages[0] = 10;
// imprimir o ltimo elemento do array

System.out.print(ages[99]);
Lembre-se que o array, uma vez declarado e construdo, ter o valor de cada membro
inicializado automaticamente. Conforme a seguinte tabela:
Tipo primitivo Iniciado com
boolean false
byte, short e int 0

char '\u0000'
long 0L
float 0.0F
double 0.0
Tabela 1: Valor de inicializao automatica para os tipos primitivos
Entretanto, tipos de dados por referncia, como as Strings, no sero inicializados caracteres em
branco ou com uma string vazia "", sero inicializados com o valor null. Deste modo, o ideal pre-
encher os elementos do arrays de forma explcita antes de utiliz-los. A manipulao de objetos nu-
los pode causar a desagradvel surpresa de uma exceo do tipo NullPointerException, por exem-
plo, ao tentar executar algum mtodo da classe String, conforme o exemplo a seguir:
public class ArraySample {
public static void main(String[] args){
String [] nulls = new String[2];
System.out.print(nulls[0]); // Linha correta, mostra null
System.out.print(nulls[1].trim()); // Causa erro
}
}
O cdigo abaixo utiliza uma declarao for para mostrar todos os elementos de um array.
public static void main(String[] args){
int[] ages = new int[100];
for (int i = 0; i < 100; i++) {
System.out.print(ages[i]);
}
}
}
Dicas de programao:
1. Normalmente, melhor inicializar, ou instanciar, um array logo aps declar-lo.
Por exemplo, a instruo:
int []arr = new int[100];
prefervel, ao invs de:
int [] arr;
arr = new int[100];
2. Os elementos de um array de n elementos tem ndices de 0 a n-1. Note que no existe o ele-
mento arr[n]. A tentativa de acesso a este elemento causar uma exceo do tipo ArrayIndexOu-
tOfBoundsException, pois o ndice deve ser at n-1.
3. No possvel modificar o tamanho de um array.
5. Tamanho do Array
Para se obter o nmero de elementos de um array, pode-se utilizar o atributo length. O atributo
length de um array retorna seu tamanho, ou seja, a quantidade de elementos. utilizado como no
cdigo abaixo:
nomeArray.length
Por exemplo, dado o cdigo anterior, podemos reescrev-lo como:

public static void main (String[] args) {
int[] ages = new int[100];
for (int i = 0; i < ages.length; i++) {
System.out.print(ages[i]);
}
}
}
Dicas de programao:
1. Quando criar laos com for para o processamento de um array, utilize o campo length como ar-
gumento da expresso lgica. Isto ir permitir ao lao ajustarse, automaticamente para tamanhos
de diferentes arrays.
2. Declare o tamanho dos arrays utilizando variveis do tipo constante para facilitar alteraes
posteriores. Por exemplo:
final int ARRAY_SIZE = 1000; // declarando uma constante
...
int[] ages = new int[ARRAY_SIZE];
6. Arrays Multidimensionais
Arrays multidimensionais so implementados como arrays dentro de arrays. So declarados ao atri-
buir um novo conjunto de colchetes depois do nome do array. Por exemplo:
// array inteiro de 512 x 128 elementos
int [][] twoD = new int[512][128];
// array de caracteres de 8 x 16 x 24
char [][][] threeD = new char[8][16][24];
// array de String de 4 linhas x 2 colunas
String [][] dogs = {{"terry", "brown"},
{"Kristin", "white"},
{"toby", "gray"},
{"fido", "black"}};
Acessar um elemento em um array multidimensional semelhante a acessar elementos em
um array de uma dimenso. Por exemplo, para acessar o primeiro elemento da primeira linha
do array dogs, escreve-se:

System.out.print(dogs[0][0]);
Isso mostrar a String "terry" na sada padro. Caso queira mostrar todos os elementos deste array,
escreve-se:
for (int i = 0; i < dogs.length; i++) {
for (int j = 0; j < dogs[i].length; j++) {
System.out.print(dogs[i][j] + " ");
}
}
7. Exerccios
7.1. Dias da semana
Criar um array de Strings inicializado com os nomes dos sete dias da semana. Por exemplo: String
days[] = {"Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday",
"Sunday"};
Usando uma declarao while, imprima todo o contedo do array. Faa o mesmo para as declara-
es do-while e for.
7.2. Maior nmero
Usando as classes BufferedReader, Scanner ou JOptionPane, solicite 10 nmeros ao usurio. Utilize

um array para armazenar o valor destes nmeros. Mostre o nmero de maior valor.
7.3. Entradas de agenda telefnica

Dado o seguinte array multidimensional, que contm as entradas da agenda telefnica:
String entry = {{"Florence", "735-1234", "Manila"},
{"Joyce", "983-3333", "Quezon City"},
{"Becca", "456-3322", "Manila"}};
mostre-as conforme o formato abaixo:

Name : Florence
Tel. # : 735-1234
Address: Manila
Name : Joyce
Tel. # : 983-3333
Address: Quezon City
Name : Becca
Tel. # : 456-3322
Address: Manila
Lio 6
1. Objetivos
Nesta lio, aprenderemos sobre como processar a entrada que vem da linha de comando usando
argumentos passados para um programa feito em Java.

Utilizar o argumento de linha de comando
Receber dados enviados pelo usurio utilizando os argumentos de linha de comando
Aprender como passar argumentos para os programas no NetBeans
2. Argumentos de linha de comando

Uma aplicao em Java aceita qualquer quantidade de argumentos passados pela linha decomando.
Argumentos de linha de comando permitem ao usurio modificar a operao de uma aplicao a
partir de sua execuo. O usurio insere os argumentos na linha de comando no momento da execu-
o da aplicao. Deve-se lembrar que os argumentos de linha de comando so especificados depois
do nome da classe a ser executada.
Por exemplo, suponha a existncia de uma aplicao Java, chamada Sort, que ordena cinco nmeros
que sero recebidos. Essa aplicao seria executada da seguinte maneira:
java Sort 5 4 3 2 1
Lembre-se que os argumentos so separados por espaos. Em linguagem Java, quando uma aplica-
o executada, o sistema repassa os argumentos da linha de comando para a o mtodo main da
aplicao atravs de um array de String. Cada elemento deste array conter um dos argumentos de
linha de comando passados. Lembre-se da declarao do mtodo main:
}
Os argumento que so passados para o programa so salvos em um array de String com o identifi-
cador args. No exemplo anterior, os argumentos de linha de comando passados para a aplicao
Sort estaro em um array que conter cinco strings: "5", "4", "3", "2" e "1". possvel conhecer o
nmero de argumentos passados pela linha de comando utilizando-se o atributo length do array.
Por exemplo:
int numberOfArgs = args.length;
Se o programa precisa manipular argumento de linha de comando numrico, ento, deve-se conver-
ter o argumento do tipo String, que representa um nmero, assim como "34", para um nmero.
Aqui est a parte do cdigo que converte um argumento de linha de comando para
inteiro:
int firstArg = 0;
if (args.length > 0) {
firstArg = Integer.parseInt(args[0]);
}
parseInt dispara uma exceo do tipo NumberFormatException se o contedo do elemento arg[0]

no for um nmero.
Dicas de programao:
1. Antes de usar os argumentos de linha de comando, observe a quantidade de argumentos passa-

dos para a aplicao. Deste modo, nenhuma exceo ser disparada.
3. Argumentos de linha de comando no NetBeans

Para ilustrar a passagem de alguns argumentos para um projeto no NetBeans, vamos criar um pro-
jeto em Java que mostrar na tela o nmero de argumentos e o primeiro argumento passado.
public class CommandLineExample {
System.out.println("Number of arguments=" +
args.length);
System.out.println("First Argument="+ args[0]);
}
}
Abra o NetBeans, crie um novo projeto e d o nome de CommandLineExample. Copie o cdigo mos-
trado anteriormente e o compile. Em seguida, siga estas etapas para passar argumentos para o pro-
grama, utilizando o NetBeans.
Figura 1: Abrindo o projeto
D um clique com o boto direito do mouse no cone CommandLineExample, conformedestacado na

Figura 1. Um menu aparecer, conforme a Figura 2. Selecione a opo "Properties".
Figura 2: Abrindo a janela de propriedades
A janela "Project Properties" ir aparecer, conforme a Figura 3.

Figura 3: Janela de propriedades
Acesse a opo Run Running Project.
Figura 4: Acessando atravs de Running Project
Na caixa de texto dos argumentos, digite os argumentos que se quer passar para o programa.
Neste caso, digitamos os argumentos 5 4 3 2 1. Pressione o boto OK.

Figura 5: Salvando os Argumentos de Linha de Comando
Execute o projeto.
Figura 6: Executando o programa com boto de atalho
Como pode-se ver, a sada do projeto a quantidade de argumentos, que 5, e o primeiro
argumento passado, que tambm 5.

Figura 7: Sada do Programa
4. Exerccios
4.1. Argumentos de Exibio
Utilizando os dados passados pelo usurio atravs dos argumentos de linha de comando, exiba
os argumentos recebidos. Por exemplo, se o usurio digitar:

java Hello world that is all
o programa dever mostrar na tela:

world
that
is
all
4.2. Operaes aritmticas
Obtenha dois nmeros, passados pelo usurio usando argumentos de linha de comando, e
mostre o resultado da soma, subtrao, multiplicao e diviso destes nmeros. Por exemplo,
se o usurio digitar:
java ArithmeticOperation 20 4
o programa dever mostrar na tela:

sum = 24
subtraction = 16
multiplication = 80
division = 5
Lio 7
1. Objetivos
Nesta lio, abordaremos alguns conceitos bsicos da Programao Orientada a Objetos ou POO.
Mais adiante, discutiremos o conceito de classes e objetos e como usar as classes e seus membros.
Comparao, converso e casting de objetos, tambm sero vistos. Por enquanto, o foco ser o uso
das classes j definidas nas bibliotecas Java e, posteriormente, discutiremos como criar nossas pr-
prias classes.

Explicar o que Programao Orientada a Objetos e alguns dos seus conceitos
Diferenciar entre classes e objetos
Diferenciar atributos e mtodos de objeto de atributos e mtodos de classe
Explicar o que so mtodos, como invoc-los e como enviar argumentos
Identificar o escopo de um atributo
Realizar converses entre tipos de dados primitivos e entre objetos
Comparar objetos e determinar suas classes
2. Introduo Programao Orientada a Objeto

Programao Orientada a Objetos (POO) refere-se ao conceito de objetos como elemento bsico das
classes. O mundo fsico constitudo por objetos tais como carro, leo, pessoa, dentre outros. Estes
objetos so caracterizados pelas suas propriedades (ou atributos) e seus comportamentos.
Por exemplo, um objeto "carro" tem as propriedades, tipo de cmbio, fabricante e cor. O seu com-
portamento pode ser 'virar', 'frear' e 'acelerar'. Igualmente, podemos definir diferentes propriedades
e comportamentos para um leo. Veja exemplos na Tabela 1.
Objetos Propriwedades Comportamentos

carro tipo de cmbio virar
fabricante frear
cor acelerar
Leo peso rugir
cor dormir
apetite (faminto ou saciado) caar
temperamento (dcil ou selvagem)
Tabela 1: Exemplos de objetos do mundo real
Com tais descries, os objetos do mundo fsico podem ser facilmente modelados como objetos de
software usando as propriedades como atributos e os comportamentos como mtodos. Estes atri-
butos e mtodos podem ser usados em softwares de jogos ou interativos para simular objetos do
mundo real! Por exemplo, poderia ser um objeto de 'carro' numa competio de corrida ou um obje-
to de 'leo' num aplicativo educacional de zoologia para crianas.
3. Classes e Objetos
3.1. Diferenas entre Classes e Objetos
No mundo do computador, um objeto um componente de software cuja estrutura similar a um

objeto no mundo real. Cada objeto composto por um conjunto de atributos (propriedades) que
so as variveis que descrevem as caractersticas essenciais do objeto e, consiste tambm, num
conjunto de mtodos (comportamentos) que descrevem como o objeto se comporta. Assim, um ob-
jeto uma coleo de atributos e mtodos relacionados. Os atributos e mtodos de um objeto Java
so formalmente conhecidos como atributos e mtodos de objeto, para distinguir dos atributos e
mtodos de classes, que sero discutidos mais adiante.
A classe a estrutura fundamental na Programao Orientada a Objetos. Ela pode ser pensada
como um gabarito, um prottipo ou, ainda, uma planta para a construo de um objeto. Ela consiste
em dois tipos de elementos que so chamados atributos (ou propriedades) e mtodos. Atributos es-
pecificam os tipos de dados definidos pela classe, enquanto que os mtodos especificam as opera-
es. Um objeto uma instncia de uma classe.
Para diferenciar entre classes e objetos, vamos examinar um exemplo. O que temos aqui uma
classe Carro que pode ser usada pra definir diversos objetos do tipo carro. Na tabela mostrada abai-
xo, Carro A e Carro B so objetos da classe Carro. A classe tem os campos nmero da placa, cor, fa-
bricante e velocidade que so preenchidos com os valores correspondentes do carro A e B. O carro
tambm tem alguns mtodos: acelerar, virar e frear.
Tabela 2: Exemplos da classe Carro e seus objetos
Quando construdos, cada objeto adquire um conjunto novo de estado. Entretanto, as implementa-
es dos mtodos so compartilhadas entre todos os objetos da mesma classe. As classes fornecem
o benefcio do Reutilizao de Classes (ou seja, utilizar a mesma classe em vrios projetos). Os pro-
gramadores de software podem reutilizar as classes vrias vezes para criar os objetos.
3.2. Encapsulamento
Encapsulamento um princpio que prope ocultar determinados elementos de uma classe das de-
mais classes. Ao colocar uma proteo ao redor dos atributos e criar mtodos para prover o acesso a
estes, desta forma estaremos prevenindo contra os efeitos colaterais indesejados que podem afet-
los ao ter essas propriedades modificadas de forma inesperada.
Podemos prevenir o acesso aos dados dos nossos objetos declarando que temos controle desse
acesso. Aprenderemos mais sobre como Java implementa o encapsulamento quando discutirmos
mais detalhadamente sobre as classes.
3.3. Atributos e Mtodos de Classe
Alm dos atributos de objeto, tambm possvel definir atributos de classe, que so atributos que
pertencem classe como um todo. Isso significa que possuem o mesmo valor para todos os objetos
daquela classe. Tambm so chamados de atributos estticos.
Para melhor descrever os atributos de classe, vamos voltar ao exemplo da classe Carro. Suponha
que a classe Carro tenha um atributo de classe chamado Contador. Ao mudarmos o valor de Conta-
dor para 2, todos os objetos da classe Carro tero o valor 2 para seus atributos Contador.
Tabela 3: Atributos e mtodos da classe Carro
3.4 Instncia de Classe
Para criar um objeto ou uma instncia da classe, utilizamos o operador new. Por exemplo, para criar
uma instncia da classe String, escrevemos o seguinte cdigo:
String str2 = new String("Hello world!");
ou, o equivalente:
String str2 = "Hello world!";
O operador new aloca a memria para o objeto e retorna uma referncia para essa alocao. Ao
criar um objeto, invoca-se, na realidade, o construtor da classe. O construtor um mtodo onde to-
das as inicializaes do objeto so declaradas e possui o mesmo nome da classe.
Figura 1: Instanciao de uma classe
4. Mtodos
4.1. O que so mtodos e porque usar mtodos?
Nos exemplos apresentados anteriormente, temos apenas um mtodo, o mtodo main(). Em Java,
ns podemos definir vrios mtodos e podemos cham-los a partir de outros mtodos. Um mtodo
um trecho de cdigo distinto que pode ser chamado por qualquer outro mtodo para realizar alguma
funo especfica.
Mtodos possuem as seguintes caractersticas:

Podem ou no retornar um valor;
Podem aceitar ou no argumentos;
Aps o mtodo encerrar sua execuo, o fluxo de controle retornado a quem o chamou.
O que necessrio para se criar mtodos? Porque no colocamos todas as instrues dentro de um
grande mtodo? O foco destas questes chamado de decomposio. Conhecido o problema, ns o
separamos em partes menores, que torna menos crtico o trabalho de escrever grandes classes.
4.2. Chamando Mtodos de Objeto e Enviando Argumentos
Para ilustrar como chamar os mtodos, utilizaremos como exemplo a classe String. Pode-se usar a
documentao da API Java para conhecer todos os atributos e mtodos disponveis na classe String.
Posteriormente, iremos criar nossos prprios mtodos.
Para chamar um mtodo a partir de um objeto, escrevemos o seguinte:

nomeDoObjeto.nomeDoMtodo([argumentos]);
Vamos pegar dois mtodos encontrados na classe String como exemplo:
Declarao do mtodo Definio
public char charAt(int index)

Retorna o caractere especificado no ndice.
Um ndice vai de 0 at length() - 1. O primeiro caractere da seqncia est no ndice 0, o seguinte,

no ndice 1, e assim sucessivamente por todo o array.
public boolean equalsIgnoreCase (String anotherString)
Compara o contedo de duas Strings, ignorando maisculas e minsculas. Duas strings so conside-
radas iguais quando elas tm o mesmo tamanho e os caracteres das duas strings so iguais, sem
considerar caixa alta ou baixa.
Tabela 4: Exemplos de Mtodos da classe String
Usando os mtodos:
String str1 = "Hello";
char x = str1.charAt(0); // retornar o caracter H
// e o armazenar no atributo x
String str2 = "hello";
// aqui ser retornado o valor booleano true

boolean result = str1.equalsIgnoreCase(str2);
4.3. Envio de Argumentos para Mtodos
Em exemplos anteriores, enviamos atributos para os mtodos. Entretanto, no fizemos nenhuma

distino entre os diferentes tipos de atributos que podem ser enviados como argumento para os
mtodos. H duas formas para se enviar argumentos para um mtodo, o primeiro envio por valor
e o segundo envio por referncia.
4.3.1. Envio por valor
Quando ocorre um envio por valor, a chamada do mtodo faz uma cpia do valor do atributo e o re-
envia como argumento. O mtodo chamado no modifica o valor original do argumento mesmo que
estes valores sejam modificados durante operaes de clculo implementadas pelo mtodo. Por ex-
emplo:
public class TestPassByValue {
int i = 10;
//exibe o valor de i
System.out.println( i );
//chama o mtodo test
//envia i para o mtodo test
test( i );
//exibe o valor de i no modificado
System.out.println( i );
}
public static void test( int j ){
//muda o valor do argumento j
j = 33;
}
}
No exemplo dado, o mtodo test foi chamado e o valor de i foi enviado como argumento. O valor de
i copiado para o atributo do mtodo j. J que j o atributo modificado no mtodo test, no afetar
o valor do atributo i, o que significa uma cpia diferente do atributo.
Como padro, todo tipo primitivo, quando enviado para um mtodo, utiliza a forma de envio por va-
lor.
4.3.2. Envio por referncia
Quando ocorre um envio por referncia, a referncia de um objeto enviada para o mtodo chama-
do. Isto significa que o mtodo faz uma cpia da referncia do objeto enviado.
Entretanto, diferentemente do que ocorre no envio por valor, o mtodo pode modificar o objeto para
o qual a referncia est apontando. Mesmo que diferentes referncias sejam usadas nos mtodos, a
localizao do dado para o qual ela aponta a mesma. Por exemplo:
class TestPassByReference {
// criar um array de inteiros
int []ages = {10, 11, 12};
// exibir os valores do array
for (int i=0; i < ages.length; i++) {
System.out.println( ages[i] );
}
// chamar o mtodo test e enviar a
// referncia para o array
test( ages );
// exibir os valores do array
for (int i=0; i < ages.length; i++) {
System.out.println(ages[i]);
}
}
public static void test( int[] arr ){
// mudar os valores do array
for (int i=0; i < arr.length; i++) {
arr[i] = i + 50;
}
}
}
Dicas de programao:
1. Um erro comum sobre envio por referncia acontece quando criamos ummtodo para fazer tro-
cas (swap) usando referncia. Note que Java manipula objetos 'por referncia', entretanto envia-
se a referncia para um mtodo 'por valor'. Como conseqncia, no se escreve um mtodo pa-
dro para fazer troca de valores (swap) entre objetos.
Figura 2: Exemplo de Envio por referncia
4.4. Chamando mtodos estticos

Mtodos estticos so mtodos que podem ser invocados sem que um objeto tenha sido instanciado
pela classe (sem utilizar a palavra-chave new). Mtodos estticos pertencem a classe como um todo
e no ao objeto especifico da classe. Mtodos estticos so diferenciados dos mtodos de objeto
pela declarao da palavra-chave static na definio do mtodo.
Para chamar um mtodo esttico, digite:

NomeClasse.nomeMtodoEsttico(argumentos);
Alguns mtodos estticos, que j foram usados em nossos exemplos so:

// Converter a String 10 em um atributo do tipo inteiro
int i = Integer.parseInt("10");
// Retornar uma String representando um inteiro sem o sinal da

// base 16
String hexEquivalent = Integer.toHexString(10);
4.5. Escopo de um atributo
Alm do atributo ter um nome e um tipo, ele tambm possui um escopo. O escopo determina onde
o atributo acessvel dentro da classe. O escopo tambm determina o tempo de vida do atributo ou
quanto tempo o atributo ir existir na memria. O escopo determinado pelo local onde o atributo
declarado na classe.
Para simplificar, vamos pensar no escopo como sendo algo existente entre as chaves {...}. A chave
direita chamada de chave de sada do bloco (outer) e a chave esquerda chamada chave de en-
trada do bloco (inner).
Ao declarar atributos fora de um bloco, eles sero visveis (usveis) inclusive pelas linhas da classe
dentro do bloco. Entretanto, ao declarar os atributo dentro do bloco, no ser possvel utiliz-los fora
do bloco.
O escopo de um atributo dito local quando declarado dentro do bloco. Seu escopo inicia com a
sua declarao e vai at a chave de sada do bloco.
Por exemplo, dado o seguinte fragmento de cdigo:

public class ScopeExample {
int i = 0;
int j = 0;
{
int k = 0;
int m = 0;
int n = 0;
}
}
}
O cdigo acima representa cinco escopos indicado pelas letras. Dados os atributos i, j, k, m e n, e os
cinco escopos A, B, C, D e E, temos os seguintes escopos para cada atributo:
O escopo do atributo i A.
O escopo do atributo j B.
O escopo do atributo k C.
O escopo do atributo m D.
O escopo do atributo n E.
Dado dois mtodos: main e test teremos o seguinte exemplo:

class TestPassByReference {
// criar um array de inteiros
int []ages = {10, 11, 12};
//exibir os valores do array
for (int i=0; i < ages.length; i++){
}
// chamar o mtodo test e enviar a referncia para o array
test(ages);
//exibe novamente os valores do array
for (int i = 0; i < ages.length; i++) {
}
}
public static void test(int[] arr) {
// modificar os valores do array
for (int i = 0; i < arr.length; i++) {
arr[i] = i + 50;
}
}
}
Para o mtodo main, os escopos dos atributos so:

ages[] - escopo A
i em B - escopo B
i em C escopo C
E, no mtodo test, os escopos dos atributos so:

arr[] - escopo D
i em E - escopo E
Quando atributos so declarados, o identificador deve ser nico no escopo. Isto significa que se voc
tiver a seguinte declarao:
{
int test = 10;
int test = 20;
}
o compilador ir gerar um erro pois deve-se ter um nome nico para o atributos dentro do bloco.
Entretanto, possvel ter atributos definidos com o mesmo nome, se no estiverem declarados no
mesmo bloco. Por exemplo:
public class TestBlock {
int test = 10;
public void test() {

System.out.print(test);
int test = 20;
System.out.print(test);
}
TestBlock testBlock = new TestBlock();
testBlock.test();
}
}
Quando a primeira instruo System.out.print for invocada, exibir o valor 10 contido na primeira
declarao do atributo test. Na segunda instruo System.out.print, o valor 20 exibido, pois o
valor do atributos test neste escopo.
Dicas de programao:
1. Evite ter atributos declarados com o mesmo nome dentro de um mtodo para no causar confu-
so.
5. Casting, Converso e Comparao de Objetos

Nesta seo, vamos aprender como realizar um casting. Casting, ou typecasting, o processo de
converso de um certo tipo de dado para outro. Tambm aprenderemos como converter tipos de da-
dos primitivos para objetos e vice-versa. E, finalmente, aprenderemos como comparar objetos.
5.1. Casting de Tipos Primitivos
Casting entre tipos primitivos permite converter o valor de um dado de um determinado tipo para
outro tipo de dado primitivo. O casting entre primitivos comum para os tipos numricos. H um
tipo de dado primitivo que no aceita o casting, o tipo de dado boolean.
Como demonstrao de casting de tipos, considere que seja necessrio armazenar um valor do tipo
int em um atributo do tipo double. Por exemplo:
int numInt = 10;
double numDouble = numInt; // cast implcito
uma vez que o atributo de destino double, pode-se armazenar um valor cujo tamanho seja menor
ou igual aquele que est sendo atribudo. O tipo convertido implicitamente. Quando convertemos
um atributo cujo tipo possui um tamanho maior para um de tamanho menor, necessariamente deve-
mos fazer um casting explcito. Esse possui a seguinte forma:
(tipoDado)valor
onde:
tipoDado o nome do tipo de dado para o qual se quer converter o valor
valor um valor que se quer converter.
Por exemplo:
double valDouble = 10.12;
int valInt = (int)valDouble; //converte valDouble para o tipo int
double x = 10.2;
int y = 2;
int result = (int)(x/y); //converte o resultado da operao para int
Outro exemplo quando desejamos fazer um casting de um valor do tipo int para char. Um caracte-
re pode ser usado como int porque para cada caractere existe um correspondente numrico que re-
presenta sua posio no conjunto de caracteres. O casting (char)65 ir produzir a sada 'A'. O cdigo
numrico associado letra maiscula A 65, segundo o conjunto de caracteres ASCII. Por exemplo:
char valChar = 'A';
System.out.print((int)valChar); //casting explcito produzir 65
5.2. Casting de Objetos
Para objetos, a operao de casting tambm pode ser utilizada para fazer a converso para outras
classes, com a seguinte restrio: a classe de origem e a classe de destino devem ser da mesma fa-
mlia, relacionadas por herana; uma classe deve ser subclasse da outra. Veremos mais em lies
posteriores sobre herana.
Analogamente converso de valores primitivos para um tipo maior, alguns objetos no necessitam
ser convertidos explicitamente. Em conseqncia de uma subclasse conter todas as informaes da
sua superclasse, pode-se usar um objeto da subclasse em qualquer lugar onde a superclasse espe-
rada.
Por exemplo, um mtodo que recebe dois argumentos, um deles do tipo Object e outro do tipo Win-
dow. Pode-se enviar um objeto de qualquer classe como argumento Object porque todas as classes
Java so subclasses de Object. Para o argumento Window, possvel enviar apenas suas subclas-
ses, tais como Dialog, FileDialog, Frame (ou quaisquer de subclasses de suas subclasses, indefini-
damente). Isso vale para qualquer parte da classe, no apenas dentro da chamadas do mtodo.
Para um objeto definido como uma classe Window, possvel atribuir objetos dessa classe ou qual-
quer uma de suas subclasses para esse objeto sem o casting.
O contrrio tambm verdadeiro. Uma superclasse pode usada quando uma subclasse esperada.
Entretanto, nesse caso, o casting necessrio porque as subclasses contm mais mtodos que suas
superclasses, e isso acarreta em perda de preciso. Os objetos das superclasses podem no dispor
de todo o comportamento necessrio para agir como um objeto da subclasse. Por exemplo, se uma
operao faz a chamada a um mtodo de um objeto da classe Integer, usando um objeto da classe
Number, ele no ter muitos dos mtodos que foram especificados na classe Integer. Erros ocorre-
ro se voc tentar chamar mtodos que no existem no objeto de destino.
Para usar objetos da superclasse onde uma subclasse esperada, necessrio fazer o casting ex-
plcito. Nenhuma informao ser perdida no casting, entretanto, ganhar todos os atributos e m-
todos que a subclasse define. Para fazer o casting de um objeto para outro, utiliza-se a mesma ope-
rao utilizada com os tipos primitivos:
Para fazer o casting:

onde:
nomeClasse o nome da classe destino
objeto a referncia para o objeto origem que se quer converter
Uma vez que casting cria uma referncia para o antigo objeto de nomeClasse; ele continua a existir
depois do casting.
Figura 3: Exemplo de Hierarquia de Classes
Figura 4: Hierarquia de classes para a superclasse Employee
O exemplo a seguir realiza um casting de um objeto da classe VicePresident para um objeto da clas-
se Employee. VicePresident uma subclasse de Employee com mais informaes, supondo que te-
nha sido definido que a classe VicePresident tem mais privilgios que um Employee.
Employee emp = new Employee();
VicePresident veep = new VicePresident();
emp = veep; // casting no necessrio de baixo para cima
veep = (VicePresident)emp; // necessita do casting explcito
5.3. Convertendo Tipos Primitivos para Objetos e Vice-Versa
No se pode fazer sob qualquer circunstncia um casting de um objeto para um tipo de dado pri-
mitivo, ou vice-versa. Tipos primitivos e objetos so muito diferentes em Java e no se pode fazer o
casting automaticamente entre os dois ou intercambiar o seu uso.
Como alternativa, o pacote java.lang oferece classes que fazem a correspondncia para cada tipo
primitivo: Float, Boolean, Byte, dentre outros. Muitas dessas classes tm o mesmo nome dos tipos
de dados primitivos, exceto pelo fato que o nome dessas classe comeam com letra maiscula
(Short ao invs de short, Double ao invs de double, etc). H duas classes que possuem nomes que
diferem do correspondente tipo de dado primitivo: Character usado para o tipo char e Integer usa-
do para o tipo int. Estas classes so chamadas de Wrapper Class.
Verses anteriores a 5.0 de Java tratam os tipos de dados e suas Wrapper Class de forma muito di-
ferente e uma classe no ser compilada com sucesso se for utilizado uma quando deveria usar a
outra. Por exemplo:
Integer ten = 10;
Integer two = 2;
System.out.println(ten + two);
Usando as classes que correspondem a cada um dos tipos primitivos, possvel criar objetos que ar-
mazenam este mesmo valor. Por exemplo:
// A declarao seguinte cria um objeto de uma classe Integer
// com o valor do tipo int 7801 (primitivo -> objeto)
Integer dataCount = new Integer(7801);
// A declarao seguinte converte um objeto Integer para um

// tipo de dado primitivo int. O resultado o valor 7801
int newCount = dataCount.intValue();
// Uma converso comum de se fazer de String para um tipo

// numrico (objeto -> primitivo)
String pennsylvania = "65000";
int penn = Integer.parseInt(pennsylvania);
Dicas de programao:
1. A classe Void representa vazio em Java. Deste modo, no existem motivos para ela ser usada
na converso de valores primitivos e objetos. Ela um tratador para a palavra-chave void, que
utilizada na assinatura de mtodos indicando que estes no retornam valor.
5.4. Comparando Objetos
Em lies prvias, aprendemos sobre operadores para comparar valores igualdade, negao, me-
nor que, etc. Muitos desses operadores trabalham apenas com dados de tipo primitivo, no com ob-
jetos. Ao tentar utilizar outros tipos de dados, o compilador produzir erros.
Uma exceo para esta regra so os operadores de igualdade: == (igual) e != (diferente). Quando
aplicados a objetos, estes operadores no fazem o que se poderia supor. Ao invs de verificar se um
objeto tem o mesmo valor de outro objeto, eles determinam se os dois objetos comparados pelo
operador tm a mesma referncia. Por exemplo:
String valor1 = new String;
Integer dataCount = new Integer(7801);
Para comparar objetos de uma classe e ter resultados apropriados, deve-se implementar e chamar
mtodos especiais na sua classe. Um bom exemplo disso a classe String. possvel ter dois objetos
String diferentes que contenham o mesmo valor. Caso se empregue o operador == para comparar
objetos, estes sero considerados diferentes. Mesmo que seus contedos sejam iguais, eles no so
o mesmo objeto. Para ver se dois objetos String tm o mesmo contedo, um mtodo chamado
equals() utilizado. O mtodo compara cada caractere presente no contedo das Strings e retorna
true se ambas strings tiverem o mesmo valor.
O cdigo seguinte ilustra essa comparao,

class EqualsTest {
String str1, str2;
str1 = "Free the bound periodicals.";
str2 = str1;
System.out.println("String1: " + str1);
System.out.println("Same object? " + (str1 == str2));
str2 = new String(str1);
System.out.println("Same object? " + (str1 == str2));
System.out.println("Same value? " + str1.equals(str2));
}
}
A sada dessa classe a seguinte:

String1: Free the bound periodicals.
Same object? true
Same object? false
Same value? true
Vamos entender o processo envolvido.

String str1, str2;
str1 = "Free the bound periodicals.";
str2 = str1;
Figura 5: Duas referncias apontando para o mesmo objeto
A primeira parte dessa classe declara dois atributos (str1 e str2) e atribui a literal "Free the bound
periodicals." a str1, e depois atribui esse valor a str2. Como visto anteriormente, str1 e str2 agora
apontam para o mesmo objeto, e o teste de igualdade prova isso.
Em seguida, temos a seguinte instruo:

str2 = new String(str1);
Na segunda parte da classe, cria-se um novo objeto String com o mesmo valor de str1 e faz-se a
atribuio de str2 para esse novo objeto String. Agora temos dois diferentes tipos de objetos na str1
e str2, ambos com o mesmo contedo. Testando para ver se eles so o mesmo objeto usando o ope-
rador de igualdade obtemos a resposta esperada: false eles no so o mesmo objeto na mem-
ria. Utilizando o mtodo equals() recebemos a resposta esperada: true eles tem o mesmo conte-
do.
Figura 6: As referncias apontam agora para objetos diferentes
Dicas de programao:
1. Porque no se pode ter a mesma literal quando mudamos str2, a no ser quando utilizamos o
new? Literais String so otimizadas em Java; se uma String criada utilizando uma literal e cria-se
outra String com os mesmos caracteres, Java tem inteligncia suficiente para retornar apenas a
posio em memria do primeiro objeto String criado. Ou seja, ambas strings se referem ao mes-
moobjeto como se fosse um apelido. Para obrigar ao Java criar um novo objeto String, deve-se uti-
lizar o operador new.
5.5. Determinando a Classe de um Objeto

Existem duas maneiras de se descobrir a qual classe determinado objeto pertence:
1. Para obter o nome da classe:
Utiliza-se o mtodo getClass() que retorna a classe do objeto (onde Class a classe em si). Esta,
por sua vez, possui o mtodo chamado getName() que retorna o nome da classe.
Por exemplo:
String name = key.getClass().getName();
2. Para testar se um objeto qualquer foi instanciado de uma determinada classe:
Utiliza-se a palavra-chave instanceof. Esta palavra-chave possui dois operadores: a referncia para o
objeto esquerda e o nome da classe direita. A expresso retorna um lgico dependendo se o ob-
jeto uma instncia da classe declarada ou qualquer uma de suas subclasses.
Por exemplo:
String ex1 = "Texas";
System.out.println(ex1 instanceof String); // retorna true
String ex2;
System.out.println(ex2 instanceof String); // retorna false
6. Exerccios
6.1. Definindo termos
Em suas palavras, defina os seguintes termos:

1. Classe
2. Objeto
3. Instanciao
4. Atributo de objeto
5. Mtodo de objeto
6. Atributo de classe ou atributos estticas
7. Construtor
8. Mtodo de classe ou mtodos estticos
6.2. Java Scavenger Hunt
Pipoy um novato na linguagem de programao Java. Ele apenas ouviu que existem Java APIs
(Application Programming Interface) prontas para serem usadas em suas classes e ele est ansioso
para fazer uns testes com elas. O problema que Pipoy no tem uma cpia da documentao Java e
ele tambm no tem acesso Internet, deste modo, no h como ele ver as APIs java.
Sua tarefa ajudar Pipoy a procurar as APIs. Voc deve informar as classes s quais os mtodos
pertencem e como o mtodo deve ser declarado com um exemplo de uso deste.
Por exemplo, se Pipoy quer saber qual o mtodo que converte uma String para int, sua resposta
deve ser:
Classe: Integer
Declarao do Mtodo: public static int parseInt( String value )
Exemplo de Uso:
String strValue = "100";
int value = Integer.parseInt( strValue );
Tenha certeza de que o fragmento de cdigo que voc escreveu em seu exemplo de uso compila e
que produza o resultado correto. Enfim, no deixe Pipoy confuso. (Dica: Todos os mtodos esto no
package java.lang). Caso haja mais de um mtodo para atender tarefa, utilize apenas um.
Agora vamos iniciar a busca! Aqui esto alguns mtodos que Pipoy necessita:
1. Procure pelo mtodo que verifica se uma String termina com um determinado sufixo. Por exem-
plo, se a String dada "Hello", o mtodo deve retornar true se o sufixo informado "lo", e false se o
sufixo for "alp".
2. Procure pelo mtodo que determina a representao do caractere para um dgito e base especfi-
cos. Por exemplo, se o dgito informado 15 e a base 16, o mtodo retornar o caractere 'F', uma
vez que 'F' a representao hexadecimal para o nmero 15 em base 10.
3. Procure por um mtodo que retorna a parte inteira de um valor double. Por exemplo, se a entrada
for 3.13, o mtodo deve retornar o valor 3.
4. Procure por um mtodo que determina se um certo caractere um dgito. Por exemplo, se a en-
trada for '3', retornar o valor true.
5. Procure por um mtodo que interrompe a execuo da Java Virtual Machine corrente.
Lio 8
1. Objetivos
Agora que j estudamos como usar as classes existentes na biblioteca de classes do Java, estudare-
mos como criar nossas prprias classes. Nesta lio, para facilmente entender como cri-las, realiza-
remos um exemplo de classe no qual adicionaremos dados e funcionalidades medida em que avan-
armos no curso.
Criaremos uma classe com informaes de um Estudante e com operaes necessrias para seu re-
gistro.
Algumas observaes devem ser feitas quanto sintaxe que ser usada nesta e nas prximas se-
es:
* - significa que pode haver nenhuma ou diversas ocorrncias na linha em que for aplicada <descri-
o> - indica a substituio deste trecho por um certo valor, ao invs de digit-lo como est [] - in-
dica que esta parte opcional
Criar nossas classes

Declarar atributos e mtodos para as classes
Usar o objeto this para acessar dados de instncia
Utilizar overloading de mtodos
Importar e criar pacotes
Usar modificadores de acesso para controlar o acesso aos elementos de uma classe
2. Definindo nossas classes

Antes de escrever sua classe, primeiro pense onde e como sua classe ser usada. Pense em um
nome apropriado para a classe e liste todas as informaes ou propriedades que deseje que ela te-
nha. Liste tambm os mtodos que sero usados para a classe.
Para definir uma classe, escrevemos:

<modificador>* class <nome> {
<declaraoDoAtributo>*
<declaraoDoConstrutor>*
<declaraoDoMtodo>*
}
onde:
<modificador> um modificador de acesso, que pode ser
usado em combinao com outros
<nome> nome da sua classe
<declaraoDoAtributo> atributos definidos para a classe
<declaraoDoConstrutor> mtodo construtor
<declaraoDoMtodo> mtodos da classe
Dicas de programao:
1. Lembre-se de que, para a declarao da classe, o nico modificador de acesso

vlido o public. De uso exclusivo para a classe que possuir o mesmo nome do
arquivo externo.
Nesta lio, criaremos uma classe que conter o registro de um estudante. Como j identificamos o
objetivo da nossa classe, agora podemos nome-la. Um nome apropriado para nossa classe seria
StudentRecord.
Para definir nossa classe, escrevemos:

public class StudentRecord {
// adicionaremos mais cdigo aqui
}
onde:
public modificador de acesso e significa que qualquer classe pode acessar esta
class palavra-chave usada para criar uma classe StudentRecord identificador nico que identifica a
classe
Dicas de programao:
1. Pense em nomes apropriados para a sua classe. No a chame simplesmente de
classe XYZ ou qualquer outro nome aleatrio.
2. Os nomes de classes devem ser iniciadas por letra MAISCULA.
3. O nome do arquivo de sua classe obrigatoriamente possui o MESMO NOME da
sua classe pblica.
3. Declarando Atributos
Para declarar um certo atributo para a nossa classe, escrevemos:
<modificador>* <tipo> <nome> [= <valorInicial>];
onde:
modificador tipo de modificador do atributo
tipo tipo do atributo
nome pode ser qualquer identificador vlido
valorInicial valor inicial para o atributo
Relacionaremos a lista de atributos que um registro de estudante pode conter. Para cada informao,
listaremos os tipos de dados apropriados que sero utilizados. Por exemplo, no seria ideal usar um
tipo int para o nome do estudante ou String para a nota do estudante.
Abaixo, por exemplo, temos algumas informaes que podemos adicionar ao registro do estudante:
nome - String
endereo - String
idade - int
nota de matemtica - double
nota de ingls - double
nota de cincias - double
Futuramente, possvel adicionar mais informaes. Para este exemplo, utilizaremos somente es-
tas.
3.1. Atributos de Objeto
Agora que temos uma lista de todos os atributos que queremos adicionar nossa classe, vamos
adicion-los ao nosso cdigo. Uma vez que queremos que estes atributos sejam nicos para
cada objeto (ou para cada estudante), devemos declar-los como atributos de objeto.
Por exemplo:

private String name;
private String address;
private int age;
private double mathGrade;
private double englishGrade;
private double scienceGrade;
}
onde:
private significa que os atributos so acessveis apenas de dentro da classe. Outros objetos no po-
dem acessar diretamente estes atributos.
Dicas de programao:
1. Declare todas os atributos de objeto na parte superior da declarao da classe.
2. Declare cada atributo em uma linha.
3. Atributos de objeto, assim como qualquer outro atributo devem iniciar com le-
tra MINSCULA.
4. Use o tipo de dado apropriado para cada atributo declarado.
5. Declare atributos de objetos como private de modo que somente os mtodos
da classe possam acess-los diretamente.
3.2. Atributos de Classe ou Atributos Estticos
Alm das atributos de objeto, podemos tambm declarar atributos de classe ou atributos que per-
tenam classe como um todo. O valor destes atributos o mesmo para todos os objetos da mes-
ma classe. Suponha que queiramos saber o nmero total de registros criados para a classe. Pode-
mos declarar um atributo esttico que armazenar este valor. Vamos cham-lo de studentCount.
Para declarar um atributo esttico:

// atributos de objeto declarados anteriormente
private static int studentCount;
}
usamos a palavra-chave static para indicar que um atributo esttico.
Ento, nosso cdigo completo deve estar assim:

private int age;
}
4. Declarando Mtodos
Antes de discutirmos quais mtodos que a nossa classe dever conter, vejamos a sintaxe geral usa-
da para a declarao de mtodos.
Para declararmos mtodos, escrevemos:
<modificador>* <tipoRetorno> <nome>(<argumento>*) {
<instrues>*
}
onde:
<modificador> pode ser utilizado qualquer modificador de acesso
<tipoRetorno> pode ser qualquer tipo de dado (incluindo void)
<nome> pode ser qualquer identificador vlido
<argumento> argumentos recebidos pelo mtodo separados por vrgu-
las. So definidos por:
<tipoArgumento> <nomeArgumento>
4.1. Mtodos assessores
Para que se possa implementar o princpio do encapsulamento, isto , no permitir que quaisquer
objetos acessem os nossos dados de qualquer modo, declaramos campos, ou atributos, da nossa
classe como particulares.Entretanto, h momentos em que queremos que outros objetos acessem
estes dados particulares. Para que possamos fazer isso, criamos mtodos assessores.
Mtodos assessores so usados para ler valores de atributos de objeto ou de classe. O mtodo as-
sessor recebe o nome de get<NomeDoAtributo>. Ele retorna um valor. Para o nosso exemplo, que-
remos um mtodo que possa ler o nome, endereo, nota de ingls, nota de matemtica e nota de ci-
ncias do estudante. Vamos dar uma olhada na implementao deste:
:
:
public String getName() {
return name;
}
}
onde:
public significa que o mtodo pode ser chamado por objetos externos classe String o tipo do re-
torno do mtodo. Isto significa que o mtodo deve retornar um valor de tipo String getName o nome
do mtodo() significa que o nosso mtodo no tem nenhum argumento
A instruo:
return name;
no mtodo, significa que retornar o contedo do atributo name ao mtodo que o chamou. Note que
o tipo do retorno do mtodo deve ser do mesmo tipo do atributo utilizado na declarao return. O
seguinte erro de compilao ocorrer caso o mtodo e o atributo de retorno no tenham o mesmo
tipo de dados:
StudentRecord.java:14: incompatible types
found : int
required: java.lang.String
return name;
^
1 error
Outro exemplo de um mtodo assessor o mtodo getAverage:

:
:
public double getAverage(){
double result = 0;
result =
(mathGrade+englishGrade+scienceGrade)/3;
return result;
}
}
O mtodo getAverage calcula a mdia das 3 notas e retorna o resultado.
4.2 Mtodos Modificadores
Para que outros objetos possam modificar os nossos dados, disponibilizamos mtodos que possam
gravar ou modificar os valores dos atributos de objeto ou de classe. Chamamos a estes mtodos
modificadores. Este mtodo escrito como set<NomeDoAtributoDeObjeto>.
Vamos dar uma olhada na implementao de um mtodo modificador:

:
:
public void setName(String temp) {
name = temp;
}
}
onde:
public significa que o mtodo pode ser chamado por objetos externos classevoid significa que o
mtodo no retorna valor setName o nome do mtodo (String temp) argumento que ser utilizado
dentro do nosso mtodo
A instruo:
name = temp;
atribuir o contedo de temp para name e, portanto, alterar os dados dentro do atributo de objeto
name.
Mtodos modificadores no retornam valores. Entretanto, eles devem receber um argumento com o
mesmo tipo do atributo no qual esto tratando.
4.3. Mltiplos comandos return
possvel ter vrios comandos return para um mtodo desde que eles no pertenam ao mesmo
bloco. possvel utilizar constantes para retornar valores, ao invs de atributos.
Por exemplo, considere o mtodo:

public String getNumberInWords(int num) {
String defaultNum = "zero";
if (num == 1) {
return "one"; // retorna uma constante
} else if( num == 2) {
return "two"; // retorna uma constante
}
// retorna um atributo
return defaultNum;
}
4.4. Mtodos estticos
Para o atributo esttico studentCount, podemos criar um mtodo esttico para obter o seu conte-
do.
public static int getStudentCount(){
return studentCount;
}
}
onde:
public significa que o mtodo pode ser chamado por objetos externos classe static significa que o
mtodo esttico e deve ser chamado digitando-se [NomeClasse].[nomeMtodo] int o tipo do re-
torno do mtodo. Significa que o mtodo deve retornar um valor de tipo int getStudentCount nome
do mtodo() significa que o mtodo no tem nenhum argumento Por enquanto, getStudentCount re-
tornar sempre o valor zero j que ainda no fizemos nada na nossa classe para atribuir o seu valor.
Modificaremos o valor de studentCount mais tarde, quando discutirmos construtores.
Dicas de programao:
1. Nomes de mtodos devem iniciar com letra MINSCULA.

2. Nomes de mtodos devem conter verbos
3. Sempre faa documentao antes da declarao do mtodo. Use o
estilo javadoc para isso.
4.5. Exemplo de Cdigo Fonte para a classe StudentRecord
Aqui est o cdigo para a nossa classe StudentRecord:

private int age;
/**
* Retorna o nome do estudante
*/
public String getName(){
return name;
}
/**
* Muda o nome do estudante
*/
public void setName( String temp ){
name = temp;
}
// outros mtodos modificadores aqui ....
/**
* Calcula a mdia das classes de ingls, matemtica
* e cincias
*/
public double getAverage(){
double result = 0;
result =
(mathGrade+englishGrade+scienceGrade)/3;
return result;
}
/**
* Retorna o nmero de ocorrncias em StudentRecords
*/
public static int getStudentCount(){
return studentCount;
}
}
Aqui est um exemplo do cdigo de uma classe que utiliza a nossa classe StudentRecord.
public class StudentRecordExample {
// criar trs objetos para StudentRecord

StudentRecord annaRecord = new StudentRecord();
StudentRecord beahRecord = new StudentRecord();
StudentRecord crisRecord = new StudentRecord();
/
/ enviar o nome dos estudantes
annaRecord.setName("Anna");
beahRecord.setName("Beah");
crisRecord.setName("Cris");
// mostrar o nome de anna

System.out.println(annaRecord.getName());
//mostrar o nmero de estudantes

System.out.println("Count=" +
StudentRecord.getStudentCount());
}
}
A sada desta classe :

Anna
Count = 0
5. this
O objeto this usado para acessar atributos de objeto ou mtodos da classe. Para entender isso
melhor, tomemos o mtodo setAge como exemplo. Suponha que tenhamos o seguinte mtodo para
setAge:
public void setAge(int age){
age = age; // No uma boa prtica
}
O nome do argumento nesta declarao age, que tem o mesmo nome do atributo de objeto age.
J que o argumento age a declarao mais prxima do mtodo, o valor do argumento age ser
usado. Na instruo:
age = age;
estamos simplesmente associando o valor do argumento age para si mesmo! Isto no o que que-
remos que acontea no nosso cdigo. A fim de corrigir esse erro, usamos o objeto this. Para utilizar
o objeto this, digitamos:
this.<nomeDoAtributo>
O ideal reescrever o nosso mtodo do seguinte modo:

public void setAge(int age){
this.age = age;
}
Este mtodo ir atribuir o valor do argumento age para a atributo de objeto age do objeto Studen-
tRecord.
6. Overloading de Mtodos
Nas nossas classes, podemos necessitar de criar mtodos que tenham os mesmos nomes, mas que
funcionem de maneira diferente dependendo dos argumentos que informamos. Esta capacidade
chamada de overloading de mtodos.
Overloading de mtodos permite que um mtodo com o mesmo nome, entretanto com diferentes
argumentos, possa ter implementaes diferentes e retornar valores de diferentes tipos. Ao invs de
inventar novos nomes todas as vezes, o overloading de mtodos pode ser utilizado quando a mesma
operao tem implementaes diferentes.
Por exemplo, na nossa classe StudentRecord, queremos ter um mtodo que mostre as informaes
sobre o estudante. Entretanto, queremos que o mtodo print mostre dados diferentes dependendo
dos argumentos que lhe informamos. Por exemplo, quando no enviamos qualquer argumento que-
remos que o mtodo print mostre o nome, endereo e idade do estudante.
Quando passamos 3 valores double, queremos que o mtodo mostre o nome e as notas do estudan-
te.
Temos os seguintes mtodos dentro da nossa classe StudentRecord:

public void print(){
System.out.println("Name:" + name);
System.out.println("Address:" + address);
System.out.println("Age:" + age);
}
public void print(double eGrade, double mGrade, double sGrade) {

System.out.println("Name:" + name);
System.out.println("Math Grade:" + mGrade);
System.out.println("English Grade:" + eGrade);
System.out.println("Science Grade:" + sGrade);
}
Quando tentamos chamar estes mtodos no mtodo main, criado para a classe StudantRecordE-
xample:
annaRecord.setName("Anna");
annaRecord.setAddress("Philippines");
annaRecord.setAge(15);
annaRecord.setMathGrade(80);
annaRecord.setEnglishGrade(95.5);
annaRecord.setScienceGrade(100);
// overloading de mtodos
annaRecord.print();
annaRecord.print(
annaRecord.getEnglishGrade(),
annaRecord.getMathGrade(),
annaRecord.getScienceGrade());
}
teremos a sada para a primeira chamada ao mtodo print:

Name:Anna
Address:Philippines
Age:15
e, em seguida, a sada para a segunda chamada ao mtodo print:

Name:Anna
Math Grade:80.0
English Grade:95.5
Science Grade:100.0
Lembre-se sempre que mtodos overload possuem as seguintes
propriedades:
1. o mesmo nome
2. argumentos diferentes
3. tipo do retorno igual ou diferente
7. Declarando Construtores
Discutimos anteriormente o conceito de construtores. Construtores so importantes na criao de
um objeto. um mtodo onde so colocadas todas as inicializaes.
A seguir, temos as propriedades de um construtor:
1. Possuem o mesmo nome da classe
2. Construtor um mtodo, entretanto, somente as seguintes informaes podem ser colocadas no

cabealho do construtor:
Escopo ou identificador de acessibilidade (como public)
Nome do construtor
Argumentos, caso necessrio
3. No retornam valor
4. So executados automaticamente na utilizao do operador new durante a instanciao da classe
Para declarar um construtor, escrevemos:

[modificador] <nomeClasse> (<argumento>*) {
<instruo>*
}
7.1. Construtor Padro (default)
Toda classe tem o seu construtor padro. O construtor padro um construtor pblico e sem argu-
mentos. Se no for definido um construtor para a classe, ento, implicitamente, assumido um
construtor padro.
Por exemplo, na nossa classe StudentRecord, o construtor padro definido do seguinte modo:
public StudentRecord() {
}
7.2. Overloading de Construtores
Como mencionamos, construtores tambm podem sofrer overloading, por exemplo, temos aqui
quatro construtores:
// qualquer cdigo de inicializao aqui
}
public StudentRecord(String temp){

this.name = temp;
}
public StudentRecord(String name, String address) {
this.name = name;
this.address = address;
}
public StudentRecord(double mGrade, double eGrade, double sGrade) {
mathGrade = mGrade;
englishGrade = eGrade;
scienceGrade = sGrade;
}
7.3. Usando Construtores
Para utilizar estes construtores, temos as seguintes instrues:

// criar trs objetos para o registro do estudante
StudentRecord annaRecord = new
StudentRecord("Anna");
StudentRecord beahRecord =
new StudentRecord("Beah", "Philippines");
StudentRecord crisRecord =
new StudentRecord(80,90,100);
// algum cdigo aqui
}
Antes de continuarmos, vamos retornar o atributo esttico studentCount que declaramos agora a
pouco. O objetivo de studentCount contar o nmero de objetos que so instanciados com a classe
StudentRecord. Ento, o que desejamos incrementar o valor de studentCount toda vez que um
objeto da classe StudentRecord instanciado. Um bom local para modificar e incrementar o valor de
studentCount nos construtores, pois so sempre chamados toda vez que um objeto instanciado.
Por exemplo:
studentCount++; // adicionar um estudante
}
public StudentRecord(String name) {
this.name = name;
}
this.name = name;
}
mathGrade = mGrade;
}
7.4. Utilizando o this()
Chamadas a construtores podem ser cruzadas, o que significa ser possvel chamar um construtor de
dentro de outro construtor. Usamos a chamada this() para isso. Por exemplo, dado o seguinte cdi-
go,
this("some string");
}
public StudentRecord(String temp) {
this.name = temp;
}
}
Dado o cdigo acima, quando se executa a instruo do mtodo main, ser chamado o primeiro
construtor. A instruo inicial deste construtor resultar na chamada ao segundo construtor.
H algum detalhes que devem ser lembrados na utilizao da chamada ao construtor por this():
1. A chamada ao construtor DEVE SEMPRE OCORRER NA PRIMEIRA LINHA DE INSTRUO
2. UTILIZADO PARA A CHAMADA DE UM CONSTRUTOR. A chamada ao this() pode ser seguida por
outras instrues.
Como boa prtica de programao, ideal nunca construir mtodos que repitam as instrues. Bus-
camos a utilizao de overloading com o objetivo de evitarmos essa repetio. Deste modo, rees-
creveremos os construtores da classe StudentRecord para:
}
public StudentRecord(String name) {
this();
this.name = name;
}
this(name);
}
this();
mathGrade = mGrade;
}
8. Pacotes
So utilizados para agrupar classes e interfaces relacionadas em uma nica unidade (discutiremos
interfaces mais tarde). Esta uma caracterstica poderosa que oferece um mecanismo para ge-
renciamento de um grande grupo de classes e interfaces e evita possveis conflitos de nome.
8.1. Importando Pacotes
Para utilizar classes externas ao pacote da classe, necessrio importar os pacotes dessas classes.
Por padro, todos as suas classes Java importam o pacote java.lang. por isso que possvel utili-
zar classes como String e Integer dentro da sua classe, mesmo no tendo importado nenhum pacote
explicitamente.
A sintaxe para importar pacotes como segue:

import <nomeDoPacote>.<nomeDaClasse>;
Por exemplo, necessitar utilizar a classe Color dentro do pacote awt, necessrio a seguinte instru-
o:
import java.awt.Color;
ou:
import java.awt.*;
A primeira linha de instruo importa especificamente a classe Color enquanto que a seguinte im-
porta todas as classes do pacote java.awt.
Outra maneira de importar classes de outros pacotes atravs da referncia explcita ao pacote.
Isto feito utilizando-se o nome completo do pacote para declarao do objeto na classe:
java.awt.Color color;
8.2. Criando pacotes
Para criar os nossos pacotes, escrevemos:

package <nomeDoPacote>;
Suponha que desejamos criar um pacote onde colocaremos a nossa classe StudentRecord juntamen-
te com outras classes relacionadas. Chamaremos o nosso pacote de schoolClasses.
A primeira coisa que temos que fazer criar uma pasta chamada schoolClasses. Em seguida, copiar
para esta pasta todas as classes que pertenam a este pacote. Adicione a seguinte instruo no ar-
quivo da classe, esta linha deve ser colocada antes da definio da classe. Por exemplo:
package schoolClasses;
// instrues da classe
}
Pacotes podem ser aninhados. Neste caso, o interpretador espera que a estrutura de diretrios con-
tendo as classes combinem com a hierarquia dos pacotes.
8.3. Definindo a varivel de ambiente CLASSPATH
Suponha que colocamos o pacote schoolClasses sob o diretrio C:\.
Precisamos que a classpath aponte para este diretrio de tal forma que quando executemos a clas-
se, a JVM seja capaz de enxergar onde est armazenada.
Antes de discutirmos como ajustar a varivel classpath, vamos ver um exemplo sobre o que aconte-
ceria se esta no fosse ajustada.
Suponha que sigamos os passos para compilar e executar a classe StudentRecord que escrevemos:
C:\schoolClasses>javac StudentRecord.java
C:\schoolClasses>java StudentRecord
Exception in thread "main" java.lang.NoClassDefFoundError: StudentRecord
(wrong name: schoolClasses/StudentRecord)
at java.lang.ClassLoader.defineClass1(Native Method)
at java.lang.ClassLoader.defineClass(Unknown Source)
at java.security.SecureClassLoader.defineClass(Unknown Source)
at java.net.URLClassLoader.defineClass(Unknown Source)
at java.net.URLClassLoader.access$100(Unknown Source)
at java.net.URLClassLoader$1.run(Unknown Source)
at java.security.AccessController.doPrivileged(Native Method)
at java.net.URLClassLoader.findClass(Unknown Source)
at java.lang.ClassLoader.loadClass(Unknown Source)
at sun.misc.Launcher$AppClassLoader.loadClass(Unknown Source)
at java.lang.ClassLoader.loadClass(Unknown Source)
at java.lang.ClassLoader.loadClassInternal(Unknown Source)
Surge o erro NoClassDefFoundError, que significa que o Java desconhece onde procurar por esta
classe. A razo disso que a sua classe StudentRecord pertence a um pacote denominado school-
Classes. Se desejamos executar esta classe, teremos que dizer ao Java o seu nome completo scho-
olClasses.StudentRecord. Tambm teremos que dizer JVM onde procurar pelos nossos pacotes,
que, neste caso, no C:\. Para fazer isso, devemos definir a varivel classpath.
Para definir a varivel classpath no Windows, digitamos o seguinte na linha de comando:

C:\schoolClasses>set classpath=C:\
onde C:\ o diretrio onde colocamos os pacotes. Aps definir a varivel classpath, poderemos exe-
cutar a nossa classe em qualquer pasta, digitando:
C:\schoolClasses>java schoolClasses.StudentRecord
Para sistemas baseados no Unix, suponha que as nossas classes estejam no diretrio
/usr/local/myClasses, escrevemos:
export classpath=/usr/local/myClasses
Observe que possvel definir a varivel classpath em qualquer lugar. possvel definir mais de um
local de pesquisa; basta separ-los por ponto-evrgula (no Windows) e dois-pontos (nos sistemas
baseados em Unix). Por exemplo:
set classpath=C:\myClasses;D:\;E:\MyPrograms\Java
e para sistemas baseados no Unix:

export classpath=/usr/local/java:/usr/myClasses
9. Modificadores de Acesso
Quando estamos criando as nossas classes e definindo as suas propriedades e mtodos, queremos
implementar algum tipo de restrio para se acessar esses dados. Por exemplo, ao necessitar que
um certo atributo seja modificado apenas pelos mtodos dentro da classe, possvel esconder isso
dos outros objetos que estejam usando a sua classe. Para implementar isso, no Java, temos os mo-
dificadores de acesso.
Existem quatro diferentes tipos de modificadores de acesso: public, private, protected e default. Os
trs primeiros modificadores so escritos explicitamente no cdigo para indicar o acesso, para o tipo
default, no se utiliza nenhuma palavra-chave.
9.1. Acesso padro
Especifica que os elementos da classe so acessveis somente aos mtodos internos da classe e s
suas subclasses. No h palavra chave para o modificador default; sendo aplicado na ausncia de
um modificador de acesso. Por exemplo :
// acesso padro ao atributo
int name;
// acesso padro para o mtodo
String getName(){
return name;
}
}
O atributo de objeto name e o mtodo getName() podem ser acessados somente por mtodos inter-
nos classe e por subclasses de StudentRecord.
Falaremos sobre subclasses em prximas lies.
9.2. Acesso pblico
Especifica que os elementos da classe so acessveis tanto internamente quanto externamente

classe. Qualquer objeto que interage com a classe pode ter acesso aos elementos pblicos da classe.
Por exemplo:
// acesso pblico o atributo
public int name;
// acesso pblico para o mtodo
return name;
}
}
O atributo de objeto name e o mtodo getName() podem ser acessados a partir de outros objetos.
9.3. Acesso protegido
Especifica que somente classes no mesmo pacote podem ter acesso aos atributos e mtodos da
classe. Por exemplo:
//acesso protegido ao atributo
protected int name;
//acesso protegido para o mtodo
protected String getName(){
return name;
}
}
O atributo de objeto name e o mtodo getName() podem ser acessados por outros objetos, desde
que o objetos pertenam ao mesmo pacote da classe StudentRecord.
9.4. Acesso particular
Especifica que os elementos da classe so acessveis somente na classe que o definiu. Por exemplo:
// acesso particular ao atributo
private int name;
// acesso particular para o mtodo
private String getName(){
return name;
}
}
O atributo de objeto name e o mtodo getName() podem ser acessados somente por mtodos inter-
nos classe.
Dicas de programao:
1. Normalmente, os atributos de objeto de uma classe devem ser declarados particulares e a clas-
se pode fornecer mtodos assessores e modificadores para estes.
10. Exerccios
10.1. Registro de Agenda
Sua tarefa criar uma classe que contenha um Registro de Agenda. A tabela 1 descreve as informa-
es que um Registro de Agenda deve conter:
Tabela 1: Atributos e Descries dos Atributos
Crie os seguintes mtodos:

1. Fornea todos os mtodos assessores e modificadores necessrios para todos os atributos.
2. Construtores.
10.2. Agenda
Crie uma classe Agenda que possa conter entradas de objetos tipo Registro de Agenda (utilize a
classe criada no primeiro exerccio). Devem ser oferecidos os seguintes mtodos para a agenda:
1. Adicionar registro
2. Excluir registro
3. Visualizar registros
4. Modificar um registro
Lio 9
1. Objetivos
Nesta lio ser discutido como uma classe pode herdar as propriedades de outra classe jexistente.
Uma classe que faz isso chamada de subclasse, e sua classe pai chamada de superclasse. Ser
tambm discutida a aplicao automtica dos mtodos de cada objeto, independente da subclasse
deste. Esta propriedade conhecida como polimorfismo. E, por ltimo, discutiremos sobre interfa-
ces, que ajudam a reduzir no esforo de programao.

Definir superclasses e subclasses
Criar override de mtodos das superclasses
Criar mtodos final e classes final
2. Herana
Todas as classes, incluindo as que compem a API Java, so subclasses da classe Object. Um exem-
plo de hierarquia de classes mostrado com a figura 1. A partir de uma determinada classe, qual-
quer classe acima desta na hierarquia de classes conhecida como uma superclasse (ou classe Pai).
Enquanto que qualquer classe abaixo na hierarquia de classes conhecia como uma subclasse (ou
classe Filho).
Figura 1: Hierarquia de Classes
Herana um dos principais princpios em orientao a objeto. Um comportamento (mtodo) defi-

nido e codificado uma nica vez em uma nica classe e este comportamento herdado por todas
suas subclasses. Uma subclasse precisa apenas implementar as diferenas em relao a sua classe
pai, ou seja, adaptar-se ao meio em que vive.
2.1. Definindo Superclasses e Subclasses
Para herdar uma classe usamos a palavra-chave extends. Ilustraremos criando uma classe pai de
exemplo. Suponha que tenhamos uma classe pai chamada Person.
public class Person {
protected String name;
protected String address;
/**
* Construtor Padro
*/
public Person(){
System.out.println("Inside Person:Constructor");
name = "";
address = "";
}
/**
* Construtor com 2 parmetros
*/
public Person( String name, String address ){
this.name = name;
}
/**
* Mtodos modificadores e acessores
*/
return name;
}
public String getAddress(){
return address;
}
public void setName( String name ){
this.name = name;
}
public void setAddress( String add ){
this.address = add;
}
}
Os atributos name e address so declarados como protected. A razo de termos feito isto que
queremos que estes atributos sejam acessveis s subclasses dessa classe. Se a declararmos com o
modificador private, as subclasses no estaro aptas a us-los. Todas as propriedades de uma su-
perclasse que so declaradas como public, protected e default podem ser acessadas por suas sub-
classes.
Vamos criar outra classe chamada Student. E, como um estudante tambm uma pessoa, conclu-
mos que iremos estender a classe Person, ento, poderemos herdar todas as propriedades existn-
tes na classe Person. Para isto, escrevemos:
public class Student extends Person {
public Student(){
System.out.println("In-
side Student:Constructor");
//Algum cdigo aqui
}
// Algum cdigo aqui
}
O fluxo de controle mostrado na figura 2.
Quando a classe Student for instanciada, o construtor padro da superclasse Person invocado im-
plicitamente para fazer as inicializaes necessrias. Aps isso, as instrues dentro do construtor
da subclasse so executadas. Para ilustrar, considere o seguinte cdigo:
Student anna = new Student();
}
No cdigo, criamos um objeto da classe Student. O resultado da execuo deste programa :

Inside Person:Constructor
Inside Student:Constructor
2.2. super
Uma subclasse pode, explicitamente, chamar um construtor de sua superclasse imediata. Isso fei-
to utilizando uma chamada ao objeto super. Uma chamada ao super no construtor de uma subclas-
se ir resultar na execuo de um construtor especfico da superclasse baseado nos argumentos
passados.
Por exemplo, dada a seguinte instruo para a classe Student:

public Student(){
super( "SomeName", "SomeAddress" );
System.out.println("Inside Student:Constructor");
}
Este cdigo chama o segundo construtor de sua superclasse imediata (a classe Person) e a executa.
Outro cdigo de exemplo mostrado abaixo:
public Student(){
super();
System.out.println("Inside Student:Constructor");
}
Este cdigo chama o construtor padro de sua superclasse imediata (a classe Person) e o executa.
Devemos relembrar, quando usamos uma chamada ao objeto super:
1. A instruo super() DEVE SER A PRIMEIRA INSTRUO EM UM CONSTRUTOR.

2. As instrues this() e super() no podem ocorrer simultaneamente no mesmo construtor. O objeto
super uma referncia aos membros da superclasse (assim como o objeto this da sua prpria
classe). Por exemplo:
public Student() {
super.name = "person name"; // Nome da classe pai
this.name = "student name"; // Nome da classe atual
}
2.3. Override de Mtodos
Se, por alguma razo, uma classe derivada necessita que a implementao de algum mtodo seja
diferente da superclasse, o polimorfismo por override pode vir a ser muito til. Uma subclasse pode
modificar um mtodo definido em sua superclasse fornecendo uma nova implementao para aquele
mtodo.
Supondo que tenhamos a seguinte implementao para o mtodo getName da superclasse Person:
...
System.out.println("Parent: getName");
return name;
}
...
}
Para realizar um polimorfismo por override no mtodo getName da subclasse Student, escrevemos:
...
System.out.println("Student: getName");
return name;
}
...
}
Ento, quando invocarmos o mtodo getName de um objeto da classe Student, o mtodo chamado
ser o de Student, e a sada ser:
Student: getName
possvel chamar o mtodo getName da superclasse, basta para isso:

...
public String getName() {
super.getName();
System.out.println("Student: getName");
return name;
}
...
}
Inserimos uma chamada ao objeto super e a sada ser:

Parent: getName
Student: getName
2.4. Mtodos final e Classes final
Podemos declarar classes que no permitem a herana. Estas classes so chamadas classes finais.
Para definir que uma classe seja final, adicionamos a palavra-chave final na declarao da classe (na
posio do modificador). Por exemplo, desejamos que a classe Person no possa ser herdada por
nenhuma outra classe, escrevemos:
public final class Person {
// Cdigo da classe aqui
}
Muitas classes na API Java so declaradas final para certificar que seu comportamento no seja her-
dado e, possivelmente , modificado. Exemplos, so as classes Integer, Double e Math.
Tambm possvel criar mtodos que no possam ser modificados pelos filhos, impedindo o polimo-
rfismo por override. Estes mtodos so o que chamamos de mtodos finais. Para declarar um mto-
do final, adicionamos a palavra-chave final na declarao do mtodo (na posio do modificador).
Por exemplo, se queremos que o mtodo getName da classe Person no possa ser modificado, es-
crevemos:
public final String getName(){
return name;
}
Caso o programador tente herdar uma classe final, ocorrer um erro de compilao. O mesmo acon-
tecer ao se tentar fazer um override de um mtodo final.
3. Polimorfismo
Considerando a classe pai Person e a subclasse Student do exemplo anterior, adicionaremos outra
subclasse a Person, que se chamar Employee. Abaixo est a hierarquia de classes que ilustra o ce-
nrio:
Figura 3: Hieraquia para a classe Person e suas subclasses.
Podemos criar uma referncia do tipo da superclasse para a subclasse. Por exemplo:
public static main( String[] args ) {
Person ref;
Student studentObject = new Student();
Employee employeeObject = new Employee();
ref = studentObject; //Person ref: ponteiro para um Student
// algum cdigo aqui
}
Supondo que tenhamos um mtodo getName em nossa superclasse Person, iremos realizar uma
modificao deste nas subclasses Student e Employee:
System.out.println("Person Name:" + name);
return name;
}
}
System.out.println("Student Name:" + name);
return name;
}
}
public class Employee extends Person {
System.out.println("Employee Name:" + name);
return name;
}
}
Voltando ao mtodo main, quando tentamos chamar o mtodo getName da referncia ref do tipo
Person, o mtodo getName do objeto Student ser chamado. Agora, se atribuirmos ref ao objeto
Employee, o mtodo getName de Employee ser chamado.
public static main(String[] args) {
Person ref;
ref = studentObject; //ponteiro de referncia para um Student
String temp = ref.getName(); //getName de Student chamado
System.out.println(temp);
ref = employeeObject; // ponteiro de referncia Person para um
// objeto Employee
String temp = ref.getName(); // getName de Employee
// classe chamada
System.out.println(temp);
}
A capacidade de uma referncia mudar de comportamento de acordo com o objeto a que se refere
chamada de polimorfismo. O polimorfismo permite que mltiplos objetos de diferentes subclasses
sejam tratados como objetos de uma nica superclasse, e que automaticamente sejam selecionados
os mtodos adequados a serem aplicados a um objeto em particular, baseado na subclasse a que ele
pertena.
Outro exemplo que demonstra o polimorfismo realizado ao passar uma referncia a mtodos. Su-
pondo que exista um mtodo esttico printInformation que recebe como parmetro um objeto do
tipo Person, pode-se passar uma referncia do tipo Employee e do tipo Student, porque so subclas-
ses do tipo Person.
public static main(String[] args) {
printInformation(studentObject);
printInformation(employeeObject);
}
public static printInformation(Person p){
...
}
4. Classes Abstratas
Para criar mtodos em classes devemos, necessariamente, saber qual o seu comportamento. Entre-
tanto, em muitos casos no sabemos como estes mtodos se comportaro na classe que estamos
criando, e, por mera questo de padronizao, desejamos que as classes que herdem desta classe
possuam, obrigatoriamente, estes mtodos.
Por exemplo, queremos criar uma superclasse chamada LivingThing. Esta classe tem certos mto-
dos como breath, sleep e walk. Entretanto, existem tantos mtodos nesta superclasse que no po-
demos generalizar este comportamento. Tome por exemplo, o mtodo walk (andar). Nem todos os
seres vivos andam da mesma maneira. Tomando os humanos como exemplo, os humanos andam
sobre duas pernas, enquanto que outros seres vivos como os ces andam sobre quatro. Entretanto,
existem muitas caractersticas que os seres vivos tm em comum, isto o que ns queremos ao
criar uma superclasse geral.
Figura 4: Classe Abstrata
Para realizarmos isto, teremos que criar uma superclasse que possua alguns mtodos com imple-
mentaes e outros no. Este tipo de classe chamada de classe abstrata.
Uma classe abstrata uma classe que no pode gerar um objeto. Freqentemente aparece no topo
de uma hierarquia de classes no modelo de programao orientada a objetos.
Os mtodos nas classes abstratas que no tm implementao so chamados de mtodos abstra-

tos. Para criar um mtodo abstrato, apenas escreva a assinatura do mtodo sem o corpo e use a pa-
lavra-chave abstract. Por exemplo:
public abstract void someMethod();
Agora, vamos criar um exemplo de classe abstrata:
public abstract class LivingThing {

public void breath(){
System.out.println("Living Thing breathing...");
}
public void eat(){
System.out.println("Living Thing eating...");
}
/**
* mtodo abstrato walk
* Queremos que este mtodo seja criado pela
* subclasse de LivingThing
*/
public abstract void walk();
}
Quando uma classe estende a classe abstrata LivingThing, ela obrigada a implementar o mtodo
abstrato walk. Por exemplo:
public class Human extends LivingThing {
public void walk(){
System.out.println("Human walks...");
}
}
Se a classe Human no implementar o mtodo walk, ser mostrada a seguinte mensagem de erro
de compilao:
Human.java:1: Human is not abstract and does not override abstract
method walk() in LivingThing
public class Human extends LivingThing
^
1 error
Dicas de programao:
1. Use classes abstratas para definir muitos tipos de comportamentos no topo de uma hierarquia
de classes de programao orientada a objetos. Use suas subclasses para prover detalhes de im-
plementao da classe abstrata.
5. Interfaces
Uma interface um tipo especial de classe que contm unicamente mtodos abstratos ou atributos
finais. Interfaces, por natureza, so abstratas.
Interfaces definem um padro e o caminho pblico para especificao do comportamento de classes.

Permitem que classes, independente de sua localizao na estrutura hierrquica, implementem com-
portamentos comuns.
5.1. Porque utilizar Interfaces?
Utilizamos interfaces quando queremos classes no relacionadas que implementem mtodos simila-
res. Atravs de interfaces, podemos obter semelhanas entre classes no relacionadas sem forar
um relacionamento artificial entre elas.
Tomemos como exemplo a classe Line, contm mtodos que obtm o tamanho da linha e compara o
objeto Line com objetos de mesma classe. Considere tambm que tenhamos outra classe, MyInte-
ger, que contm mtodos que comparam um objeto MyInteger com objetos da mesma classe. Pode-
mos ver que ambas classes tm os mesmos mtodos similares que os comparam com outros objetos
do mesmo tipo, entretanto eles no so relacionados. Para se ter certeza de que essas classes im-
plementem os mesmos mtodos com as mesmas assinaturas, utilizamos as interfaces. Podemos
criar uma interface Relation que ter declarada algumas assinaturas de mtodos de comparao. A
interface Relation pode ser implementada da seguinte forma:
public interface Relation {
public boolean isGreater(Object a, Object b);
public boolean isLess(Object a, Object b);
public boolean isEqual(Object a, Object b);
}
Outra razo para se utilizar interfaces na programao de objetos revelar uma interface de progra-
mao de objeto sem revelar essas classes. Como veremos mais adiante, podemos utilizar uma in-
terface como tipo de dados.
Finalmente, precisamos utilizar interfaces como mecanismo alternativo para herana mltipla, que
permite s classes em ter mais de uma superclasse. A herana mltipla no est implementada em
Java.
5.2. Interface vs. Classe Abstrata
A principal diferena entre uma interface e uma classe abstrata que a classe abstrata pode possuir
mtodos implementados (reais) ou no implementados (abstratos). Na interface, todos os mtodos
so obrigatoriamente abstratos e pblicos, tanto que para esta, a palavrachave abstract ou public
opcional.
5.3. Interface vs. Classe
Uma caracterstica comum entre uma interface e uma classe que ambas so tipos. Isto significa
que uma interface pode ser usada no lugar onde uma classe esperada. Por exemplo, dadas a clas-
se Person e a interface PersonInterface, as seguintes declaraes so vlidas:
PersonInterface pi = new Person();
Person pc = new Person();
Entretanto, no se pode criar uma instncia de uma interface sem implement-la. Um exemplo disso
:
PersonInterface pi = new PersonInterface(); //ERRO DE
//COMPILAO !!!
Outra caracterstica comum que ambas, interfaces e classes, podem definir mtodos, embora uma
interface no possa t-los implementados. J uma classe pode.
5.4. Criando Interfaces
Para criarmos uma interface, utilizamos:

[public] [abstract] interface <NomeDaInterface> {
< [public] [final] <tipoAtributo> <atributo> = <valorInicial>; >*
< [public] [abstract] <retorno> <nomeMetodo>(<parametro>*); >*
}
Como exemplo, criaremos uma interface que define o relacionamento entre dois objetos de acordo
com a "ordem natural" dos objetos:
interface Relation {
boolean isGreater(Object a, Object b);
boolean isLess(Object a, Object b);
boolean isEqual( Object a, Object b);
}
Para implementar esta interface, usaremos a palavra chave "implements". Por exemplo:
/**
* Esta classe define um segmento de linha
*/
public class Line implements Relation {
private double x1;
private double x2;
private double y1;
private double y2;
public Line(double x1, double x2, double y1, double y2) {
this.x1 = x1;
this.x2 = x2;
this.y2 = y2;
this.y1 = y1;
}
public double getLength(){
double length = Math.sqrt((x2-x1)*(x2-x1)+(y2-y1)*(y2-y1));
return length;
}
public boolean isGreater( Object a, Object b){
double aLen = ((Line)a).getLength();
double bLen = ((Line)b).getLength();
return (aLen > bLen);
}
public boolean isLess( Object a, Object b){
return (aLen < bLen);
}
public boolean isEqual( Object a, Object b){
return (aLen == bLen);
}
}
Quando a classe implementa uma interface, deve-se implementar todos os mtodos desta, caso
contrrio ser mostrado o erro:
Line.java:4: Line is not abstract and does not override abstract
method isGreater(java.lang.Object,java.lang.Object) in Relation
public class Line implements Relation
^
1 error
Dicas de programao:
1. Use interface para criar uma definio padro de mtodos em classes diferentes. Uma vez que o
conjunto de definies de mtodos criado, e pode ser escrito um mtodo simples para manipular
todas as classes que implementam a interface.
5.5. Relacionamento de uma Interface para uma Classe
Como vimos nas sees anteriores, a classe pode implementar uma interface e para isso prover o
cdigo de implementao para todos os mtodos definidos na interface. Outro detalhe a se notar na
relao entre uma interface e uma classe. A classe pode apenas estender uma nica superclasse,
mas pode implementar diversas interfaces. Um exemplo de uma classe que implementa diversas in-
terfaces:
public class Person implements PersonInterface, LivingThing, WhateverInterface
{
//algumas linhas de cdigo
}
Outro exemplo de uma classe que estende de outra superclasse e implementa interfaces:
public class ComputerScienceStudent extends Student
implements PersonInterface, LivingThing {
// algumas linhas de cdigo
}
Uma interface no parte de uma hierarquia de classes. Classes no relacionadas podem implemen-
tar a mesma interface.
5.6. Herana entre Interfaces
Interfaces no so partes de uma hierarquia de classes. Entretanto, interfaces podem ter relaciona-
mentos entre si. Por exemplo, suponha que tenhamos duas interfaces, StudentInterface e PersonIn-
terface. Se StudentInterface estende PersonInterface, esta herda todos os mtodos declarados em
PersonInteface.
public interface PersonInterface {
...
}
public interface StudentInterface extends PersonInterface {

...
}
6. Exerccios
6.1. Estendendo StudentRecord
Neste exerccio, queremos criar um registro mais especializado de Student que contm informaes
adicionais sobre um estudante de Cincia da Computao. Sua tarefa estender a classe Studen-
tRecord que foi implementada nas lies anteriores e acrescentar atributos e mtodos que so ne-
cessrios para um registro de um estudante de Cincia da Computao.
Utilize override para modificar alguns mtodos da superclasse StudentRecord, caso seja necessrio.
6.2. A classe abstrata Shape
Crie uma classe abstrata chamada Shape com os mtodos abstratos getArea() e getName(). Escreva
duas de suas subclasses Circle e Square. E acrescente mtodos adicionais a estas subclasses.
Lio 10
1. Objetivos
Nesta lio, iremos aprender uma tcnica utilizada em Java para tratar condies incomuns que in-
terrompem a operao normal da classe. Esta tcnica chamada de tratamento de exceo.

Definir o que so excees
Tratar excees utilizando try-catch-finally
2. O que so Excees (Exception)?

Uma exceo um evento que interrompe o fluxo normal de processamento de uma classe. Este
evento um erro de algum tipo. Isto causa o trmino anormal da classe. Estes so alguns dos
exemplos de excees que podem ter ocorridos em exerccios anteriores:
ArrayIndexOutOfBoundsException, ocorre ao acessar um elemento inexistente de um array.
NumberFormatException, ocorre ao enviar um parmetro no-numrico para o mtodo Inte-

ger.parseInt().
3. Tratando Excees
Para tratar excees em Java utilizamos a declarao try-catch-finally. O que devemos fazer para
proteger as instrues passveis de gerar uma exceo, inser-las dentro deste bloco.
A forma geral de um try-catch-finally :

try{
// escreva as instrues passveis de gerar uma exceo
// neste bloco
} catch (<exceptionType1> <varName1>){
// escreva a ao que o seu programa far caso ocorra
// uma exceo de um determinado
} . . .
} catch (<exceptionTypen> <varNamen>){
// escreva a ao que o seu programa far caso ocorra
// uma exceo de um determinado tipo
} finally {
// escreva a ao que o seu programa executar caso ocorra
// ou no um erro ou exceo
}
Excees geradas durante a execuo do bloco try podem ser detectadas e tratadas num bloco cat-
ch. O cdigo no bloco finally sempre executado, ocorrendo ou no a exceo.
A seguir so mostrados os principais aspectos da sintaxe da construo de um try-catchfinally:
A notao de bloco obrigatria.
Para cada bloco try, pode haver um ou mais blocos catch, mas somente um bloco finally.
Um bloco try deve que ser seguido de PELO MENOS um bloco catch OU um bloco finally, ou
ambos.
Cada bloco catch define o tratamento de uma exceo.
O cabealho do bloco catch recebe somente um argumento, que a exceo (Exception)
que este bloco pretende tratar.
A exceo deve ser da classe Throwable ou de uma de suas subclasses. Para um melhor en-
tendimento, observe a figura 1 que demonstra o fluxo seguido pelo trycatch-finally:
Figura 1: Fluxo em um try-catch-finally

Tomemos, por exemplo, uma classe que imprime o segundo argumento passado atravs da linha de
comandos. Supondo que no h verificao no cdigo para o nmero de argumentos.
public class ExceptionExample {
System.out.println(args[1]);
System.out.println("Finish");
}
}
Ao executar esta classe sem informar nenhum argumento e, ao tentar acessar diretamente, confor-
me o exemplo descrito, o segundo argumento args[1], uma exceo obtida que interromper a
execuo normal do programa, e a seguinte mensagem ser mostrada:
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 1
at ExceptionExample.main(ExceptionExample.java:5)
Para prevenir que isto ocorra, podemos colocar o cdigo dentro de um bloco try-catch. O bloco fi-
nally opcional. Neste exemplo, no utilizaremos o bloco finally.
public class ExceptionExample{
try {
System.out.println( args[1] );
} catch (ArrayIndexOutOfBoundsException exp) {
System.out.println("Exception caught!");
}
System.out.println("Finish");
}
}
Assim, quando tentarmos rodar o programa novamente sem a informao dos argumentos, a sada
trataria a exceo e o fluxo do programa no seria interrompido, mostrando o resultado:
Exception caught!
Finish
4. Exerccios
4.1. Capturando Excees 1
Dada a seguinte classe:

public class TestException {
for (int i=0; true; i++) {
System.out.println("args["+i+"]="+ args[i]);
}
System.out.println("Quiting...");
}
}
Compile e rode a classe TestException. E como sada ser:

java TestExceptions one two three
args[0]=one
args[1]=two
args[2]=three
Exception in thread "main"
java.lang.ArrayIndexOutOfBoundsException: 3
at TestExceptions.main(1.java:4)
Modifique a classe TestException para tratar esta exceo. A sada depois do tratamento da exceo
dever ser:
java TestExceptions one two three
args[0]=one
args[1]=two
args[2]=three
Exception caught: java.lang.ArrayIndexOutOfBoundsException: 3
Quiting...
4.2. Capturando Excees 2
H uma boa chance de que algumas classes escritas anteriormentes tenham disparados excees.
Como as excees no foram tratadas, simplesmente interromperam a execuo.
Retorne a estes programas e implemente o tratamento de excees.

Apndice A
Instalao do Java e do NetBeans
1. Objetivos
Neste apndice, veremos como instalar o Java, verso JDK, e o NetBeans no seu sistema (Ubuntu
Dapper/Windows). Efetue os downloads na pgina web da Sun Microsystems no endereo http://ja-
va.sun.com para o JDK 5.0.x e na pgina web do projeto NetBeans no endereo http://www.ne-
tbeans.org/downloads para o NetBeans 5.5. Antes de comear a instalao, copie, primeiramente,
os arquivos instaladores para seu disco rgido.
Para Ubuntu Dapper:
Copie todos os instaladores para a pasta /usr.
Para Windows:
Copie os instaladores em qualquer diretrio temporrio.
2. Instalando Java no Ubuntu Dapper

Passo 1: No diretrio onde foi efetuado o download dos instaladores.
Passo 2: Antes de executar o instalador, assegure-se de que o arquivo seja um executvel. Para tan-
to, pressione o boto direito do mouse no cone do instalador, e em seguida selecione Properties.
Selecione na aba Permissions, e ento marque a opo Execute. Feche a janela.
Passo 3: Duplo-clique no arquivo jdk-1_5_0_07-linux-i586.bin. A caixa de dilogo abaixo ser mos-

trada. Pressione o boto Run in Terminal.
No console ser mostrado o contrato de licena do software. Pressione ENTER at ser mostrada a
pergunta: Do you agree to the above license terms? [yes or no]. Caso concorde com os termos
apresentados digite a palavra yes e pressione a tecla ENTER. Aguarde que o instalador termine de
descompactar e instale o Java.
Passo 4: Devemos um caminho de pesquisa a fim de permitir a execuo de comandos java em

qualquer local. Para isto, entraremos na pasta /usr/local/bin. Digitando:
cd /usr/local/bin
Para criar os links simblicos para os comandos, tecle:
sudo ln -s /usr/java/jdk1.5.0_07/bin/* .
3. Instalando Java no Windows

Passo 1: Utilizando o Windows Explorer, v at a pasta onde estiver o instalador Java.
Passo 2: Para executar o instalador, duplo-clique no cone. A caixa de dilogo do instalador J2SE ser
mostrada com o contrato. Selecione a opo I accept the terms in the license agreement caso con-
corde com os termos apresentados e pressione o boto Next >.
Figura 2: Contrato de Licena
Esta prxima janela define o que ser instalado. Pressione o boto Next > para continuar a instala-
o. O processo de instalao poder demorar um pouco, ao trmino a seguinte janela ser mostra-
da, pressione o boto Finish para completar a instalao.
4. Instalando NetBeans no Ubuntu Dapper

Passo 1: V para a pasta onde estiver o instalador do NetBeans.
Passo 2: Antes de executar o instalador, assegure-se de que o arquivo seja executvel. Para tanto,
utilize o boto direito do mouse no cone do instalador e, em seguida selecione Properties. Selecione
a aba Permissions, e marque a opo Execute. Encerre a janela.
Passo 3: Duplo-clique no arquivo de instalao do NetBeans. Pressione o boto Run in Terminal.

Ser mostrada uma caixa de dilogo do NetBeans 5.5. Pressione o boto Next >.
Na prxima janela o termos da licena sero mostrados, caso concorde selecione a opo I accept
the terms in the license agreement, e ento pressione o boto Next >.
Modifique o nome do diretrio para: /usr/java/netbeans-5.5, ento pressione o boto Next >. Na
pasta do JDK, selecione /usr/java/jdk1.5.0_07, e ento pressione o boto Next >.
A prxima caixa de dilogo mostra apenas informaes sobre o NetBeans que voc est instalando.
Pressione o boto Next >. Aguarde o NetBeans terminar o processo de instalao. Pressione o boto
Finish para completar a instalao.
Passo 4: A fim de possibilitar a execuo do NetBeans a partir de qualquer pasta no computador,
precisamos criar um caminho de pesquisa. Para isso, entramos na pasta :/usr/local/bin. com o
comando:
cd /usr/local/bin
Crie um caminho de pesquisa para o NetBeans, digitando:
sudo ln -s /usr/java/netbeans-5.5 .
possvel executar o NetBeans a partir de qualquer pasta, digitando:
netbeans &
5. Instalando NetBeans no Windows

Passo 1: Atravs do Windows Explorer, localize a pasta do instalador do NetBeans.
Passo 2: Para executar o instalador, d um duplo-clique no cone do instalador. O assistente de insta-

lao do NetBeans ser mostrado. Pressione o boto Next > para iniciar o processo de instalao.
A pgina do contrato ser mostrada. Caso concorde com os termos selecione a opo I accept the
terms in the license agreement e pressione o boto Next > para continuar.
O instalador solicitar a pasta que deve ser instado o NetBeans. Se desejar modifique a pasta suge-
rida pressionando o boto Browse, e ao trmino pressione o boto Next >.
O prximo passo selecionar uma JDK existente em seu computador. Pressione o boto Next> para
continuar.
Em seguida, o instalador informar a localizao e o espao em disco que o NetBeans ir ocupar de-
pois de instalado no seu computador. Pressione o boto Next > e aguarde o trmino da instalao.
No momento que o NetBeans terminar de ser instalado em seu computador. Pressione o boto
Finish para encerrar o processo.

Hino Nacional Hino do Estado do Cear
Ouviram do Ipiranga as margens plcidas Poesia de Thomaz Lopes

De um povo herico o brado retumbante, Msica de Alberto Nepomuceno
E o sol da liberdade, em raios flgidos, Terra do sol, do amor, terra da luz!
Brilhou no cu da ptria nesse instante. Soa o clarim que tua glria conta!
Terra, o teu nome a fama aos cus remonta
Se o penhor dessa igualdade Em claro que seduz!
Conseguimos conquistar com brao forte, Nome que brilha esplndido luzeiro
Em teu seio, liberdade, Nos fulvos braos de ouro do cruzeiro!
Desafia o nosso peito a prpria morte!
Mudem-se em flor as pedras dos caminhos!
Ptria amada, Chuvas de prata rolem das estrelas...
Idolatrada, E despertando, deslumbrada, ao v-las
Salve! Salve! Ressoa a voz dos ninhos...
H de florar nas rosas e nos cravos
Brasil, um sonho intenso, um raio vvido Rubros o sangue ardente dos escravos.
De amor e de esperana terra desce, Seja teu verbo a voz do corao,
Se em teu formoso cu, risonho e lmpido, Verbo de paz e amor do Sul ao Norte!
A imagem do Cruzeiro resplandece. Ruja teu peito em luta contra a morte,
Acordando a amplido.
Gigante pela prpria natureza, Peito que deu alvio a quem sofria
s belo, s forte, impvido colosso, E foi o sol iluminando o dia!
E o teu futuro espelha essa grandeza.
Tua jangada afoita enfune o pano!
Terra adorada, Vento feliz conduza a vela ousada!
Entre outras mil, Que importa que no seu barco seja um nada
s tu, Brasil, Na vastido do oceano,
Ptria amada! Se proa vo heris e marinheiros
Dos filhos deste solo s me gentil, E vo no peito coraes guerreiros?
Ptria amada,Brasil!
Se, ns te amamos, em aventuras e mgoas!
Porque esse cho que embebe a gua dos rios
Deitado eternamente em bero esplndido, H de florar em meses, nos estios
Ao som do mar e luz do cu profundo, E bosques, pelas guas!
Fulguras, Brasil, floro da Amrica, Selvas e rios, serras e florestas
Iluminado ao sol do Novo Mundo! Brotem no solo em rumorosas festas!
Abra-se ao vento o teu pendo natal
Do que a terra, mais garrida, Sobre as revoltas guas dos teus mares!
Teus risonhos, lindos campos tm mais flores; E desfraldado diga aos cus e aos mares
"Nossos bosques tm mais vida", A vitria imortal!
"Nossa vida" no teu seio "mais amores." Que foi de sangue, em guerras leais e francas,
E foi na paz da cor das hstias brancas!
Ptria amada,
Idolatrada,
Salve! Salve!
Brasil, de amor eterno seja smbolo

O lbaro que ostentas estrelado,
E diga o verde-louro dessa flmula
- "Paz no futuro e glria no passado."
Mas, se ergues da justia a clava forte,

Vers que um filho teu no foge luta,
Nem teme, quem te adora, a prpria morte.
Terra adorada,
Entre outras mil,
s tu, Brasil,
Ptria amada!
Dos filhos deste solo s me gentil,
Ptria amada, Brasil!

Informatica Programacao Orientada A Objeto1 PDF

Загружено:

Сведения о документе

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Informatica Programacao Orientada A Objeto1 PDF

Загружено:

Авторское право:

Доступные форматы

Escola Estadual de

Educao Profissional - EEEP

Curso Tcnico em Informtica

Assessora Institucional do Gabinete da Seduc

Coordenadora de Desenvolvimento da Escola

Coordenadora da Educao Profissional SEDUC

9.3. System.out.println( ) e System.out.print( ).........................................................................35

4.1. Mtodos assessores..........................................................................................................107

4.2. Capturando Excees 2....................................................................................................136

Informtica - Programao Orientada a Objetos I 5

Florence Tiu Balagtas

Sistemas Operacionais Suportados

NetBeans IDE 5.5 para os seguintes sistemas operacionais:

Microsoft Windows XP Profissional SP2 ou superior

Microsoft Windows 2000 Profissional SP4

Nota: IDE NetBeans com resoluo de tela em 1024x768 pixel

Sistema Operacional Processador Memria HD Livre

Microsoft Windows 500 MHz Intel Pentium III

Configurao Recomendada de Hardware

Sistema Operacional Processador Memria HD Livre

Microsoft Windows 1.4 GHz Intel Pentium III

Colaboradores que auxiliaram no processo de traduo e reviso

Reviso Geral do texto para os seguintes Pases:

Brasil Tiago Flach

Daniel de Oliveira JU GLeader responsvel pelos acordos de parcerias

Luci Campos - Idealizadora do DFJUG responsvel pelo apoio social

Fernando Anselmo - Coordenador responsvel pelo processo de traduo e reviso,

disponibilizao dos materiais e insero de novos mdulos

Regina Mariani - Coordenadora responsvel pela parte jurdica

Rodrigo Nunes - Coordenador responsvel pela parte multimdia

Srgio Gomes Veloso - Coordenador responsvel pelo ambiente (Moodle)

Rommel Feria Criador da Iniciativa

Figura 1: James Gosling criador do Java

A motivao original do Java era a necessidade de uma linguagem indepen-

Ao mesmo tempo, a World Wide Web e a Internet foram ganhando popula-

2.2. O que uma tecnologia JAVA?

2.2.1. Uma linguagem de programao

Como ambiente de desenvolvimento, a tecnologia Java fornece um grande conjunto deferramentas:

2.2.3. Um ambiente de aplicao

2.2.4. Um ambiente de distribuio

Figura 3: JDK e JRE

2.3. Algumas Caractersticas do JAVA

2.3.1. Mquina Virtual Java

2.3.2. Garbage Collection

Muitas linguagens de programao permitem ao programador alocar memria durante o tempo de

Isso acontece automaticamente durante o tempo de vida do programa Java.

2.3.3. Segurana de cdigo

Segurana do Cdigo alcanada em Java atravs da implementao da Java Runtime Environment

2.4. Fases do Java programa

A figura seguinte descreve o processo de compilao e execuo de um programa Java. O primeiro

Figura 1: Fases de um Programa Java.

Tarefa Ferramenta utilizada Sada

Tabela 1: Resumo das fases de um programa Java.

3. Primeiro Programa Java

3.1. Utilizando a Console e um editor de texto

Passo 1: executar um editor de texto

Accessories Text Editor. Para

Passo 2: Abrir a janela de console

Passo 3: Escrever as instrues utilizando o Editor de Texto

Digite as seguintes instrues no editor de textos:

Chamaremos o programa de "Hello.java" e o colocaremos em uma pasta denominada "myJavaPro-

Passo 6: Compilar o programa

Para compilar o programa, utilizamos o comando: javac [Nome do Arquivo]. Ou seja: