0% acharam este documento útil (0 voto)

5 visualizações

Apostila Java

Enviado por

josiel.dimas

Direitos autorais

Formatos disponíveis

Baixe no formato PDF, TXT ou leia on-line no Scribd

0% acharam este documento útil (0 voto)

5 visualizações

Apostila Java

Enviado por

josiel.dimas

Direitos autorais

Formatos disponíveis

Baixe no formato PDF, TXT ou leia on-line no Scribd

Você está na página 1/ 86

Java Prático

para Engenheiros e Cientistas

(Rascunho)
Atualizado para Java 6 e Eclipse 3.4.X

Rafael de Pelegrini Soares

www.rps.eng.br

25 de Setembro de 2012
Conteúdo

I Básico 4

1 Iniciando 5
1.1 Porque Java? . . . . . . . . . . . . . . . . . . . 6
1.2 JVM – Java Virtual Machine . . . . . . . . . . . 7
1.3 Mas Java não é . . . . . . . . . . . . . . . . . . . 8
1.4 Preparando o Sistema . . . . . . . . . . . . . . . 9
1.4.1 Instalando o JDK . . . . . . . . . . . . . 9
1.4.2 Instalando o Eclipse IDE . . . . . . . . . . 11
1.5 O Primeiro Programa . . . . . . . . . . . . . . . 12
1.6 Imprimindo e Lendo do Console . . . . . . . . . . 18

2 Programação Tradicional 22
2.1 Noções Básicas . . . . . . . . . . . . . . . . . . . 23
2.2 Tipos Primitivos . . . . . . . . . . . . . . . . . . 24
2.3 Comentários . . . . . . . . . . . . . . . . . . . . 26
2.4 Operadores . . . . . . . . . . . . . . . . . . . . . 27
2.4.1 Atribuição . . . . . . . . . . . . . . . . . 28
2.4.2 Operadores Aritméticos . . . . . . . . . . 28
2.4.3 Cast . . . . . . . . . . . . . . . . . . . . 29
2.4.4 Incremento e Decremento . . . . . . . . . 29
2.4.5 Operadores Relacionais . . . . . . . . . . 31
2.4.6 Operadores Booleanos . . . . . . . . . . . 32
2.4.7 Ordem de Precedência . . . . . . . . . . . 32
2.5 Tratando Textos com os String’s . . . . . . . . 33
2.6 Loop while . . . . . . . . . . . . . . . . . . . . 36
2.7 Loop for . . . . . . . . . . . . . . . . . . . . . 36
2.8 Utilizando break e continue . . . . . . . . . 36
2.9 Precisão dos Números em uma Máquina . . . . . 36
2.10 Condicionais com if . . . . . . . . . . . . . . . 37
2.11 A classe Math . . . . . . . . . . . . . . . . . . . 37
2.12 Funções e Variáveis Estáticas (static) . . . . . 37
2.12.1 Declaração de Funções . . . . . . . . . . . 38
2.12.2 Chamando Funções . . . . . . . . . . . . 39
2.12.3 Variáveis Locais e static . . . . . . . . 39

3 Programação Orientada a Objetos 40

3.1 Objetos, Funções de Objetos e Variaveis de Objeto 41
3.1.1 Objetos vs. Classes . . . . . . . . . . . . 41
3.1.2 Mais sobre Objetos . . . . . . . . . . . . 42
3.2 Construtores e a Inicialização de Objetos . . . . . 44
3.3 Modificadores public e private . . . . . . . 46
3.3.1 Getter’s e Setter’s . . . . . . . . . . . . . 48
3.4 Vetores e Matrizes . . . . . . . . . . . . . . . . . 49
3.5 Algumas classes do java.util . . . . . . . . . 51
3.6 Inheritance . . . . . . . . . . . . . . . . . . . . . 52
3.6.1 Inheritance - Estendendo Classes . . . . . 52
3.7 Classes Abstratas e Interfaces . . . . . . . . . . . 54
3.8 Lists . . . . . . . . . . . . . . . . . . . . . . . . 54
3.9 Arquivos . . . . . . . . . . . . . . . . . . . . . . 54
3.10 Unidades de Medida . . . . . . . . . . . . . . . . 54

4 Interfaces Gráficas 55
4.1 Introdução . . . . . . . . . . . . . . . . . . . . . 56
4.2 JFrame . . . . . . . . . . . . . . . . . . . . . . 56
4.3 Layout . . . . . . . . . . . . . . . . . . . . . . . 58
4.3.1 BorderLayout . . . . . . . . . . . . . . . . 58
4.3.2 FlowLayout e GridLayout . . . . . . . . . 58
4.4 Layouts combinados com o JPanel . . . . . . . 59
4.5 Listeners . . . . . . . . . . . . . . . . . . . . . . 61
4.6 JLabel e JTextField . . . . . . . . . . . . . 62

II Aplicações 64

5 Funções Monovariáveis 65
5.1 Representando Funções Monovariáveis . . . . . . 66
5.2 Raizes de Funções Monovariáveis . . . . . . . . . 66
5.3 Derivadas e o Método de Newton . . . . . . . . . 66
5.4 Integral Aproximada de Funções Monovariáveis . . 66
5.5 Ajustando Retas e Polinômios . . . . . . . . . . . 66
5.6 Interpolação Linear e Cúbica . . . . . . . . . . . . 66

6 Sistemas de Equações 67
6.1 Sistemas de Equações Lineares . . . . . . . . . . 68
6.2 Sistemas de Equações Não-Lineares . . . . . . . . 68
6.3 Sistemas de Equações Diferenciais Ordinárias . . . 68

7 Conteúdo Extra 69
7.1 Estatı́stica . . . . . . . . . . . . . . . . . . . . . 70
7.2 Distribuições e Testes . . . . . . . . . . . . . . . 70

III Apêndices 71

Lista de Atalhos 72

A Padrões de Codificação 73
A.1 Porque Padrões de Codificação? . . . . . . . . . . 74
A.2 Organização dos Arquivos . . . . . . . . . . . . . 74
A.2.1 Comentários Iniciais . . . . . . . . . . . . 74
A.2.2 Comandos Package e Import . . . . . . . 74
A.2.3 Declaração de Classes e Interfaces . . . . . 75
A.2.4 Organização e Indentação . . . . . . . . . 76
A.3 Convenções de Nomes . . . . . . . . . . . . . . . 77
Sı́mbolos e Convenções

Funções e palavras-chave são enfatizados com uma fonte dife-

Códigos e rente. Exemplo de função seria println e de palavra-chave
Palavras-Chave seria package.
A sequencia de ações para acessar um comando dentro de um
Comandos em Menus menu é representada da seguinte forma: File I Open.
Um trecho de código escrito em Java ou impressões em um
Códigos e Impressões console são apresentados da seguinte forma:
1 package java.prat;

3 /**
4 * Class documentation goes here.
5 *
6 * @author rafael
7 */
8 class ClassName {
9 // This is a single line comment
10 }

Nota: sı́mbolo para uma um ponto importante, preferencialmente

deve ser memorizado.

Dica: Sı́mbolo utilizado para uma dica de utilização. Normal-

mente relacionada com alguma ferramenta em particular e não
com Java em geral.

Linux: Sı́mbolo para uma nota especı́fica para plataformas Linux,

provavelmente se aplica também para sistemas Unix e Solaris.

Windows: Sı́mbolo para uma nota especı́fica para plataformas

Windows (apenas Windows XP e superiores).
Prefácio

Este livro foi desenvolvido com base no material desenvolvido

para o curso de Java para Engenharia Quı́mica da Universidade
Federal do Rio Grande do Sul.
A motivação de produzir este material veio da experiência com
diversas linguagem e ambientes de desenvolvimento. Já utilizei
muito as mais diversas linguagens que supostamente são adequa-
das o desenvolvimento de programas no contexto da engenharia
e para fazer ciência. Iniciei a programar em Pascal em 1997,
quando estava no inı́cio do curso de Engenharia Quı́mica. Fiz uma
disciplina de linguagem C em 1998 onde as aulas eram dadas em
um quadro negro, não havia computadores para testar os conhe-
cimentos. Nestas aulas, compilar o código era algo apenas dito
que seria necessário. As provas tratavam da solução de proble-
mas de programação, mas as resolvı́amos apenas mentalmente e
entregávamos o código escrito a mão em papel. No ano seguinte
iniciei dois cursos novos de programação, agora já no Departa-
mento de Engenharia Quı́mica da UFRGS. Lá já tı́nhamos um
laboratório com computadores para o curso, alguns bons 486’s
com compiladores e editores de texto tipo tela preta. Estes cursos
eram de linguagem C e do já antigo FORTAN 77, que resiste até
hoje. Por exemplo, os principais códigos para solução de sistemas
de equações algébrico-diferenciais ainda são mantidos no bom e
velho FORTRAN 77 (ver ??). A cultura do FORTRAN é tão
arraigada entre os engenheiros e ciêntistas que o seu abandono
parece ser impossı́vel. As suas limitações são continuamente di-
minuidas através de adaptações: FORTRAN 90, FORTRAN 95,
etc. Ao meu ver estas adaptações são nada elegantes e muitas
vezes implementadas de forma diferente entre os fabricantes de
compiladores, um grande gerador de dor-de-cabeça. Além das
já citadas clássicas linguagens de programação utilizadas entre
os engenheiros e cientistas, também conheço muito bem o C++,
MatLab, Python e, é claro, Java.
Minha experiência com Java é muito menor do que com C++.
EMSO é a sigla para Environment
for Modeling, Simulation, and Fui o principal desenvolvedor do simulador dinâmico de processos
Optimization, mais detalhes em conhecido como EMSO, todo em C++. Com o passar do tempo,
www.enq.ufrgs.br/alsoc.
a manutenção de um sistema complexo como este começou a de-
mandar cada vez mais tempo. A adição de novas funcionalidades
e a correção de defeitos se tornou cada vez mais complicada para
2

a pequena equipe envolvida. Além disso, códigos escritos em C++

precisam ser compilados especificamente para as máquinas onde
serão executados. Dar suporte para plataformas Windows 32 bits
e para uma distribuição Linux em especı́fico já era difı́cil. O ideal
seria também ter executáveis para Windows 64 bits, diversas dis-
tribuições Linux tanto em 32 quanto 64 bits, outros tipos de Unix
e Solaris. Para uma pequena equipe este problema é intratável.
Por outro lado, formar novos programadores em C++ não é uma
tarefa tão simples. Para os inexperientes as mensagens de erro
dos compiladores são difı́ceis de decifrar. Se o erro acontece na
etapa de lincagem, a situação é ainda pior.
Na busca por alternativas para estes problemas e outros (que não
comentei para que este texto não ficasse entediante) encontrei
o Java. Essa nova plataforma me surpreendeu de diversas ma-
neiras e esta obra tenta trazer estas agradáveis surpresas a mais
pessoas. A idéia deste livro não é tratar somente a linguagem
de programação Java, mas também as ferramentas atualmente
disponı́veis para o desenvolvimento utilizando esta linguagem.
Aqui a solução de problemas mais complexos, por exemplo que en-
volvem a solução de sistemas de equações diferenciais ordinárias,
é auxiliada através da utilização de bibliotecas disponı́veis livre-
mente na internet. Esta abordagem prática através da reutilização
de ferramentas e códigos disponı́veis sem custo é o diferencial
deste livro.

Prof. Rafael de Pelegrini Soares, DSc.

Departamento de Engenharia Quı́mica
Escola de Engenharia
Universidade Federal do Rio Grande do Sul
Obras Consultadas

As principais fontes consultadas para a produção deste livro foram:

• Introduction to Programming Using Java, Fifth Edition Version 5.0, December 2006,
http://math.hws.edu/javanotes/
• The Java Tutorials, http://java.sun.com/docs/books/tutorial/
• How to Write Doc Comments for the Javadoc Tool, http://java.sun.com/
j2se/javadoc/writingdoccomments/
I. Básico
1 Iniciando

Neste capı́tulo vamos construir nosso primeiro programa em Java. Para isto vamos precisar de
algumas ferramentas e aqui apresentamos também como obter e instalar estas ferramentas.

Sumário
1.1 Porque Java? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.2 JVM – Java Virtual Machine . . . . . . . . . . . . . . . . . . . . . 7
1.3 Mas Java não é . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.4 Preparando o Sistema . . . . . . . . . . . . . . . . . . . . . . . . . 9
1.5 O Primeiro Programa . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.6 Imprimindo e Lendo do Console . . . . . . . . . . . . . . . . . . . 18
6 1 Iniciando

1.1 Porque Java?

A minha motivação para a utilização de Java foi dada no prefácio

(na página 1): baixo tempo de desenvolvimento e facilidade de
manutenção. O que quero dizer com isto fica mais claro com um
exemplo concreto. Vamos considerar os cursos de programação
em linguagem C ou FORTRAN ministrados para estudantes da
engenharia, fı́sica e áreas correlatas. Com uma carga horária para
um semestre, o aluno aprende a programar precariamente, seus
programas tendem a ser mal organizados e a interface com o
usuário utilizador do programa é invariavelmente um console
dizendo algo do tipo:
Choose the desired vapor pressure equation:
1 - Antoine
2 - Watson

Select the equation number and press enter:

Com o mesmo tempo de curso e a mesma categoria de alunos é

possı́vel formar programadores Java capazes de fazer mais e que
escrevem códigos mais elegantes. Os programas gerados resolvem
problemas mais complexos, apresentam gráficos e interagem com
o usuário na forma de interfaces gráficas.

Como isto é possı́vel? Isto é possı́vel porque o aluno não vai per-
der horas decifrando uma mensagem de erro de compilação na
linha 3560 do arquivo stdio.h. Não vai ter que compreender
como funciona de fato a memória do computador para que alo-
Muitos compiladores limitam o
número máximo de erros que memória dinâmicamente (e que não esqueça de liberar esta
apresentados para 100, evitando memória mais tarde). Ou então indo atrás de 100 unresolved
que travem devido ao excessivo
número de erros. symbol que apareceram porque o compilador foi atualizado para
uma versão mais recente.

Ao contrário, quando utilizar Java o estudante terá disponı́vel

um sistema inteligente, que lista as possı́veis soluções para er-
ros de digitação e que tenta adivinhar o que o programador quer
dizer. O estudante poderá utilizar as diversas bibliotecas já desen-
volvidas pela comunidade, o que permitirá a solução de problemas
mais complexos. A construção de interfaces gráficas também é
facilitada com a disponibilidade de botões, campos de texto e
todo o tipo de controles para interagir com o usuário, além de
biblitecas para a geração de gráficos em 2 e 3 dimensões.

E o melhor, os programas gerados rodam sem alterações em Win-

dows, Linux, Solaris e até através da web.
1.2 JVM – Java Virtual Machine 7

1.2 JVM – Java Virtual Machine

O conjunto de instruções mais
conhecido e de maior sucesso As instruções que os computadores tratam diretamente são co-
comercial é referenciado pelo termo nhecidas como linguagem de máquina. Diferentes arquiteturas
genérico x86.
podem implementar diferentes conjutos de instruções, isto torna
códigos em linguagem de máquina incompatı́veis entre diferentes
arquiteturas. Um programa de computador, que é uma sequencia
de instruções de máquina, é representado em última instância por
números binários (0’s e 1’s).
É claro que para um ser humano não é nada conveniente escre-
ver programas de computador em linguagem de máquina. Sendo
assim todas as linguagens de programação são tentativas de fa-
cilitar a nossa vida, algumas mais bem sucedidas e outras nem
tanto. Quando utilizamos linguagens como C, C++ e FORTRAN
o papel da ferramenta conhecida como compilador é traduzir as
instruções do programador em código de máquina. Como diferen-
tes arquiteturas implementam diferentes conjuntos de instruções,
o código gerado será especı́fico para uma determinada arquite-
tura. Além disso, parte das instruções presentes nos programas
são tratadas pelo próprio sistema operacional. Sendo assim, pro-
gramas compilados desta forma só podem ser executados em um
par especı́fico de sistema operacional–arquitetura.
Em comparação com o C++ Java
também disponibiliza menos A linguagem de programação Java foi inspirada no C++, mas
funções de baixo nı́vel. torna vários conceitos mais simples. Programas escritos em Java
também são compilados para código de máquina, mas para um
computador que na verdade não existe. Esta máquina virtual é
conhecida como a Java Virtual Machine – JVM.
O código de máquina que é executado em uma JVM é conhecido
como Java bytecode, aqui vamos referenciar este termo simples-
mente como bytecode. Este processo de compilação do bytecode
para a posterior execução por uma JVM está representado na Fi-
gura 1.1.

Figura 1.1: Processo de

compilação para posterior
execução em uma máquina
virtual.
8 1 Iniciando

É claro que precisamos de uma JVM diferente para cada tipo de

computador. Mas, uma vez que a máquina tem uma JVM insta-
lada, ela pode rodar um bytecode de Java. A consequencia disso
é que um mesmo bytecode pode rodar virtualmente em qualquer
computador. Esta é uma caracterı́stica essencial do Java: per-
mitir a execução do mesmo programa em diferentes máquinas,
sem a necessidade de recompilação do código.

Nota: Para muitas plataformas temos disponı́vel apenas a JVM

e não temos um compilador de Java. Isto porque o compilador
é um programa muito mais complexo que a própria JVM.

O primeiro conjunto de compilador, máquina virtual e bibliotecas

Java foi disponibilizado pela Sun em 1995. Atualmente existem
diversas implementações de virtual machines e compiladores. Em
Mais detalhes sobre o processo de
abertura do código Java da Sun 2005 a Sun disponibilizou boa parte da sua tecnologia Java na
podem ser encontrados em forma de código livre sob os termos da licensa GPL. Em 2007 a
http://www.itworld.com/
070508opsjava. Sun finalizou o processo de abertura da sua implementação Java,
tornando todo o cerne do Java código livre, com excessão de
uma pequena parte da qual a Sun não é detentora dos direitos
autorais.
A versão atualmente (2009) distribuı́da pela Sun é o Java 6.
Também existem implementações
de JVM para rodar em outros Estão disponı́veis JVM para Windows, Linux, Mac OS X e So-
dispositivos, como por exemplo laris em diversas plataformas. Na verdade a Sun diferencia seus
telefones celulares.
pacotes Java entre:
JDK : O pacote do desenvolvedor (Java Development Kit). Contém
o compilador e outros utilitários, além da virtual machine.
JRE : O pacote mı́nimo para rodar bytecode de Java (Java Run-
time Environment). Contém basicamente a virtual machine
e as bibliotecas padrões, não é capaz de compilar código
fonte. A maioria das instalações de Linux e Windows atu-
ais contém a instalação de uma JRE.

1.3 Mas Java não é . . .

Lento : Existe o mito de que Java é lento. Este fato me manteve
distante do Java por muito tempo. Isto porque sempre tra-
balhei com aplicações que requerem muito da máquina. De
fato, inclusive hoje uma aplicação desenvolvida em Java
tende a ser mais lenta que uma escrita em C++ ou FORTRAN.
Isto é natural, uma vez que um programa compilado para
código de máquina é executado diretamente pelo proces-
sador. Já o bytecode de Java é executado pela máquina
1.4 Preparando o Sistema 9

virtual e não diretamente pelo processador. Entretanto,

as virtual machines (ver Seção 1.2) tendem a ser cada vez
mais otimizadas tornando a tecnologia Java cada vez mais
competitiva. De qualquer forma, boa parte dos problemas
relacionados com a engenharia e ciências são resolvidos em
alguns milisegundos tanto quando programados em Java
quanto em qualquer outra linguagem. Já para os casos onde
a carga computacional é mais crı́tica outra regra pode se
aplicar: o tempo economizado no desenvolvimento de um
programa e na sua posterior manutenção é capaz de pagar
por uma máquina muito mais potente.
Claro que em alguns casos de missão crı́tica ainda é acon-
selhado utilizar um código otimizado em C ou FORTRAN.
JNI é a sigla para Java Native
Interface, um mecanismo que De qualquer forma ainda podemos encapsular estes códigos
permite utilizar códigos nativos através de JNI e fazer todo o resto em Java. Esta técnica
compiliados em qualquer outra
linguagem. é aconselhada, por exemplo, para a solução de sistemas
de álgebra linear de grande dimensão. Existem inclusive
códigos para a solução de problemas de álgebra linear oti-
mizados pelos fabricantes de processadores, porém que fun-
cionam apenas para o processador para o qual foi projetado.
Para Internet : Muitas pessoas quando escutam falar em Java logo asso-
ciam com algo para a programação de páginas na internet
e coisas relacionadas. De fato Java ganhou fama pela sua
Quando um programa escrito em
Java roda a partir da internet este utilização como programação voltada para a internet, mas
é conhecido como um Applet. é uma linguagem de programação geral. Neste livro va-
mos focar na produção de aplicativos que serão executados
localmente na máquina (e não através da web) de forma
análoga aos executáveis criados com C, FORTRAN, etc.

1.4 Preparando o Sistema

Como vamos precisar compilar nossos programas escritos em Java
será necessário ter instalado não só uma JVM, mas também um
compilador Java e outros utilitários.

1.4.1 Instalando o JDK

Neste livro vamos utilizar o Sun SE Development Kit (JDK)

versão 6 ou a versão livre OpenJDK mantida pelo projeto Iced-
Tea. Ambos são equivalentes nas funcionalidades que vamos uti-
lizar. O pacote da SUN pode ser baixado sem custo no site
da Sun http://java.sun.com para diversas plataformas.
O pacote mantido pelo IcedTea está disponı́vel para a maioria
das distribuições Linux ou pode ser obtido através do endereço
http://icedtea.classpath.org.
10 1 Iniciando

Neste livro há um forte apelo para a utilização do Linux. Este livro
O Ubuntu Linux pode ser baixado
de http://www.ubuntu.com. e todo o seu conteúdo foram gerados utilizando uma instalação
de Ubuntu Linux. É claro que sou um entusiasta do Linux e reco-
mendo a sua utilização, entretanto não há nenhum problema em
acompanhar este livro em uma instalação Windows XP e superi-
ores.

Linux: Para instalar um JDK basta abrir seu gerenciador de

pacotes favorito e selecionar o pacote sun-java6-sdk ou
openjdk-6-jdk para instalação.

A instalação da JDK introduz diversos arquivos no sistema. Na

Figura 1.2 é apresentada a árvore de diretórios de uma instalação
de um Sun JDK 6 em um Linux.

Figura 1.2: Árvore de

diretórios de uma instalação
de um Sun JDK 6.

Dentro da pasta bin da JDK encontramos o programa javac.

Neste livro não vamos utilizar
diretamente o compilador javac, Este é o compilador de Java, capaz de converter códigos em
mas sim um ambiente que fará este Java para bytecode. Como pode ser visto na Figura 1.2 a JDK
trabalho para nós.
contém uma JRE (pasta jre). Dentro da JRE há uma pasta
chamada bin onde encontramos o executável chamado java.
Este é o programa que é capaz de executar o bytecode: é a virtual
machine.
1.4 Preparando o Sistema 11

Nota: Se o objetivo é apenas executar seu bytecode Java é

necessária apenas a instalação de uma JVM, por exemplo o
Sun SE Runtime Environment (JRE) versão 6. No Linux se-
ria necessário apenas instalar o pacote openjdk-6-jre ou
sun-java6-jre.

1.4.2 Instalando o Eclipse IDE

O ciclo de trabalho no desenvolvimento com Java pode ser re-

sumido em:
1. Codificação do programa na linguagem Java
2. Compilação para bytecode
3. Execução do programa em uma JVM
4. Melhorias e correções no código, voltando ao 1
Estas tarefas podem ser feitas de uma forma rudimentar apenas
com um editor de textos e com uma instalação JDK. Assim, o
código seria construı́do em um editor de textos como o notepad
ou gedit. A compilação se daria através de uma chamada ao
programa javac e a execução com uma chamada ao programa
java. As linhas abaixo exemplificam como seriam estas chama-
das:
$ javac Hello.java
$ java Hello

A primeira linha acima converteria o código fonte presente no

arquivo Hello.hava criando o bytecode Hello.class. A
segunda linha faria com que a JVM executasse o bytecode do
programa.
O desenvolvimento desta forma é entediante e propenso a erros,
pricipalmente quando o projeto passa a envolver dezenas de arqui-
vos de código fonte. A ferramenta que auxilia e muito em todas as
tarefas mencionadas acima é conhecida como ambiente de desen-
volvimento (Integrated Development Environment – IDE). Hoje o
conceito de programação passa obrigatoriamente pelo ambiente
de desenvolvimento e este é um ponto onde Java se destaca.
Existem ambientes de desenvolvimento muito bem desenvolvidos
para Java. Entre os ambientes livres disponı́veis destacam-se o
Eclipse e o NetBeans.
Neste livro vamos utilizar o Eclipse versão 3.4, disponı́vel gratui-
tamente em http://www.eclipse.org. O Eclipse é confi-
12 1 Iniciando

gurável para a utilização na programação de diversas linguagens

diferentes, vamos utilizar do pacote preparado para o desenvol-
vimento com Java. Este pacote está identificado no site como
Eclipse IDE for Java Developers. O Eclipse em si é também es-
crito em Java, sendo assim ele precisa de uma JVM instalada
para rodar. Como vamos fazer desenvolvimentos em Java, além
de uma JVM, precisamos de uma JDK para compilar os códigos.

Nota: Na verdade o Eclipse não precisa ser instalado, basta des-

compactar o pacote obtido no site www.eclipse.org e exe-
cutar o programa eclipse que acompanha o pacote.

Linux: Basta selecionar o pacote eclipse-jdt para instalação

no seu gerenciador de pacotes favorito. Claro que também pode
ser baixado de www.eclipse.org, onde está disponı́vel a
versão mais recente.

1.5 O Primeiro Programa

O Eclipse é baseado no conceito de Workspace. O Workspace é

uma pasta onde são guardadas todas as configurações do usuário
e será também a pasta preferencial para guardar os projetos de-
senvolvidos dentro do ambiente. Assim, quando o Eclipse é exe-
cutado a primeira coisa a fazer é selecionar uma pasta para o
Workspace. Isto se dá pela configuração do diálogo como exibido
na Figura 1.3.

Figura 1.3: Tela de

configuração do Workspace
do Eclipse.
1.5 O Primeiro Programa 13

Nota: Sempre selecione uma pasta para o Workspace onde você

tenha direitos de escrita.

Após a seleção do Workspace, na primeira vez que o Eclipse é

executado, uma tela de boas-vindas é exibida. Neste ponto você
deve estar observando uma tela como a da Figura 1.4. Se você
não está vendo esta tela ou a fechou por acidente basta ir no
menu Help I Welcome. Nesta tela, cada ı́cone representa um
link para um ponto diferente. Aproveite para explorar o conteúdo
do Overview, onde o funcionamento de Eclipse é explicado.

Figura 1.4: Tela de

boas-vindas do Eclipse.

Depois de explorar um pouco o Overview e os diversos menus

disponı́veis no Eclipse, volte a tela de boas-vindas através do menu
Help I Welcome. Clique em Tutorials para chegar em uma tela
como a exibida na Figura 1.5.
Neste ponto vamos executar o tutorial Create a Hello World ap-
plication. Para isso basta clicar o link com o nome do tutorial e
seguir as instruções na tela.
Este tutorial consiste na criação do famoso programa Hello World.
Este programa é um aplicativo que simplesmente imprime a frase
Hello world! em um console quando é executado.
Embora este tutorial possa ser seguido inteiramente com as ins-
truções apresentadas pelo Eclipse, aqui vamos reproduzir os prin-
cipais passos. O primeiro passo é a criação de um novo pro-
jeto de Java. Se você estiver utilizando o tutorial assistido do
14 1 Iniciando

Figura 1.5: Tela de tutoriais

do Eclipse.

Eclipse, isto pode ser feito clicando em Click to perform

dentro de Create a Java Project. O mesmo efeito é ob-
tido clicando no menu File I New I Java Project. Neste ponto
você deve estar visualizando uma tela como a apresentada na Fi-
gura 1.6.
Aqui vamos nomear o nosso projeto de Hello e deixar as demais
configurações na sua forma padrão. Isto significa que uma pasta
A pasta src é onde ficam os
códigos fontes, é a abreviação para com o nome Hello será criada dentro do nosso Workspace e
source. Os códigos compilados em que vamos utilizar o JRE padrão instalado na máquina. Ao pres-
bytecode ficam dentro da pasta
bin, que é a abreviação para sionar Finish na janela de configuração, o projeto é criado e
binary.
as pastas relacionadas com ele também. Por padrão, duas pastas
são criadas dentro da pasta de um projeto novo: a pasta src e
a pasta bin. A Figura 1.7 apresenta a tela resultante da criação
do projeto.
A Figura 1.7 aprensenta uma tela tı́pica do Eclipse, sendo com-
posta por várias sub-janelas ou simplesmente abas. A principal
aba no densenvolvimento em Java é a Package Explorer.
Nesta aba podemos explorar o conteúdo do nosso projeto.
Para o nosso projeto recém criado, a aba Package Explorer
O Package Explorer do Eclipse
não exibe a pasta bin para não apresenta a pasta src e o elemento JRE System Library.
poluir o projeto. Embora o nosso projeto também contenha uma pasta bin, esta
não é exibida pelo Package Explorer. Por outro lado, nosso
projeto não contém uma pasta JRE System Library e esta
é apresentada dentro do projeto pelo Package Explorer. O
elemento JRE, exibido pelo Package Explorer, representa as
bibliotecas padrões do Java, que estão sempre disponı́veis para
1.5 O Primeiro Programa 15

Figura 1.6: Configuração de

um novo projeto de Java no
Eclipse.

um projeto de Java. Vamos utilizar várias destas bibliotecas e o

Eclipse vai tornar esta tarefa muito fácil.

Dica: Abra a pasta Hello encontrada dentro do seu Workspace

em um navegador de arquivos e observe as pastas src e bin que
foram criadas. Por enquanto estas pastas estão vazias.

Com o projeto criado, agora vamos criar o código do nosso exem-

Para reforçar a organização, em
Java todo código deve fazer parte plo. Em Java todo código precisa fazer parte de uma class
de uma class e cada class é (mais detalhes no Capı́tulo 3). Vamos então criar uma nova
guardada em um arquivo separado.
class utilizando o menu File I New I Class. Ao acionar este
menu uma janela como a da Figura 1.8 é exibida.

Vamos escolher Hello como nome da nossa classe e marcar a

opção public static void main(...), como apresen-
tado na Figura 1.8. Além disso, é sempre recomendável organizar
as classes por pacotes, vamos escolher pack como o nome do
nosso pacote. No sistema de arquivos, cada classe é representada
16 1 Iniciando

Figura 1.7: Projeto Hello

recém criado.

por um arquivo de mesmo nome e com a extensão .java. Cada

pacote é representado por um diretório no sistema de arquivos.
Após pressionar Finish na janela de configuração nossa nova
classe terá sido criada. Nesse momento o pacote chamado pack
também foi criado.

Dica: Aproveite para explorar novamente a pasta Hello encon-

trada dentro do seu Workspace. Agora tanto a pasta src quanto
a bin terão conteúdo.

Nesse momento o conteúdo do arquivo Hello.java deve estar

sendo exibido na parte central da tela com o seguinte conteúdo:
1 package pack;

3 public class Hello {

4 /**
5 * @param args
6 */
7 public static void main(String[] args) {
8 // TODO Auto-generated method stub
9 }
10 }

O processo de compilação de
arquivos Java é tipicamente Neste ponto o aplicativo já foi compilado e o seu bytecode ge-
rápido. Normalmente o usuário não rado. Na verdade o Eclipse recompila o código automaticamente
percebe a etapa de compilação,
mesmo para projetos grandes. toda vez que um arquivo é salvo, desde que a opção do menu
Project I Build Automatically esteja marcada. O aplicativo já
pode também ser executado através do menu Run I Run As I
Java Application. Entretanto nada acontecerá, pois não adico-
1.5 O Primeiro Programa 17

Figura 1.8: Janela de

configuração para a criação de
uma nova class no Eclipse.

namos nenhuma ação no código.

Para que o código imprima uma mensagem no console precisamos
apenas adicionar uma linha à função main. O código final deve
ser:
1 package pack;

3 public class Hello {

4 public static void main(String[] args) {
5 System.out.println("Hello world!");
6 }
7 }

Após adicionar esta linha ao código basta salvar o arquivo para

que este seja recompilado. Agora basta executar novamente o
aplicativo através do menu Run I Run As I Java Application.
A execução fará com que a aba Console seja exibida e se torne
ativa com o dizer Hello world!. Após a primeira execução
do aplicativo, basta utilizar o menu Run I Run para que o último
aplicativo executado seja disparado novamente.
18 1 Iniciando

Se tudo deu certo, você acaba de construir e executar seu primeiro

aplicativo em Java. Alguns pontos importantes utilizados neste
nosso primeiro código são:
• Toda classe de Java é armazenada em um arquivo de
mesmo nome com a extensão .java
• É aconselhável organizar as classes em pacotes, que são
representados por diretórios no sistema de arquivos
• Um aplicativo precisa ter uma função do tipo public
static void main, que é por onde a execução do pro-
grama inicia
• Textos (referidos como strings) são representados entre as-
pas duplas, como em "Hello world!"
• Cada instrução é finalizada com um ponto-e-vı́rgula ;
• As chaves { e } marcam o inı́cio e o fim de classes e funções
• A chamada System.out.println imprime no console
o string fornecido como argumento

1.6 Imprimindo e Lendo do Console

Como visto na seção anterior é possı́vel imprimir uma linha no
console chamando a função println do System.out. Na
verdade System é uma das classes padrões do Java e out,
Existe ainda o System.err que é
a saı́da padrão para erros. que um de seus objetos internos, representa a saı́da padrão para
o console. A mesma classe também contém a entrada padrão de
console, o System.in.

Dica: Para ver todos os objetos e funções que são membros do

System: em uma linha dentro de uma função digite System,
então digite mais um ponto . para que uma lista com as opções
seja exibida. Se esta lista desaparecer utilize o atalho Ctrl +
Space para que ela seja exibida novamente.

O System.out contém diversas funções além da println.

Uma destas funções é a print, a diferença entre elas é que a
println faz com que o console pule para uma nova linha após
fazer a impressão e a print mantém a mesma linha.
Para exemplificar vamos incrementar o nosso exemplo Hello.
Antes de continuar faça uma cópia da classe Hello com o nome
de Hello2. Para isto selecione a classe Hello no Package
Explorer e então utilize os comandos Edit I Copy e Edit I
1.6 Imprimindo e Lendo do Console 19

Paste. Por fim, atualize o conteúdo da nova classe para o se-

guinte:
1 package pack;

3 public class Hello2 {

4 public static void main(String[] args) {
5 System.out.print("Hello!");
6 System.out.println(" I can do some simple" +
7 " math here.");
8 System.out.print("For instance, 1+2 = ");
9 System.out.println(1+2);
10 System.out.println("Bye!");
11 }
12 }

Note que entre as linhas 6 e 7 do código acima o operador + é

utilizado para concatenar dois strings. Já na linha 9 o mesmo
operador executa a soma de dois números inteiros. O código
acima quando executado produz o seguinte resultado no console:
Hello! I can do some simple math here.
For instance, 1+2 = 3
Bye!

De acordo com a linha 9 do exemplo acima podemos observar que

a println pode também imprimir números além de strings, o
mesmo vale para a print.
Como visto, a única diferença entre o print e o println, é
que o último sempre inicia uma nova linha após a impressão. Na
verdade, o println imprime um caracter adicional que repre-
senta uma nova linha: o caracter ’\n’. Sendo assim, todas as
três chamadas a seguir são equivalentes:
1 System.out.println();
2 System.out.print(’\n’);
3 System.out.print("\n");

Para avançarmos mais um pouco vamos precisar aprender a ler da-

dos do console. Para imprimir estamos utilizamos a saı́da padrão
System.out, para a leitura vamos utilizar a entrada padrão
Utilizando diretamente o
System.in terı́amos que ler System.in. A utilização direta do System.in para a leitura
sequencias de bytes que teriam que de textos e números não é conveniente. Ao invés disto, vamos
ser convertidos em números, texto,
etc. utilizar um utilitário chamado Scanner. Esta classe também
faz parte do conjunto de classes básicas do java e é encontrado
dentro do pacote java.util. A utilização de um Scanner é
exemplificada no seguinte código:
1 package pack;

3 import java.util.Scanner;

5 public class Hello3 {

6 public static void main(String[] args) {
20 1 Iniciando

7 Scanner scan = new Scanner(System.in);

9 System.out.println("Hello! I can echo, " +

10 "enter with a text:");

12 String text = scan.next();

14 System.out.print("You entered with: ");

15 System.out.println(text);
16 System.out.println("Bye!");
17 }
18 }

A primeira grande diferença do código acima é a utilização do

comando import. Como a classe Scanner se encontra dentro
Na verdade o import é opcional,
sem ele terı́amos que escrever o do pacote java.util precisamos dar um import na classe,
caminho completo como apresentado na linha 3 do código acima. Mais detalhes
java.util.Scanner ao invés de
apenas Scanner. sobre este comando podem ser encontrados na ??.
Na linha 7 criamos um novo Scanner que vai utilizar como fonte
de dados a entrada de console System.in. O novo objeto do
tipo Scanner que foi criado será referenciado dali em diante
como scan. Para criar o nosso Scanner a palavra-chave new
foi utilizada. Em Java sempre precisamos utilizar o new para
criar os objetos que vamos utilizar, a excessão são os tipos primi-
tivos. Variáveis de tipos primitivos são criadas sem a necessidade
do new (veja mais detalhes na ??).
Na linha 12 fazemos uso do nosso Scanner através da chamada
de uma de suas funções, a função next. Esta função espera pela
entrada em de um texto no console e retorna este texto na forma
de um String. Este será referenciado dali em diante como
text. Na linha 15 imprimimos de volta no console o texto que
foi inserido.

Dica: Apague e insira novamente o ponto . do comando

scan.next() para que o Eclipse liste todas as funções dis-
ponı́veis para o objeto scan. Tente também utilizar o atalho
Ctrl + Space com o cursor logo após o ponto.

Evoluindo um pouco mais nosso código, podemos criar um pe-

queno aplicativo que faz uma multiplicação:
1 package pack;

3 import java.util.Scanner;

5 public class Hello4 {

6 public static void main(String[] args) {
7 Scanner scan = new Scanner(System.in);

9 System.out.println("Hello! I can do " +

10 "a multiplication for you, " +
1.6 Imprimindo e Lendo do Console 21

11 "enter with two numbers:");

13 int num1 = scan.nextInt();

14 int num2 = scan.nextInt();

16 System.out.print("The result is = ");

17 System.out.println(num1*num2);
18 System.out.println("Bye!");
19 }
20 }

Neste novo exemplo estamos utilizando a função nextInt do

Haverá um erro de execução no
programa se o usuário fornecer Scanner, linhas 13 e 14. Esta função espera pela entrada no
algo diferente de número inteiro. console de um número inteiro. Os números lidos pelo Scanner
Vamos aprender a tratar estes
problemas no ?? são armazenados em variáveis e utilizados mais tarde na operação
de multiplicação da linha 17. A execução deste último aplicativo
geraria algo do tipo:
Hello! I can do a multiplication for you, enter with two numbers:
6 8
The result is = 48
Bye!
2 Programação Tradicional

Neste capı́tulo vamos introduzir os conhecimentos necessários para fazer o que vamos cha-
mar de programação tradicional (não orientada a objetos). Um termo mais técnico seria
programação procedural. Isto nos permitirá construir programas pequenos, capazes de fazer
cálculos repetitivamente e de tomar decisões em função da escolha do usuário ou do resultado
dos cálculos executados.
A programação orientada a objetos é introduzida apenas no Capı́tulo 3, isto porque boa parte
dos engenheiros e cientistas já construiram algum tipo de programa tradicional (procedural)
em alguma linguagem antes de experimentar o Java. Se este for o caso, este capı́tulo
pode ser visto praticamente como uma apresentação da sintaxe Java para comandos já bem
conhecidos.

Sumário
2.1 Noções Básicas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
2.2 Tipos Primitivos . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
2.3 Comentários . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
2.4 Operadores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
2.5 Tratando Textos com os String’s . . . . . . . . . . . . . . . . . . 33
2.6 Loop while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
2.7 Loop for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
2.8 Utilizando break e continue . . . . . . . . . . . . . . . . . . . . 36
2.9 Precisão dos Números em uma Máquina . . . . . . . . . . . . . . 36
2.10 Condicionais com if . . . . . . . . . . . . . . . . . . . . . . . . . 37
2.11 A classe Math . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
2.12 Funções e Variáveis Estáticas (static) . . . . . . . . . . . . . . . 37
2.1 Noções Básicas 23

2.1 Noções Básicas

Em programação existem dois aspectos fundamentais: os dados e
as instruções. Programas manipulam dados que estão gravados
na memória utilizando instruções. Para trabalhar com os dados
vamos precisar dos conceitos de variáveis e tipos. Com relação
Neste livro o termo função é
preferido frente a subrotina ou às instruções será preciso entender estruturas de controle e
método. funções. O objetivo deste capı́tulo é tornar estes conceitos fami-
liares, no contexto de programação em Java.
Uma variável é apenas uma referência a um ponto da memória
do computador para a qual damos um nome. Este nome dado
nos permite que utilizemos a variável em vários pontos do pro-
grama. O programador precisa se preocupar apenas com o nome
da variável, é responsabilidade do compilador mapear entre o
nome e o endereço de memória a que ele se refere.

Nota: Java diferencia maiúsculas de minúsculas, sendo assim os

identificadores num, Num e NuM vão se referir a coisas diferentes
dentro de um programa.

Em Java, como em boa parte das linguagens de programação,

uma variável tem sempre um tipo definido. O tipo indica para
que tipo de dados uma variável se refere. Um tipo de variável
pode se referir a números inteiros, tais como 3 e -4. Outro tipo
pode tratar de números quebrados, tal como 3.14. Há um tipo
para caracteres, por exemplo ’c’ e outro para sequencias de
caracteres (strings), por exemplo "Hello". Alguns exemplos de
utilização de variáveis inteiras, similares ao que já trabalhamos no
Capı́tulo 1, seguem:
1 int num1 = 3;
2 int num2 = -4;

4 int num3 = num1 + num2;

O tipo int, utilizado no código acima, é um tipo primitivo da lin-

guagem Java. Na Seção 2.2 todos tipos primitivos da linguagem
são introduzidos. Uma caracterı́stica interessante do Java é a
Criar novos tipos é só uma das
possibilidades das linguagens possibilidade de criar novos tipos de variáveis, isto é feito através
orientadas a objetos. das classes (mais detalhes no Capı́tulo 3).
Para trabalhar com os dados das variáveis as linguagens de pro-
gramação sempre disponibilizam alguns operadores. Na linha 4
do código acima utilizamos o operador + para fazer a soma do
valor das variáveis num1 e num2. Nesta mesma linha o ope-
rador = foi utilizado para atribuir o resultado da operação na
24 2 Programação Tradicional

variável num3; Além dos operadores temos as estruturas de con-

trole, exemplos são o if para testes de condicionais e o for para
iterar. Estes comandos são as peças utilizadas para a construção
dos programas. Quando uma sequencia de comandos é utilizada
com frequencia é conveniente agrupa-la em uma função. Uma
função que já utilizamos foi a println, para imprimir uma linha
no System.out.
Na verdade, a maioria dos programas é tão complexo que seria
quase impossı́vel escrevermos todo o código sem quebrar ele em
partes. Nisso as funções também ajudam, pois podemos agrupar
alguns conjuntos de comandos que executam uma determinada
tarefa. O nome de uma função, que é escolhido pelo programa-
dor, normalmente indica qual a tarefa que ela executa (veja o
Apêndice A para as regras de nomenclatura). Como por exemplo
o println, que imprime uma linha. Apenas reproduzindo um
trecho de código que já utilizamos:
System.out.println("Hello world!");

Falando grosseiramente, quando chamamos a função println

acima, seria como se todos os comandos que ela representa fossem
colados naquela linha. A vantagem disso não é apenas economizar
linhas de código. A construção de funções ajuda a organizar o
código e a focar na solução da tarefa especı́fica que a função
deve executar sem se preocupar com a complexidade do programa
como um todo.
Variáveis, tipos primitivos, operadores, estruturas de controle e
funções formam o que vamos chamar de programação básica.
Programação básica pode ser feita
em C e FORTRAN 77, orientada a No resto deste capı́tulo vamos ficar limitados e este tipo de pro-
objetos não. gramação. Entretanto, quando a complexidade de um programa
cresce a utilização de alguns elementos mais avançados pode
ajudar. No Capı́tulo 3 vamos estudar estes elementos: a pro-
gramação orientada a objetos.

2.2 Tipos Primitivos

Java é uma linguagem de programação do tipo strongly-typed,
isto significa que todas as variáveis precisam ser declaradas antes
de serem utilizadas. Isto envolve não só a definição prévia do
nome das variáveis, mas também o seu tipo:
int num1 = 3;

Na declaração acima, dizemos que existe uma variável chamada

num1, esta guarda um valor inteiro e que seu valor inicial é 3.
2.2 Tipos Primitivos 25

O tipo da variável determina o tipo de dado que ela pode con-

ter. Adicionalmente, o tipo de variável define que operações são
possı́veis com aquela variável. Além do int o Java suporta ou-
Não é possı́vel nomear variáveis ou
funções com palavras reservadas da tros 7 tipos primitivos. Cada tipo primitivo é representado por
linguagem. Exemplos de palavras uma palavra chave reservada. A seguir os tipos primitivos são
reservadas são int e new.
descritos:

int : Tipo para números inteiros. Este tipo de variável ocupa

32 bits e pode assumir valores até o ± 2147483647. Este
tipo de número é o suficiente para a maioria das aplicações.
Caso necessite representar um número maior, o long deve
ser utilizado.
long : Análogo ao int mas ocupa 64 bits de memória. Como
consequencia este tipo de variável pode representar números
até ± 9223372036854775807.
float : Tipo de dados para números quebrados. Este tipo também
ocupa 32 bits de memória e a faixa exata de valores que
ele pode representar não vem ao caso. É importante saber
que ele pode representar números da ordem de ±10±126 .
Este tipo pode ser utilizado (no lugar do double) quando
deseja-se economizar memória em detrimento da precisão
dos números.
double : Tipo de dados para números quebrados, porém ocupando
64 bits de memória. Para representar números reais este
tipo é normalmente a opção. Pode representar números da
ordem de ±10±1022 .
boolean : Tipo de dados para testes lógicos, pode assumir apenas
os valores true e false. Embora este tipo possa ser
representado por apenas 1 bit de memória, o quanto uma
variável deste tipo ocupa de fato não é definido.
char : Tipo para caracteres, ocupa 16 bits de memória. Na lingua-
gem um caracter é representado por uma letra entre aspas
simples, por exemplo: ’j’.
byte e short : O byte é um tipo de número inteiro com apenas 8 bits e o
short com 16 bits. Podem ser utilizados para economizar
memória (no lugar do int), mas não são muito comuns
para cálculos em aplicações de engenharia e ciências.

Nos exemplos introdutórios também trabalhamos com as sequen-

cias de caracteres, os strings. Uma vez que os strings são muito
comuns, o Java provê suporte especial para este tipo de dados.
Por exemplo, sempre que escrevemos algo entre aspas duplas
como em "Hello" o Java cria automaticamente um string.
26 2 Programação Tradicional

Isto pode nos levar a crer que um string é um tipo primitivo.

Isto não é verdade, os string são representados por uma classe,
mais especificamente pela classe java.lang.String. Na
Seção 2.5 vamos trabalhar mais alguns aspectos dos strings.

Dica: Em aplicações de cálculos de engenharia, fı́sica ou quı́mica

o tipo double é o mais comumente utilizado. Na Seção 2.9
vamos discutir um pouco mais a questão da precisão de um
double.

Toda a linguagem de programação tem regras e convenções sobre

os nomes que podem ser utilizados para variáveis e funções.

Nota: Embora o programador possa escolher os nomes das

variáveis e funções da forma que quiser, é recomendável seguir
alguns padrões. No Apêndice A temos algumas regras para no-
mear variáveis e funções, seria interessante seguir estas regras
desde já.

2.3 Comentários
Toda a linguagem de programação pertime a presença comentários.
Comentários são textos que não serão interpretados pela máquina
e não alteram em nada a execução do programa. Eles existem
apenas para que o programador explique o funcionamento do pro-
grama ou coloque informações adicionais. Estas informações tor-
narão mais fácil o entendimento do código pelo próprio autor ou
para terceiros que tenham acesso ao código. Em Java existem
dois tipos de comentários:
Por linha : É iniciado por // e faz com que todo o texto seja ignorado
até o final da linha.
Por bloco : É iniciado por /* e faz com que todo o texto seja ignorado
até que */ seja encontrado. Pode se expandir por múltiplas
linhas.
Um trecho de código que exemplifica o uso dos dois tipos de
comentários segue:
// Declaring a double variable (this is a line comment)
double x = 0.5;

/* Updating the value of x

to a new value (this is a block comment) */
x = 1.5;
2.4 Operadores 27

Dica: Para comentar/descomentar uma linha utilize o menu

Source I Toogle Comment ou pressione Ctrl+/.

Em Java existe ainda uma variante do comentário por bloco, que

é o comentário de documentação. Este tipo de comentário deve
aparecer imediatamente antes da declaração de classes, funções
ou variáveis e é indicado por um asterisco extra no seu inı́cio /**:
/**
* This is the documentation of my new class.
*/
class MyClass {
/**
* Function documentation.
*/
public void myFunction(){
}
}

No código acima o asterisco extra em cada linha é opcional, uti-

lizado apenas por estética. Comentários de documentação con-
tinuam sendo ignorados pela linguagem. A diferença é que este
tipo de comentátio é tratado pela ferramenta Javadoc para a
geração automática de documentação de código. A Apêndice A
apresenta mais alguns aspectos deste tipo de comentário. O se-
guinte endereço apresenta detalhadamente o funcionamento dos
O Javadoc acompanha a instalação
do JDK da Sun, mais detalhes comentários de documentação http://java.sun.com/j2se/
podem ser encontrados em javadoc/writingdoccomments/.
http://java.sun.com/j2se/
javadoc/.
Outra vantagem de utilizar comentários de documentação é que
o Eclipse irá automaticamente exibir a documentação de uma
classe quando passamos o mouse sobre ela. O mesmo acontece
com as funções que são documentadas com comentários de do-
cumentação.

Dica: No Eclipse, F2 exibe a documentação da classe ou função

selecionada no editor.

2.4 Operadores
Na seção anterior aprendemos como declarar e inicializar variáveis
de tipos primitivos. Agora vamos detalhar como trabalhamos
estas variáveis utilizando operadores. Operadores são sı́mbolos
especiais que executam operações especiais em um, dois ou três
operandos e então retornam um resultado.
28 2 Programação Tradicional

2.4.1 Atribuição

As variáveis representam os dados de um programa, depois de

inicializadas elas são atualizáveis. O valor de uma variável de um
tipo primitivo pode ser sobreposto com um novo valor. O ato
de alterar o valor armazenado em uma variável com o operador
= é conhecido como atribuição. Naturalmente a atribuição não
altera o nome da variável, apenas seu conteúdo. Um exemplo de
atribuição em Java é o seguinte:
double x = 0.5;
x = 1.5;

No trecho de código acima, x é inicializado com 0.5 e então

atualizado para 1.5. Isto faz com que o ponto de memória para
o qual x se referencia tenha seu valor alterado.

Nota: Se a variável não for de um tipo primitivo o operador =

tem um sentido bem diferente, pois não altera o valor da variável
e sim a quem ela referencia. Estas diferenças serão exploradas no
Capı́tulo 3.

2.4.2 Operadores Aritméticos

Depois da atribuição, os operadores mais simples são os opera-

dores aritméticos. Eles são indicados pelos sı́mbolos +, -, * e
/. Estes operadores podem ser utilizados com qualquer valor
numérico, por exemplo: int e double. Quando a máquina de
fato avalia uma operação dessas os dois valores que o operador
combina devem ser do mesmo tipo. Se um operador aritmético
é utilizado com tipos diferentes, como por exemplo em 2.3 +
8, então o computador irá converter o inteiro 8 para o real 8.0
para finalmente executar 2.3 + 8.0.
Grosseiramente, poderı́amos dizer que não precisamos nos preo-
cupar, pois em Java a máquina fará as conversões necessárias.
Por exemplo, se somamos ou multiplicamos duas variáveis do tipo
int o resultado será um int. O mesmo acontecerá com um
double. Entretanto se dividimos duas variáveis do tipo int o
resultado também será um inteiro, e muitas vezes isto não é o que
queremos. Por exemplo, 7/3 vai resultar em 2 e não em 2.5.
Outra fonte tı́pica de erros de programação aparecem quando
temos um inteiro N: a divisão N/100 também será um inteiro.
O resultado desta operação será zero para qualquer N entre 0 e
100, o que provavelmente não é o que se quer. Para estes casos
2.4 Operadores 29

podemos forçar que a operação resulte em um número real, fa-

zendo com que um dos operandos seja um double: N/100.0.
Assim, antes de executar a operação a máquina irá converter N
para um real para depois executar a operação, resultando em um
número real.
Para representar números muito pequenos ou muito grandes em
Java podemos utilizar a notação cientı́fica, da seguinte forma:
double AVOGADRO = 6.02214179e23;

double ELECTRON_VOLT = 1.60217653e-19;

Nota: Sempre que escrevemos um número quebrado, por exem-

plo 3.5, este número é interpretado como sendo do tipo
double. Se na verdade queremos um float precisamos adici-
onar um f no final do número, por exemplo 3.5f.

2.4.3 Cast

Como visto na seção anterior, o Java faz conversões automáticas

entre os tipos numéricos. Entretando, estas conversões são feitas
automaticamente apenas quando isto não significar perda de in-
formação. A tentativa de atribuir um valor do tipo double em
uma variável do tipo int, gera um erro de compilação:
double x = 0.8;
int i = 1;

i = x;

Para conversões entre tipos onde há possı́vel perda de informação

é necessário fazer um cast ou conversão explı́tica:
1 double x = 0.8;
2 int i = 1;

4 i = (int)x;

O cast está na linha 4, fazendo a conversão de x que é do tipo

double para o tipo int. O valor final da variável i será 0, o
valor original na variável x é perdido neste caso.

2.4.4 Incremento e Decremento

Em programação, a operação de adicionar 1 a uma variável (in-

crementar seu valor) é extremamente comum. Da mesma forma,
subtrair 1 (decrementar) também é muito comum. Uma forma
de fazer é utilizando atribuição, como exemplificado abaixo:
30 2 Programação Tradicional

i = i + 1;
counter = counter - 1;

O efeito da primeira linha acima é pegar o valor atual de i calcular

a sua soma com 1 e guardar o resultado novamente na variável
i. A mesma operação pode ser feita simplesmente com i++ (ou
++i se preferir). Ou seja, o código acima pode ser reescrito da
seguinte forma:
i++;
counter--;

De forma similar poderı́amos escrever i-- (ou --i) para decre-

mentar em 1 o valor de i. Ou seja, terá o mesmo efeito de i =
i - 1.
Os operadores incremento e decremento podem ser utilizados
como um comandos sozinhos, da seguinte forma:
double x = 4.0;
x++;
x--;

No caso acima o valor final de x será 4.0. Poderı́amos ter

utilizado também:
double x = 4.0;
++x;
--x;

Isto não traria nenhuma alteração no resultado final, no qual x

vale 4.0. Entretanto, o incremento e decremento podem ser
utilizados como parte de uma expressão maior:
double x = 4.0, y, z;
y = x++;
z = x--;

O resultado do código acima será: x e y valem 4.0 e z vale

5.0. Isto porque o operador incremento, quando colocado após
a variável, irá incrementar o valor da variável mas retornará o valor
antigo (antes do incremento). Já quando o operador é colocado
na frente da variável, este fará o incremento e retornará o valor
novo (já incrementado). Por exemplo:
double x = 4.0, y, z;
y = ++x;
z = --x;

O código acima resultará em: x e z valem 4.0 e y vale 5.0.

2.4 Operadores 31

2.4.5 Operadores Relacionais

Para testes e condicionais o Java dispõe do tipo primitivo boolean

o qual tem como valores válidos apenas true e false. Uma
forma de gerar um valor do tipo boolean é através dos ope-
radores relacionais. Estes operadores testam quando dois valores
são iguais, um valor é maior que outro e assim por diante. Em
Java os operadores relacionais são: ==, !=, <, >, <= e >=. O
significado destes operadores é o seguinte:
a == b : a é igual a b?
a != b : a não é igual a b?
a > b : a é maior que b?
a < b : a é menor que b?
a >= b : a é maior ou igual a b?
a <= b : a é menor ou igual a b?
Estes operadores podem ser utilizados para comparar qualquer
A tabela de caracteres Unicode não
é exatamente na ordem alfabética, valor de tipos primitivos numéricos. Eles podem também ser uti-
uma vez que todos os caracteres lizados para comparar variáveis do tipo char. Para caracteres,
maiúsculos vêm primeiro que os
minúsculos. os operadores < e > são definidos de acordo com a tabela de
caracteres Unicode. Uma tabela de caracteres pode ser encon-
trada em http://www.scism.lsbu.ac.uk/jfl/Appa/
appa4.html.
O resultado de uma comparação com operadores relacionais pode
ser naturalmente guardado em uma variável do tipo boolean
para ser utilizada mais tarde por outros comandos ou novas com-
parações:
boolean xGreaterThanZero;

xGreaterThanZero = x > 0;

É importante notar que os operadores <, >, <= e >= não po-
dem ser utilizados com o tipo String, pois este não é um tipo
numérico primitivo. Também lembre que, embora seja possı́vel
utilizar os operadores == e != com um String estes podem
não retornar o valor desejado (o operador == verificará se os ob-
jetos em teste se referem ao mesmo endereço de memória e não
se o texto contido de fato é o mesmo). Para este caso devem
ser utilizadas as funções equals(), equalsIgnoreCase()
e compareTo(), mais detalhes sobre o tipo String são en-
contrados na Seção 2.5.
Na Seção 2.6 vamos aprender como utilizar os operadores relaci-
onais para iterar várias vezes um trecho de código com o while
32 2 Programação Tradicional

até que determinada condição seja satisfeita. Na Seção 2.10 ve-

remos como escolher que trecho de código executar utilizando o
if em função de um teste condicional.

2.4.6 Operadores Booleanos

No cotidiano tratamos de condições complicadas compostas pelas

palavras e, ou e não. Por exemplo: Se você tiver uma prova
e você não estudar . . . Estas três palavras são os operadores
booleanos em Java.
O operador e é representado por &&. O operador && combina dois
valores do tipo boolean e o resultado também é um boolean.
O resultado será true apenas se ambos os valores são true.
O resultado será false se qualquer um dos valores é false.
O operador ou é representado por ||. O operador || também
combina dois valores do tipo boolean, resultando em um boolean.
O resultado será true se algum dos valores for true. O resul-
tado será false apenas se ambos os valores forem false.
Os operadores && e || são ditos do tipo short-circuit, pois o
segundo operando não necessariamente é avaliado. Considere o
seguinte teste:
(x != 0) && (y/x > 1)

Supondo que o valor de x é de fato zero. Neste caso, a divisão

y/x não é definida em uma máquina. Porém, a máquina jamais
executará esta divisão, uma vez que se x != 0 é avaliado como
false a máquina sabe que o resultado será falso independen-
temente do segundo operando. Nestes casos a máquina não se
gasta avaliando o segundo operando e a divisão por zero é evitada.
O operador não é indicado no Java por um ! apresentado na
frente do seu operando. Como este operador utiliza apenas um
operando ele é dito um operador unário. Por exemplo, consi-
dere uma variável chamada test do tipo boolean no seguinte
código:
test = !test;

O código acima irá reverter o valor da variável test, trocando

de true para false ou vice-versa.

2.4.7 Ordem de Precedência

Quando múltiplos operadores são combinados em um mesmo co-

mando é importante saber em qual ordem estes são executados
2.5 Tratando Textos com os String’s 33

para que o resultado seja o esperado. Na tabela abaixo são apre-

sentados a ordem de precedência de execução dos principais ope-
radores da linguagem Java.

Operador Ordem de Precedência

Incrementos após expr++ expr--
Demais unários ++expr --expr +expr -expr !
Multiplicativos * / %
Additivos + -
Relacionais < > <= >= instanceof
Igualdade == !=
Lógicos &&
Operador ternário ? :
Atribuição = += -= *= /= %=

O nı́vel de precedência dos operadores na tabela acima é de cima

para baixo e da esquerda para a direita. Operadores com maior
precedência são avaliados primeiro nas expressões.

2.5 Tratando Textos com os String’s

Na Seção 2.2 os tipos primitivos foram introduzidos. Existe uma

diferença fundamental entre os tipos primitivos e o String: va-
lores do tipo String são objetos. Estudaremos em datalhes os
objetos no Capı́tulo 3, mas já é interessante saber um pouco so-
bre eles. Algumas diferenças importantes entre objetos e variáveis
de tipos primitivos são:

• Para criar um objeto precisamos utilizar a palavra chave

new, para criar uma variável de um tipo primitivo basta
declarar a variável.

• Uma variável de um tipo primitivo representa apenas um

dado, um objeto tem funções além de dados (por exemplo,
na Seção 1.6 utilizamos uma função de um objeto com o
comando scan.next()).

O String não é um tipo primitivo, mas o Java oferece um

Não há um código escrito em Java
descrevendo o funcionamento dos tratamento especial ao String, o que pode acabar dando a
tipos primitivos, eles estão impressão de que String é um tipo primitivo. Em Java, ti-
embutidos no sistema. Para as
classes, como o String, há um pos que não são tipos primitivos são conhecidos como classes.
código que descreve o seu
funcionamento, escrito em Java.
O String é uma classe, outra classe que já utilizamos foi a
Scanner, que faz parte do pacote java.util.
34 2 Programação Tradicional

Dica: Para ver o código fonte de uma classe, selecione o nome

da classe no editor do Eclipse e utilize o menu Navigate I Open
Declaration ou pressione F3.

Assim, a nomenclatura que utilizamos em Java é a seguinte:

se String é uma classe então uma variável do tipo String
é um objeto. O objeto contém dados, neste caso a sequencia
de caracteres que forma o texto, mas também contém funções.
Por exemplo, todo objeto do tipo String contém uma função
chamada length() que retorna o número de caracteres que
formam o texto. No trecho de código abaixo esta função é exem-
plificada:
String advice;
advice = "When you want to cross the street, look twice.";

System.out.println("Length of \"advice\" is:" + advice.length());

No trecho de código acima, um objeto chamado advice foi

declarado, mas não foi inicializado. Em seguida o objeto é ini-
cializado com um texto. Após, a função length() do objeto
advice foi chamada. Esta função retorna um inteiro, que é
então automaticamente convertido para um String para que
possa ser concatenado pelo operador +.

Nota: A função length() da classe String não espera ne-

nhum argumento, mesmo assim precisamos utilizar os parênteses
após o nome da função. Isto é necessário para deixar claro que
estamos chamando uma função e não uma possı́vel variável com
o nome length.

Do exemplo acima é importante notar que, embora o String

seja uma classe, o Java trata ela de uma forma especial, fazendo
parecer um tipo primitivo:
• Podemos inicializar um String com um texto entre aspas
duplas, sem a necessidade de utilizar o new.
• O operator + tem um significado especial para o String,
ele concatena os seus argumentos para formar um novo
texto.
Como visto, o operador + pode ser utilizado para concatenar
variáveis do tipo String. Este é um dos tratamentos especiais
que o String recebe: é a única classe para a qual o operador
+ está definido. Operadores que estão definidos para todas as
2.5 Tratando Textos com os String’s 35

classes são o == e o !=. Estes operadores devem ser utilizados

com cuidado quando estamos trabalhando com objetos do tipo
String. Por exemplo, a execução do código abaixo resultará na
impressão de true:
String s1 = "A String";
String s2 = "A String";

System.out.println(s1 == s2);

Na verdade, o compilador Java irá converter o código acima em

algo semelhante ao seguinte:
String s1 = new String("A String");
String s2 = s1;

System.out.println(s1 == s2);

Isto porque os textos acima eram claramente idênticos. Nesse

caso o mesmo objeto é reutilizado, fazendo com que as duas
variáveis apontem para o mesmo objeto. Ja o seguinte código irá
retornar false, mesmo com os textos com conteúdo idêntico:
String s1 = "A String";
String s2 = "A" + " String";

System.out.println(s1 == s2);

No exemplo acima ainda temos strings com conteúdos idênticos,

mas estamos tratando com objetos, e não variáveis de tipos pri-
mitivos. O operador ==, quando recebe objetos, testa se seus
argumentos são o mesmo objeto e não se o conteúdo deles é o
mesmo.
Para testar se um String tem o mesmo conteúdo que outro é
necessário utilizar uma função. As funções que estarão disponı́veis
em um objeto são definidas na sua classe. A classe String de-
fine diversas funções. Abaixo seguem algumas que são de grande
utilidade. Assumindo que temos dois objetos do tipo String
chamados s1 e s2:
• s1.equals(s2) é uma função que retorna um boolean.
O resultado será true se ambos os strings contém exa-
tamente a mesma sequencia de caracteres, caso contrário
false.
• s1.equalsIgnorecase(s2) é análoga a anterior mas
não diferencia maiúsculas de minúsculas.
• s1.length(), retorna um int com o número de carac-
teres do texto.
36 2 Programação Tradicional

• s1.charAt(n), onde n é um inteiro, retorna o caracter

na posição n. As posições iniciam do zero, s1.charAt(0)
vai retornar o primeiro caracter do texto.
• s1.indexOf(s2) retorna um int. Se s1 contém o
texto de s2 então a posição inicial onde s2 foi encontrado
é retornada. Se o texto não é encontrado o resultado é -1.

Dica: No editor do Eclipse, para listar todas as funções de um

objeto basta digitar o ponto . logo após o nome do objeto. Com
isto você também pode verificar que variáveis de tipos primitivos
não têm nenhuma função.

2.6 Loop while

2.7 Loop for
2.8 Utilizando break e continue
2.9 Precisão dos Números em uma Máquina
Quando programamos a solução de problemas de engenharia,
fı́sica, quı́mica, etc. precisamos representar variáveis contı́nuas
dentro de uma máquina. A solução usual para isto é utilizar
variáveis do tipo float ou double. Estas ocupam 32 e 64 bits
de memória, respectivamente. Para representar todos os números
possı́veis do conjunto dos números reais seria preciso uma precisão
infinita. Sendo assim, quando escolhemos os tipos float ou
double, que tem uma precisão limitada, nem todos os números
podem ser representados.
Esta limitação não é apenas para números muito grandes ou muito
pequenos. O que estou querendo dizer é que mesmo números da
Como já visto na seção Seção 2.2
um double pode representar ordem de 1 não podem ser representados em precisão limitada.
números até ±10±1022 . Por exemplo, o número representado pela soma 1+10−9 não pode
ser representado com um float. Isto porque o número resul-
tante seria 1.000000001, o qual requer mais casas decimais que os
16 bits podem oferecer. Sendo assim, se estamos utilizando um
float a operação anterior vai resultar simplesmente no número
1. De forma análoga, o resultado da soma 1 + 10−18 não pode ser
representado com um double e a operação resultaria no valor
aproximado 1.
Fica claro que há um limite para o qual dois números podem ser
diferenciados. O código a seguir apresenta como descobrir este
limite para um double:
2.10 Condicionais com if 37

1 package pack;

3 public class Precision {

4 public static void main(String[] args) {
5 double one = 1.0;
6 double eps = 1.0;

8 while(one+eps != one){
9 eps = eps/2;
10 }
11 System.out.print("Precision for double:" + eps);
12 }
13 }

O código acima também pode ser facilmente alterado para disco-

brir o limite de precisão de um float.
No Java existe também a classe java.math.BigDecimal,
capaz de representar números com a precisão que se deseje. Esta
classe dá ao usuário controle total sobre a precisão dos números
e operações. A consequencia é que os números ocupam mais
memória e as operações são mais demoradas a medida que mais
precisão é requisitada. Por este motivo, a grande maioria das
aplições utiliza os tipos float e double, que têm uma precisão
fixa.

2.10 Condicionais com if

Existe também uma forma compacta para o operador if (Condi-
tional Operator).

2.11 A classe Math

2.12 Funções e Variáveis Estáticas (static)
Uma forma de quebrar um programa complexo em partes menores
é através de funções. Uma função consiste em uma série de
instruções agrupadas, para a qual damos um nome. Em algum
ponto do programa, chamamos a função através de seu nome
para que as suas instruções sejam executadas.
Uma mesma função pode ser chamada várias vezes em diferentes
Uma função que chama a si mesmo
é conhecida como uma função pontos do programa. Uma função pode chamar outras funções
recursiva. Funções recursivas e até mesmo chamar a si mesmo. Isto permite escrever funções
devem ser programadas com
cuidado para evitar a recursão pequenas que são reutilizadas em vários pontos do programa.
infinita.
Dessa forma, programas complexos podem ser escritos passo-a-
passo. Sendo que cada passo é de uma complexidade pequena.
Em Java, uma função pode ser static ou não-static. Nesta
seção trataremos apenas de funções static. As funções não-
38 2 Programação Tradicional

static requerem conceitos da programação orientada a objetos,

que serão vistos no Capı́tulo 3.

2.12.1 Declaração de Funções

Em Java, uma função só pode ser declarada dentro de uma

classe. Esta restrição torna Java um pouco diferente das de-
Em linguagens como o C++ uma
função que faz parte de uma classe mais linguagens. Por exemplo em C++, é possı́vel a delcaração
é chamada de um método. Esta de funções “soltas”, que não fazem parte de classe alguma. A
nomenclatura também é utilizada
em Java, mas como todas as declaração de uma função em Java segue a seguinte forma:
funções devem estar dentro de uma
classe, podemos utilizar apenas o modifiers return_type functionName ( parameter_list ){
termo função. statements
...
}

Já estamos um pouco habituados com o formato acima, pois já

declaramos várias vezes uma função main. O modificador que
utilizamos quando declaramos uma main é o static. Iremos
utilizar vários outros modificadores mais adiante. A presença do
static quer dizer que a função pode ser chamada diretamente,
sem utilizar um objeto. Outro modificador que já utilizamos foi o
public. A utilização destes modificadores ficará mais clara no
Capı́tulo 3. Por enquanto, basta saber apenas que se não estamos
fazendo programação orientada a objetos, então todas as funções
precisam ser public static.
Os statements entre as chaves { } formarm o corpo ou im-
plementação da função. O corpo contém os comandos e ins-
truções que a máquina deve executar quando a função é chamada.
Se o objetivo de uma função é executar algum tipo de cálculo este
pode ser retornado no return type. Por exemplo, a função
sqrt da classe Math retorna a raiz quadrada de um valor. Se
a função não tem um resultado a retornar então a palavra void
é utilizada. Este é o caso quando implementamos uma função
main, é também o caso da função println que utilizamos
várias vezes. Um exemplo de declaração de uma função void
segue abaixo:
public static void printDateAndTime ( ){
Date now = new Date();
System.out.println("Now is :" + now);
}

A função acima irá imprimir a data e hora atual. O tipo de retorno

é void pois não há nenhum valor a retornar. Note que para isto
estamos utilizando a classe Date.
2.12 Funções e Variáveis Estáticas (static) 39

2.12.2 Chamando Funções

Quando declaramos uma função estamos dizendo que ela existe,

Isto é verdade até para a função
main, mas neste caso ela é qual o seu nome e o que ela faz. Esta função não é executada
chamada pelo sistema que executa até o momento em que é chamada, através do seu nome. Por
o programa.
exemplo, a função printDateAndTime do exemplo acima se-
ria chamada da seguinte forma:
printDateAndTime();

O comando acima pode aparecer em qualquer ponto da mesma

classe, sendo na main ou em outra função da classe. Uma vez
que esta função também é public ela pode ser chamada de
outras classes. Mas nesse caso é preciso dizer à máquina em
qual classe ela se encontra. Por exemplo, se o nome da classe
é MyClass, podemos chamar a nossa função de qualquer outra
classe com o seguinte comando:
MyClass.printDateAndTime();

A chamada chamada acima é análoga a que fizemos com a função

sqrt da classe Math.

2.12.3 Variáveis Locais e static

Quando declaramos uma variável dentro de uma função, seja den-

tro da main ou qualquer outra, ela só existe em seu contexto.

Nota: Um contexto é delimitado pelas chaves { } de uma função

ou if, while, etc.

Fora do contexto a variável não existe, por exemplo:

public static void main(String[] args){
int i = 0;
while(i < 10){
i++;
int i2 = i;
}
// This is an error, i2 was not declared on this context
System.out.println(i2);
}

Para que uma variável seja acessı́vel em todas as funções de uma

classe ela precisa ser declarada diretamente no contexto da classe
e não dentro de alguma função.
3 Programação Orientada a Objetos

Enquanto uma função representa apenas um conjunto de instruções agrupadas para realizar
uma determinada tarefa, um objeto encapsula tanto dados quanto tarefas que vão operar sobre
estes dados. Assim, trabalhando com objetos temos uma estrutura muito mais sofisticada
que auxilia a gerenciar a complexidade de programas grandes.

Sumário
3.1 Objetos, Funções de Objetos e Variaveis de Objeto . . . . . . . . 41
3.2 Construtores e a Inicialização de Objetos . . . . . . . . . . . . . . 44
3.3 Modificadores public e private . . . . . . . . . . . . . . . . . . 46
3.4 Vetores e Matrizes . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
3.5 Algumas classes do java.util . . . . . . . . . . . . . . . . . . . 51
3.6 Inheritance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
3.7 Classes Abstratas e Interfaces . . . . . . . . . . . . . . . . . . . . 54
3.8 Lists . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
3.9 Arquivos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
3.10 Unidades de Medida . . . . . . . . . . . . . . . . . . . . . . . . . . 54
3.1 Objetos, Funções de Objetos e Variaveis de Objeto 41

3.1 Objetos, Funções de Objetos e Variaveis de Objeto

A programação orientada a objetos tenta fazer com que os pro-
gramas se pareçam mais com o modelo mental que as pessoas
naturalmente concebem sobre tudo que as cerca.
Grosseiramente falando, vamos imaginar um objeto como algo
que simplesmente agrupa variáveis e provê funções para operar
sobre estas variáveis.

3.1.1 Objetos vs. Classes

Objetos são fortemente relacionados com as classes. Já trabalha-

mos bastante com classes. Vimos que classes contém variáveis e
funções. A questão agora é: se um objeto também tem variáveis
e funções, então qual a diferença? Na verdade, ainda não conse-
guimos distinguir bem entre objetos e classes porque até o mo-
mento utilizamos sempre o prefixo static em nossas variáveis
e funções.
A relação entre classes e objetos é a seguinte: uma classe des-
creve o funcionamento de um objeto. Mais precisamente, a parte
não estática (sem o prefixo static) da classe faz isto. É usual
também dizer que um objeto pertence ou é do tipo de determi-
nada classe. Não é possı́vel criar um objeto sem ter uma classe, a
classe é como se fosse uma fábrica de objetos. Objetos são criados
e destruidos durante a execução de um programa. Objetos criados
a partir de uma mesma classe têm uma estrutura idêntica, mas
podem estar em estados diferentes (conter variáveis com valores
diferentes).
Vamos tentar deixar as coisas mais claras através de um exemplo.
Digamos que queremos representar um aluno de um curso em um
programa em Java:
1 class Student {
2 static String name;
3 static int id;
4 }

Um programa que utiliza a classe acima, haverá apenas uma cópia

das variáveis Student.name e Student.id. Assim, podere-
mos ter apenas um aluno. The classe Student e as variáveis
que ela contém existem durante toda a execução do programa,
não precisam ser criadas. Agora, se reescrevermos a classe sem a
utilização do modificador static:
1 class Student {
2 String name;
3 int id;
4 }
42 3 Programação Orientada a Objetos

Nesse caso, as variáveis Student.name e Student.id não

existem, uma vez que elas não são static. Então não há nada
na classe Student, a não ser a oportunidade de criar objetos.
Mas isto é uma grande oportunidade, pois podemos criar quantos
objetos desejarmos. Podemos ter quantos estudantes quisermos,
basta criar novos objetos assim que forem necessários. A vanta-
gem é que cada objeto criado vai conter as suas próprias variáveis
name e id, como exemplificado no código abaixo:
1 class Student {
2 String name;
3 int id;

5 public static void main(String[] args){

6 Student st1 = new Student();
7 Student st2 = new Student();
8 Student st3 = new Student();

10 st1.name = "Charlie";
11 st1.id = 100;
12 st2.name = "Alan";
13 st2.id = 200;
14 st3.name = "Jake";
15 st3.id = 300;
16 }
17 }

Um objeto que é do tipo de uma classe também é conhecido

como uma instância da classe. Neste livro vamos simplesmente
É comum utilizar instance method
e instance variable para funções e utilizar a palavra objeto quando temos uma instância de uma
variáveis de um objeto. Não vamos classe. Analogamente uma função não static será uma função
utilizar estes termos, pois a sua
tradução para o Português não traz do objeto assim como uma variável será uma variável do objeto.
muito significado. Por outro lado funções e variáveis static são da classe.
Como dito anteriormente, a parte não estática das classes des-
crevem o funcionamento de objetos. Para criar de fato um novo
objeto para uma determinada classe utilizamos a palavra chave
new.

3.1.2 Mais sobre Objetos

Vamos considerar novamente a nossa classe Student. Agora

se esta classe representar um estudante em um curso com três
provas. Poderı́amos imaginar as seguintes modificações:
1 class Student {
2 String name;
3 int id;
4 double test1, test2, test3;

6 double getAverage(){
7 return (tes1 + test2 + test3)/3;
8 }
9 }
3.1 Objetos, Funções de Objetos e Variaveis de Objeto 43

Nenhuma das variáveis ou funções da classe acima são static,

então ela existe para trabalhar com objetos e não diretamente na
classe. Um objeto do tipo Student terá as variáveis name, id,
test1, . . . e também uma função chamada getAverage().
O nome e as notas dos testes para cada estudante terão, em
geral, valores diferentes para cada objeto. Isto todas variáveis
são não-estáticas, do objeto e não da classe. Quando a função
getAverage() é chamada para um determinado estudante ela
fará o cálculo para aquele estudante em particular (objeto). Mas
como são da mesma classe, todos terão o mesmo comportamento
(mesmas variáveis e funções disponı́veis).
Em Java, uma classe tipo, similar aos tipos primitivos boolean,
double, etc. Assim, o nome da classe pode ser utilizado para
informar o tipo de uma variável em uma declaração. Por exem-
plo, podemos declarar a variável st1 do tipo Student com o
seguinte:
Student st1;

Entretanto, declarar um objeto não cria um objeto novo auto-

maticamente. Na declaração acima, a variável st1 estará vazia,
representada em Java pela palavra-chave null. Para tipos pri-
mitivos, diferentemente de classes, a declaração cria a variável
automaticamente. Esta diferenciação entre variáveis de tipos pri-
mitivos e objetos é muito importante. Em Java, uma variável
nunca guarda um objeto, apenas guarda uma referência
para um objeto.
Na verdade existe um trecho
especial na memória para os Podemos imaginar como se todos os objetos ficassem espalha-
objetos, chamado de heap. dos independentemente na memória do computador. Assim, uma
variável não guarda um objeto mas apenas a informação ne-
cessária para encontrar o objeto na memória. Esta informação é
chamada de uma referência. Se uma variável é declarada mas
não é associada a nenhum objeto, ela terá uma referencia vazia
ou null.
Para criarmos um objeto precisamos fazer uso do new, que cria
um objeto e retorna uma referência para que seja guardada na
variável. Por exemplo:
Student st1 = new Student();

O código acima irá criar um novo objeto do tipo Student e a

variável st1 contém uma referência para ele. Não está correto
dizer que st1 guarda ou contém o objeto, mas sim apenas
uma referência para o objeto. A terminologia correta é dizer
que a variável referencia ou aponta para o objeto.
44 3 Programação Orientada a Objetos

É possı́vel manter mais de uma referência para um mesmo objeto,

como exemplificado abaixo:
Student st1 = new Student();
Student st1Ref = st1;

No trecho de código acima, tanto st1 quanto st1Ref apon-

tam para o mesmo objeto. Assim, podemos acessar ou modificar
o objeto tanto via st1Ref quanto via st1. A virtual machine do
A memória associada à um objeto
não é liberada imediatamente Java irá liberar automaticamente a memória reservada para um
quando não há mais referências objeto quando não houver mais nenhuma referência para ele. Na
para ele, mas sim em algum outro
momento para uma maior verdade o Java mantém, para cada objeto criado, um contador
eficiência. Mas não precisamos nos
preocupar com isto.
com o número de variáveis que apontam para ele. Quando não
há mais nenhuma variável apontando para o objeto este contador
estará em zero e o objeto poderá ser liberado.

3.2 Construtores e a Inicialização de Objetos

Já vimos que objetos contém variáveis e funções. As variáveis dos
objetos são as variáveis não static da sua classe. A pergunta
então é, quando utilizamos o new para criar um objeto, como são
inicializadas as variáveis dos objetos? Na verdade temos algumas
opções. Podemos informar explicitamente o valor inicial de uma
variável de objeto na sua declaração:
1 class Student {
2 String name;
3 int id = -1;
4 double test1, test2, test3;

6 double getAverage(){
7 return (tes1 + test2 + test3)/3;
8 }
9 }

Com o código do exemplo acima, toda vez que um objeto do

tipo Student for inicializada a sua variável id terá o valor -1.
E o que acontece para as variáveis não inicializadas? Se não
especificamos um valor na inicialização temos duas possibilidades
que nos interessam:
1. Se a variável é de um tipo primitivo numérico, ela é inicia-
lizada com 0
2. Se a variável aponta para um objeto, ela é inicializada com
null
As alternativas de inicialização de variáveis comentadas até agora
são úteis mas não atendem a todos os casos. Da forma como
apresentado acima, quando um objeto do tipo Student é criado
ele não tem nome (a variável name é inicializada com null). Em
3.2 Construtores e a Inicialização de Objetos 45

termos de programação isto não é um bom projeto, pois a objeto

estará potencialmente incompleto no momento em que for usado.
O ideal seria garantir que o name e id fossem garantidamente
preenchidos quando o objeto é criado. Para isto precisamos dos
construtores.
Um construtor é uma função especial, chamada quando utiliza-
mos o new para criar um objeto. Este é o motivo dos parênteses
após o nome da classe, para dar a idéia de que uma função está
sendo chamada quando damos um new:
Student st1 = new Student();

Se a nossa classe não contém um construtor, o Java cria um

automaticamente. O construtor que é criado automaticamente
não faz nada de especial. Se desejamos fazer algo quando um
objeto da nossa classe é criado precisamos declarar o nosso próprio
construtor. Um construtor é uma função, obrigatoriamente de
mesmo nome da classe e que não tem um tipo de retorno:
1 class Student {
2 String name;
3 int id = -1;
4 double test1, test2, test3;

6 Student(){
7 name = "Unamed";
8 }

10 double getAverage(){
11 return (tes1 + test2 + test3)/3;
12 }
13 }

Nota: Um construtor nunca pode retornar uma variável e não

preciso dizer que um construtor retorna void como se fosse uma
função normal sem nenhum tipo de retorno.

No exemplo acima, um construtor é declarado na linha 6. Dentro

dele inicializamos o name com um texto. Isto fará com que o
name deixe de apontar para null, mas ainda não resolve o nosso
problema. Todos os objetos do tipo Student irão começar com
o mesmo nome "Unamed".
Se quisermos forçar que, um objeto Student só possa ser criado
se for fornecido um nome, precisamos modificar nosso construtor:
1 class Student {
2 String name;
3 int id = -1;
4 double test1, test2, test3;
46 3 Programação Orientada a Objetos

6 Student(String n){
7 name = n;
8 }

10 double getAverage(){
11 return (tes1 + test2 + test3)/3;
12 }
13 }

Utilizando o código acima, não é mais possı́vel criar um objeto do

tipo Student sem fornecer um string como argumento. Pois, se
declaramos pelo menos um construtor, o Java não mais dispo-
nibiliza o construtor padrão automático. Sendo assim, a primeira
linha do código abaixo forneceria um erro:
Student st1 = new Student();
Student st2 = new Student("Charlie");

Já na segunda linha do código acima o nosso construtor será

chamado e o name do objeto apontará para o string fornecido.
Entretanto, o id do objeto continuará sendo inicializado de forma
idêntica para todos os objetos criados, com o valor -1.
O ideal seria que, toda vez que um novo objeto é criado, um id
único fosse associado a ele. Isto pode ser obtido com o seguinte
construtor:
1 public class Student {
2 String name;
3 int id;

5 static int counter = 10000;

7 Student(String n) {
8 id = Student.counter++;
9 name = n;
10 }
11 }

No trecho de código acima, a variável counter é do tipo static,

portanto é da classe e não do objeto. Haverá uma única variável
counter que iniciará com o valor 10000. Toda a vez que
criamos um Student com o código acima, seu identificador é
inicializado com o mesmo valor da variável Student.counter
e então o contador é incrementado. Isto fará com que todos os
objetos do tipo Student criados no programa tenham um id
diferente.

3.3 Modificadores public e private

Na seção anterior avançamos um pouco na programação orien-
tada a objetos. Mostramos como programar o comportamento
3.3 Modificadores public e private 47

de um objeto através da sua classe e como inicializar este objeto

utilizando construtores. Também foi visto como declarar e utilizar
funções de objetos.
Entretanto, ao utilizar a nossa classe Student, nada garante
que alguém não estrague o objeto. Por exemplo, que modifique
o id fazendo com que ele deixer de ser único:
Student st1 = new Student("Charlie");
Student st2 = new Student("Alan");

st2.id = st1.id;

Em Java temos disponı́veis recursos para guarantir que este tipo

de acidente não aconteça. Quando não queremos que alguém
mexa em alguma variável ou função utilizamos o prefixo private
na declaração. Para o nosso exemplo ficaria:
public class Student {
private String name;
private int id;

private static int counter = 10000;

public Student(String n) {
id = Student.counter++;
name = n;
}
}

Com a declaração dessa forma, não é possı́vel acessar ou mo-

dificar o id ou name de um objeto do tipo Student, exceto
dentro da própria classe. Ou seja, o construtor e qualquer função
da classe ainda podem acessar ou modificar as variáveis do tipo
private. De qualquer outro lugar (outra classe) estas variáveis
estarão inacessı́veis.
De forma análoga, para dizermos que uma função pode ser aces-
sada de qualquer outra classe utilizamos o prefixo public. É
usual ter pelo menos um construtor do tipo public, caso contrário
o objeto sequer poderá ser criado de outra classe que não a sua
própria.
Por exemplo, podemos criar uma classe chamada StudentMain,
onde criaremos vários objetos do tipo Student. Esta classe vai
conter apenas uma função main:
1 public class StudentMain {

3 public static void main(String[] args) {

4 Student st1 = new Student("Jake");
5 Student st2 = new Student("Charlie");

7 System.out.println("st1 id = " + st1.id);

8 }
9 }
48 3 Programação Orientada a Objetos

Se a Student e a StudentMain estiverem no mesmo pacote,

não será necessário utilizar o import. Como declaramos id
como private, a linha 7 do código acima será um erro, pois
st1.id estará inacessı́vel de dentro da classe StudentMain.

3.3.1 Getter’s e Setter’s

Para acessar variáveis private de outras classes é comum então

disponibilizar um getter. Um getter é uma função que inicia com
Segundo as nossas convenções de
nomenclatura, após o get teremos get seguido do nome da variável que ela supostamente retorna.
o nome da variável iniciando em Se queremos disponibilizar o valor da variável id para outras
maiúsculo.
classes, então a função seria chamada de getId():
1 public class Student {
2 private String name;
3 private int id;

5 private static int counter = 10000;

7 public Student(String n) {
8 id = Student.counter++;
9 name = n;
10 }
11 public int getId() {
12 return id;
13 }
14 }

Utilizando estes modificadores, o seguinte código é válido:

1 public class StudentMain {
2 public static void main(String[] args) {
3 Student st1 = new Student("Jake");
4 Student st2 = new Student("Charlie");

6 System.out.println("st1 id = " + st1.getId());

7 }
8 }

Dica: É uma prática recomendável que as variáveis de um objeto

sejam private, isto deixa o código mais robusto. Outra razão
para declarar variáveis como private é que estamos explicita-
mente dizendo a quem for utilizar o código: “não toque nesta
variável”.

Com um getter podemos disponibilizar o valor de uma variável

private para outras classes. Se também queremos permitir que
uma variável private seja modificada por outras classes, então
precisamos de um setter. Um setter é uma função que inicia com
set seguida do nome da variável.
Um exemplo onde permitirı́amos que o id de um Student fosse
modificado seria como segue:
3.4 Vetores e Matrizes 49

1 public class Student {

2 private String name;
3 private int id;

5 private static int counter = 10000;

7 public Student(String n) {
8 id = Student.counter++;
9 name = n;
10 }
11 public int getId() {
12 return id;
13 }
14 public void setId(int newId){
15 id = newId;
16 }
17 }

Claro que para o nosso exemplo, seria mais plausı́vel que a função
setId(), na linha 14 do código acima, não existisse.
De qualquer forma, também é recomendado que as variáveis de
uma classe sejam modificadas por outras classes apenas através
de setters. Pois, como um setter é uma função normal podemos
tomar outras ações além de simplesmente atualizar o valor da
variável. Por exemplo, podemos verificar se o valor fornecido é
válido. Ou ainda, atualizar o valor de outras variáveis que depen-
dem da que está sendo alterada.

3.4 Vetores e Matrizes

Uma situação muito comum em programação é quando temos que
tratar uma grande quantidade de dados. Por exemplo, quando te-
mos que calcular a média de um conjunto de dados, resolver sis-
temas de equações, etc. Na solução destes problemas também é
comum não conhecermos o tamanho do problema até o momento
da execução do programa.
A utilização de vetores e matrizes é a forma mais elegante de
Os vetores em Java também
conhecidos por array, uma matriz é tratar estes problemas. O Java também proporciona um suporte
um array de duas dimensões. especial para os vetores. A declaração de um vetor se dá de forma
análoga a declaração de variáveis, mas com o auxı́lio dos []:
double vector[]; // double []vector; // this is also valid

Na declaração acima declaramos, estamos dizendo que existe uma

variável chamada vector e que ela apontará para um vetor de
dados do tipo double. Não precisamos informar o tamanho
(número de elementos) do vetor no momento da declaração.
Os vetores podem ser utilizados tanto para tipos primitivos quanto
para classes, sem nenhuma diferença na declaração:
50 3 Programação Orientada a Objetos

double doubleVector[];
int intVector[];

String stringVector[];
Student studentVector[];

Porém, somente a declaração de um vetor não cria o vetor. Este

comportamento é similar ao dos objetos. Para que o vetor seja
criado precisamos utilizar o new:
double doubleVector[];

doubleVector = new double[100];

Também podemos combinar os comandos acima em um só:

double doubleVector[] = new double[100];

No momento que criamos um vetor, fazemos uso dos [] nova-

mente e informamos qual é o tamanho do vetor. No código acima
estamos criando um vetor com 100 elementos. Se criados desta
forma todos os elementos vão iniciar com o valor 0. Se o vetor
não fosse de um tipo primitivo mas de uma classe, os elementos
seriam inicializados com null.

Para casos simples, também podemos inicializar vetores sem uti-

lizar o new, da seguinte forma:
int intVector[] = {10,-5,6,12,9,54};

Em Java, o primeiro elemento de um vetor é o elemento 0.

Podemos percorrer todos os elementos de um vetor da seguinte
forma:
int intVector[] = {10,-5,6,12,9,54};

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

System.out.println(n[i]);
}

Vamos exemplificar melhor a utilização de vetores com o nosso

velho exemplo da classe Student. Vamos fazer com que as
notas agora sejam um vetor, e atualizar o cálculo da média.

Depois vamos criar a classe Course onde teremos um vetor de

estudantes. Estudantes podem ser adicionados e a lista de médias
é impressa no final.
3.5 Algumas classes do java.util 51

3.5 Algumas classes do java.util

Embora a programação com objetos trate do projeto e imple-
mentação de novas classes, é importante não esquecer que os
desenvolvedores do Java já disponibilizaram um grande número
de classes que podem ser utilizadas. Algumas destas classes são
feitas para serem estendidas em novas classes, enquanto outras
estão prontas para o uso. Por exemplo, no Capı́tulo 4 a construção
de interfaces gráficas será introduzida e utilizaremos diversas clas-
ses que fazem parte do Java.
A classe que mais utilizamos até o momento foi a String, tra-
tamos dela de forma especial na Seção 2.5. Na Seção 1.6, outra
classe que utilizamos foi a Scanner, para a leitura de textos e
números do console.
O pacote java.util dispõe de diversas classes que realmente
são muito úteis. Por exemplo há classes para o tratamento de
listas de objetos, que veremos no ??.
Outra classe muito útil deste pacote é a Date, que representa
uma data e hora. Por exemplo, quando um Date é construı́do
sem argumentos o resultado é a data e hora do momento da sua
construção. Assim, uma forma fácil de apresentar a data e hora
atual é o seguinte:
System.out.println( new Date() );

Para medir tempos de execução com uma precisão de milisegun-

dos podemos utilizar a função currentTimeMillis() da
classe System. O trecho de código abaixo exemplifica como
medir o tempo de execução de uma função:
long tstart = System.currentTimeMillis();

// call the function here

computeSomething();

long elapsed = System.currentTimeMillis() - tstart;

No trecho de código acima, a variável elapsed vai conter o

tempo de execução em milisegundos.
Existem muitas outras classes e funções disponı́veis no Java ou
em bibliotecas desenvolvidas por terceiros. O objetivo desta seção
é atentar você para isto, boa parte dos problemas já foram resolvi-
dos e a solução está nas classes padrões do Java ou de terceiros.
Se você se deparar com um problema e suspeitar que ele deve ser
comum, vale a pena pesquisar se a solução já não está pronta em
algum lugar.
52 3 Programação Orientada a Objetos

3.6 Inheritance
Objetos de uma mesma classe compartilham uma mesma estru-
tura e comportamento, mas podem estar em estados diferentes
(variáveis com valores diferentes). A classe determina a estrutura
dos objetos especificando quais são as variáveis que ele contém.
Ela também determina o comportamento dos objetos, pois es-
pecifica quais são as funções que o objeto disponibiliza. Porém,
algo similar pode ser construı́do de uma forma ou de outra com a
maioria das linguagens de programação. O que realmente distin-
gui a programação orientada a objetos da programação tradicio-
nal é que podemos ter classes que compartilham parte, mas não
No Inglês são utilizados os termos
inheritance e polymorphism. toda a estrutura ou comportamento. Isto pode ser feito através
a herança e polimorfismo.

3.6.1 Inheritance - Estendendo Classes

Em Java é possı́vel estender (ampliar ou derivar) uma classe

existente. Isto é feito através da criação de uma nova classe, da
seguinte forma:
class DerivedClass extends BaseClass {
.
. // Changes and additions.
.
}

Quando fazemos isto dizemos que a classe existente foi estendida

ou derivada e que a nova classe gerada é uma sub-classe da
classe base. Quando derivamos uma classe podemos ampliar
a sua estrutura adicionando novas variáveis. Também podemos
ampliar o seu conjunto de funções. Na ?? veremos que, no caso de
funções, é possı́vel também alterar o comportamento de funções
existentes.

Nota: Não é possı́vel remover uma variável ou função através da

herança ou derivação, apenas ampliar estes conjuntos.

A nomenclatura mais aceita em Java é chamar a nova classe de

subclass e a classe original de superclass. Então em Java, para
criar uma classe chamada B como uma subclass de uma classe
chamada A, terı́amos:
class B extends A {
.
. // additions to, and modifications of,
. // stuff inherited from class A
.
}
3.6 Inheritance 53

Várias classes podem ser declaradas como subclasses da mesma

superclass. Nesse caso, as subclasses são similares na sua es-
trutura e comportamento, isto é, a parte comum que todas her-
dam da superclass. Este tipo de estrutura é comum e pode ser
representada na forma de um diagrama, como apresentado na
Figura 3.1.

Figura 3.1: Diagrama de

classes com uma mesma
superclass.

No exemplo da Figura 3.1, as classes B, C e D compartilham

a mesma superclass A. Todas as variáveis e funções da classe
A estarão disponı́veis nas suas subclasses. Já a classe E tem
como superclass a D. Sendo assim, a classe E vai ter parte da
sua estrutura descrita em A, parte em D e ainda poderá ter suas
próprias adições e modificações.
Exemplificando com um caso simples. Se quisermos desenvolver
um código que trata do registro de veı́culos. Alguns pontos sobre
este problema em particular:
• Todo veı́culo tem um dono
• Um veı́culo pode ser transferido para outro dono
• Existem diferentes tipos de veı́culos, cada um com carac-
terı́sticas diferentes
Considerando estes pontos, podemos imaginar o diagrama de clas-
ses da Figura 3.2.

Figura 3.2: Diagrama de

classes representado diferentes
veı́culos.

Parte da estrutura e comportamento pode ser compartilhada para

os diferentes tipos de veı́culos. Esta parte será implementada na
baseclass Vehicle. Criaremos uma subclass diferente para cada
54 3 Programação Orientada a Objetos

tipo de veı́culo, e nelas colocaremos as suas particularidades. Isto

pode ser representado com o seguinte código:
class Vehicle {
int registrationNumber;
Person owner; // (Assuming we already have a Person class)
void transferOwnership(Person newOwner) {
. . .
}
. . .
}

class Car extends Vehicle {

int numberOfDoors;
. . .
}

class Truck extends Vehicle {

int numberOfAxles;
. . .
}

class Motorcycle extends Vehicle {

boolean hasSidecar;
. . .
}

Supondo que temos as classes acima, a seguinte declaração é

possı́vel:
Car aCar = new Car();

Outros pontos:
• Referencias utilizando a superclass
• Variáveis especiais this e super
• O operador instanceof

3.7 Classes Abstratas e Interfaces

3.8 Lists
3.9 Arquivos
3.10 Unidades de Medida
4 Interfaces Gráficas

Até aqui nossos programas se comunicaram com o usuário apenas através do console. Neste
capı́tulo vamos aprender como construir interfaces gráficas simples para a entrada dados e
reportagem para o usuário.

Sumário
4.1 Introdução . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
4.2 JFrame . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
4.3 Layout . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
4.4 Layouts combinados com o JPanel . . . . . . . . . . . . . . . . . 59
4.5 Listeners . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
4.6 JLabel e JTextField . . . . . . . . . . . . . . . . . . . . . . . . 62
56 4 Interfaces Gráficas

4.1 Introdução
Até o momento construimos apenas programas que se comuni-
cam com o usuário utilizando a entrada e saı́da padrões de texto
System.in e System.out. Hoje em dia, o usuário de um
computador espera sempre interagir com ele através de uma in-
terface gráfica (Graphical User Interface – GUI). Java pode ser
utilizado para escrever desde applets simples até programas com-
pletos com uma sofisticada GUI. Neste livro vamos construir in-
terfaces gráficas com o swing, que é parte integrante do Java.
A maior parte das classes que vamos utilizar aqui faz parte do
pacote javax.swing.
Em termos da função main um programa gráfico é muito similar
aos programas que vinhamos escrevendo:
public class FirstGUI {
public static void main(String[] args) {
JFrame f = new JFrame();

f.setVisible(true);
}
}

Se o programa acima for executado ele vai exibir uma janela muito
pequena no canto superior esquerdo da tela. Esta janela pode ser
redimensionada, maximizada, movida ou fechada. Entretanto se
a janela é fechada, através do seu botão fechar, o programa não
é finalizado. Note no Eclipse que o programa continua rodando,
mesmo depois de fechada a janela. É preciso finalizar o programa
através do botão Terminate da janela de Debug do Eclipse ou
então através do menu Run I Terminate.
Para que o programa termine quando a janela é fechada precisa-
mos ter o seguinte código:
public class FirstGUI {
public static void main(String[] args) {
JFrame f = new JFrame();

f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

f.setVisible(true);
}
}

4.2 JFrame
Uma parte fundamental de um programa GUI é a janela. Em
Java temos vários tipos de janela que podemos utilizar, mas o
comportamento mais usual é obtido com a classe JFrame. Um
JFrame é uma janela independente que pode, por exemplo, ser
4.2 JFrame 57

a janela principal do aplicativo. Um objeto do tipo JFrame já

contém boa parte da sua funcionalidade programada. Esta classe
nos disponibiliza uma barra de tı́tulo, a janela pode ser maxi-
mizada, minimizada, redimencionada e fechada. Com o seguinte
código alteramos algumas propriedades do nosso objeto JFrame:
1 public class FirstGUI {
2 public static void main(String[] args) {
3 JFrame f = new JFrame("My First GUI Program");

5 f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

7 f.setSize(250,100);
8 f.setLocationRelativeTo(null);

10 f.setVisible(true);
11 }
12 }

Com o setSize() alteramos o tamanho da janela. Os valores

fornecidos são em pixels e o tamanho real da janela vai depender
da resolução da tela. Com o setLocationRelativeTo()
podemos centrar o objeto com relação a outra janela. Se o argu-
mento é null, a janela é centralizada na tela. Finalmente, com
a chamada setVisible() tornamos a janela visivel. Se esta
função não for chamada, nada será exibido ao usuário.
Utilizando a lógica de programação que estamos acostumados,
podemos imaginar que o programa deveria terminar logo após a
execução da linha 10, que é o último comando da main. Porém,
mesmo após a execução da última linha, o programa continua
rodando e a janela continua sendo exibida ao usuário até que a
fechemos.
O que o JFrame exibe ao usuário é conhecido como o seu
Um JFrame pode conter, além da
sua barra de tı́tulo e de seu conteúdo. Se não adicionamos nada no conteúdo de um JFrame
conteúdo, uma barra de menu, ??. ele vai conter apenas um espaço vazio. Este espaço é também
implementado por uma das classes fundamentais do Swing, a
Container. Um Container representa uma região de uma
janela. O conteúdo de um JFrame é um Container, por
exemplo:
1 public class FirstGUI {
2 public static void main(String[] args) {
3 JFrame f = new JFrame("My First GUI Program");

5 f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

7 Container content = f.getContentPane();

8 content.add(new JButton("Click me!"));

10 f.setSize(250,100);
11 f.setLocationRelativeTo(null);

13 f.setVisible(true);
14 }
15 }
58 4 Interfaces Gráficas

Com o código acima, adicionamos um botão ao nosso aplicativo.

Neste caso o botão ocupará todo o espaço do conteúdo da janela.

4.3 Layout
Conforme vamos adicionando o conteúdo de uma janela vamos
precisar organizar de que forma este conteúdo será exibido. Para
isto vamos precisar utilizar os gerenciadores de layout. Um ge-
renciador de layout é um objeto que gerencia a forma com que os
objetos são distribuı́dos quando adicionados a um Container.

4.3.1 BorderLayout

Um dos gerenciadores de layout mais úteis é o BorderLayout:

1 public class FirstGUI {
2 public static void main(String[] args) {
3 JFrame f = new JFrame("My First GUI Program");

5 f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

7 Container content = f.getContentPane();

8 content.setLayout(new BorderLayout());
9 content.add(new JButton("Click me!"), BorderLayout.PAGE_END);

11 f.setSize(250,100);
12 f.setLocationRelativeTo(null);

14 f.setVisible(true);
15 }
16 }

Com o código acima, nosso botão irá ficar sempre na parte inferior
da janela. Se tivéssemos utilizado o BorderLayout.Center
ele voltaria a ocupar toda a janela. As possı́veis possições do
BorderLayout estão apresentadas na Figura 4.1.

Figura 4.1: Regiões do

BorderLayout.

4.3.2 FlowLayout e GridLayout

Um outro gerenciador de layout muito comum é o FlowLayout.

Ele coloca os componentes em uma linha. Se o espaço horizontal
4.4 Layouts combinados com o JPanel 59

não é suficiente para colocar todos os componentes na mesma

linha, então múltiplas linhas são criadas. Por exemplo:
1 public class FlowLayoutTest {
2 public static void main(String[] args) {
3 JFrame f = new JFrame("My First GUI Program");

5 f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

7 Container content = f.getContentPane();

8 content.setLayout(new FlowLayout());

10 content.add(new JButton("Button 1"));

11 content.add(new JButton("Button 2"));
12 content.add(new JButton("Button 3"));
13 content.add(new JButton("Long-Named Button 4"));
14 content.add(new JButton("Button 5"));

16 f.pack();
17 f.setLocationRelativeTo(null);

19 f.setVisible(true);
20 }
21 }

No código acima, não informamos o tamanho desejado da janela.

Ao invés disso chamamos a função pack() que faz com que a
janela seja redimensionada para o menor tamanho de tal forma
que todo o conteúdo seja exibido.
Outro gerenciador de layout que vamos experimentar aqui é o
GridLayout. Este gerenciador é o ideal quando precisamos
exibir componentes de mesmo tamanho em linhas ou colunas.
Podemos testar o GridLayout, basta trocarmos a linha 8 do
código acima por:
1 content.setLayout(new GidLayout(0,2));

O construtor mais comum do GridLayout espera dois argu-

mentos, o número de linhas e colunas. Com o código acima
dizemos que queremos 2 colunas e 0 linhas. Com isto o número
de colunas será fixo e serão adicionadas quantas linhas forem ne-
cessárias.

4.4 Layouts combinados com o JPanel

Utilizando apenas os gerenciadores de layout que vimos até aqui
(BorderLayout, FlowLayout e GridLayout) é possı́vel
construir janelas sofisticadas. Para isto precisamos combinar estes
diferentes gerenciadores por regiões. Com o JPanel podemos
criar diferentes regiões internas ao conteúdo da janela. E o mais
importante, cada região ou painel pode ter um gerenciador de
layout diferente.
60 4 Interfaces Gráficas

Vamos exemplificar o uso do JPanel através de um exemplo sim-

ples. Vamos implementar uma calculadora de quatro operações
que deve se parecer com a imagem da Figura 4.2.

Figura 4.2: Uma calculadora

simples de 4 operações.

É claro que há diversas formas de programar uma janela similar a

da Figura 4.2. Uma implementação possı́vel é a seguinte:
1 public class SimpleCalculator extends JFrame {
2 public SimpleCalculator() {
3 super("Simple Calculator");

5 setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

7 Container content = getContentPane();

8 content.setLayout(new GridLayout(0,1));

10 JPanel xPanel = new JPanel();

11 xPanel.add(new JLabel(" x = "));
12 xPanel.add(new JTextField("0", 10));

14 JPanel yPanel = new JPanel();

15 yPanel.add(new JLabel(" y = "));
16 yPanel.add(new JTextField("0", 10));

18 JPanel buttonPanel = new JPanel();

19 buttonPanel.setLayout(new GridLayout(1,0));
20 buttonPanel.add(new JButton("+"));
21 buttonPanel.add(new JButton("-"));
22 buttonPanel.add(new JButton("*"));
23 buttonPanel.add(new JButton("/"));

25 content.add(xPanel);
26 content.add(yPanel);
27 content.add(buttonPanel);
28 content.add(new JLabel("x + y = 0", JLabel.CENTER));

30 pack();
31 }

33 public static void main(String[] args) {

34 SimpleCalculator calc = new SimpleCalculator();

36 calc.setLocationRelativeTo(null);
37 calc.setVisible(true);
38 }
39 }
4.5 Listeners 61

4.5 Listeners
Na seção anterior experimentamos como construir janelas com
botões e outros tipos de componentes. Porém ainda não vimos
como realmente responder aos comandos do usuário.
Existe uma diferença básica entre programas feitos para interagir
apenas atráves do console e programas com uma GUI. Em um
programa baseado no console, existe apenas uma única ação es-
perada do usuário. O programa fica pausado esperando que o
usuário digite algo. Quando a entrada é fornecida o programa
continua a sua execução.
Em um programa gráfico, não existe apenas uma opção. O
usuário pode clicar em um botão, modificar uma caixa de texto ou
até mesmo fechar o programa. As diferentes ações que o usuário
pode fazer disparam o que chamamos de eventos. É trabalho de
quem está escrevendo o programa decidir o que fazer quando um
evento ocorre. Podemos não fazer nada ou tomar alguma ação.
Por exemplo, podemos fazer um cálculo quando um determinado
botão recebe um clique. Sempre que um determinado evento
ocorre, o Java avisa aos listener. Um listener é um objeto que
trata um determinado tipo de evento. Quado um listener recebe o
aviso de que um evento ocorreu, ele pode executar algum código.
Assim, para programar um programa GUI, temos que decidir sobre
que eventos queremos ser avisados e então escrever um listener
para eles.
Retornando ao nosso exemplo de uma calculadora de 4 operações.
Se quisermos que algo aconteça quando o usuário pressiona o
botão + precisamos dizer ao botão que vamos ficar escutando.
Isto é feito através da função addActionListener() do
botão:
JButton add = new JButton("+");
add.addActionListener(this);
buttonPanel.add(add);

A função addActionListener() espera como argumento

um objeto que implemente a interface ActionListener. Para
que o código acima funcione, vamos precisar adaptar a declaração
da nossa classe da seguinte forma:
public class SimpleCalculator2 extends JFrame implements
ActionListener {
.
.
.
}
62 4 Interfaces Gráficas

Com esta declaração dizemos que a nossa classe amplia a JFrame

e também implementa todas as funções da interface ActionListener.

Nota: Se uma classe implementa determinada interface, então

ela deve conter implementações para todas as funções da inter-
face. Isto garante que nossa classe seja compatı́vel com qualquer
função que trabalhe com a interface.

Isto faz com que objetos da nossa classe possam ser passados para
qualquer função que espere um ActionListener. Por outro
lado, vamos ter que ter que implementar a função actionPerformed()
na nossa classe:
public void actionPerformed(ActionEvent e) {
. . .
}

Esta é a função que será chamada quando o botão for pressionado.

Como trata-se de um botão, o evento que ficaremos escutando é
um ActionEvent.

4.6 JLabel e JTextField

Nas seções anteriores utilizamos o JLabel para exibir textos
estáticos (que não podem ser alterados pelo usuário). Esta é a
função do JLabel. Adicionalmente podemos utilizar qualquer
tag de HTML para formatar os labels:
1 public class LabelSample {
2 public static void main(String[] args) {
3 JFrame f = new JFrame("JLabel Sample");

5 f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

7 Container content = f.getContentPane();

8 content.setLayout(new BorderLayout());

10 JLabel top = new JLabel("A simple centered text.",

11 JLabel.CENTER);
12 JLabel html = new JLabel(
13 "<html>We can have lables with<br>multiple lines.<br><br>
" +
14 "Actually we can use any html<br>" +
15 "tag: <u>underline</u>, <i>italic</i>, etc.<br><br>" +
16 "<h1>This is heading 1</h1>" +
17 "<h2>This is heading 2</h2></html>", JLabel.CENTER);

19 content.add(top, BorderLayout.PAGE_START);
20 content.add(html, BorderLayout.CENTER);

22 f.pack();
23 f.setLocationRelativeTo(null);

25 f.setVisible(true);
26 }
4.6 JLabel e JTextField 63

27 }

Nota: O texto de um JLabel é fixo apenas para o usuário,

que não pode alterá-lo. Podemos sempre alterar o texto de um
JLabel programaticamente com a função setText().

No exemplo anterior, quando queremos fornecer a possiblidade

que o usuário entre com algum texto ou número utilizamos o
JTextField. Podemos obter o texto que o usuário forneceu
com a função getText(). O seguinte exemplo demonstra mais
alguns detalhes desta classe:
1 public class TextFieldSample {
2 public static void main(String[] args) {
3 JFrame f = new JFrame("TextField Sample");

5 f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

7 Container content = f.getContentPane();

8 content.setLayout(new GridLayout(0, 2));

10 content.add(new JLabel("Field for anything:"));

11 content.add(new JTextField(20));

13 content.add(new JLabel("Only numbers:"));

14 NumberFormat format = NumberFormat.getNumberInstance(Locale.
ENGLISH);
15 content.add(new JFormattedTextField(format));

17 f.pack();
18 f.setLocationRelativeTo(null);

20 f.setVisible(true);
21 }
22 }

Com o código acima estamos criando dois campos de entrada de

texto. O primeiro irá aceitar qualquer tipo de texto. O segundo
só permite números que respeitam determinado formato. Caso
algo que não seja um número seja inserido, este será invalidado
quando o campo perder o foco. Para deixar o foco de um campo
basta clicar em qualquer ponto fora do campo.
II. Aplicações
5 Funções Monovariáveis

Neste capı́tulo vamos construir nosso primeiro programa em Java. Para isto vamos precisar de
algumas ferramentas e aqui apresentamos também como obter e instalar estas ferramentas.

Sumário
5.1 Representando Funções Monovariáveis . . . . . . . . . . . . . . . 66
5.2 Raizes de Funções Monovariáveis . . . . . . . . . . . . . . . . . . 66
5.3 Derivadas e o Método de Newton . . . . . . . . . . . . . . . . . . 66
5.4 Integral Aproximada de Funções Monovariáveis . . . . . . . . . . . 66
5.5 Ajustando Retas e Polinômios . . . . . . . . . . . . . . . . . . . . 66
5.6 Interpolação Linear e Cúbica . . . . . . . . . . . . . . . . . . . . . 66
66 5 Funções Monovariáveis

5.1 Representando Funções Monovariáveis

5.2 Raizes de Funções Monovariáveis
5.3 Derivadas e o Método de Newton
5.4 Integral Aproximada de Funções Monovariáveis
5.5 Ajustando Retas e Polinômios
SimpleRegression and PolynomialFitter.

5.6 Interpolação Linear e Cúbica

6 Sistemas de Equações

Neste capı́tulo vamos construir nosso primeiro programa em Java. Para isto vamos precisar de
algumas ferramentas e aqui apresentamos também como obter e instalar estas ferramentas.

Sumário
6.1 Sistemas de Equações Lineares . . . . . . . . . . . . . . . . . . . . 68
6.2 Sistemas de Equações Não-Lineares . . . . . . . . . . . . . . . . . 68
6.3 Sistemas de Equações Diferenciais Ordinárias . . . . . . . . . . . . 68
68 6 Sistemas de Equações

6.1 Sistemas de Equações Lineares

6.2 Sistemas de Equações Não-Lineares
6.3 Sistemas de Equações Diferenciais Ordinárias
7 Conteúdo Extra

Neste capı́tulo são apresentados alguns conteúdos opcionais.

Sumário
7.1 Estatı́stica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
7.2 Distribuições e Testes . . . . . . . . . . . . . . . . . . . . . . . . . 70
70 7 Conteúdo Extra

7.1 Estatı́stica
7.2 Distribuições e Testes
III. Apêndices
Lista de Atalhos

Ctrl+/ Toogle Comment: comenta/descomenta a linha

atual.
Ctrl+I Correct Indentation: corrige a identação das li-
nhas selecionadas.
Ctrl+Space Code Assist: apresenta uma lista de opções para
completar um comando.
F2 Show Documentation: exibe a documentação da
classe ou função selecionada no editor.
F3 Open Declaration: vai para onde foi declarado o
elemento atualmente selecionado.
Shift+Ctrl+O Organize Imports: organiza todos os import do
arquivo.
Apêndice A Padrões de Codificação

A SUN propõe uma série de regras de codificação em Java no seguinte endereço: http:
//java.sun.com/docs/codeconv/. Neste capı́tulo algumas destas regras são apre-
sentadas, o leitor é encorajado a visitar o site da SUN onde as regras são apresentadas na
ı́ntegra.
74 Apêndice A Padrões de Codificação

A.1 Porque Padrões de Codificação?

Utilizar padrões de codificação é importante para os programado-
res por várias razões:
• 80% do custo de um programa está relacionado com a sua
manutenção.
• Dificilmente um software é mantido durante toda a sua
existência pelo autor original.
• A utilização de convenções padrões melhora a readability
do programa, permitindo que os engenheiros entendam o
código mais rapidamente e por inteiro.
• Se o código será repassado para outros como um produto,
é preciso guarantir que este está bem organizado.

A.2 Organização dos Arquivos

A.2.1 Comentários Iniciais

Todos os arquivos devem iniciar com um comentário em bloco

identificando o código. Um exemplo de comentário inicial segue
abaixo:
/*
* This file is part of the XXXX project, Copyright notice.
*
* Version information or Date
*/

A.2.2 Comandos Package e Import

A primeira linha de um arquivo que não é um comentário deve ser

a declaração do package. Depois disso os comandos import
devem seguir. Por exemplo:
package java.util;

import java.util.regex.ASCII;
import java.io.*;

Dica: No Eclipse o comando Source I Organize Imports faz

uma ótima organização de todos os import do arquivo que está
sendo editado. A tecla de atalho é Shift+Ctrl+O.
A.2 Organização dos Arquivos 75

A.2.3 Declaração de Classes e Interfaces

A declaração de uma class ou interface deve seguir uma

determinada ordem. No seguinte exemplo de classe estas reco-
mendações são seguidas:
/**
* Class description goes here.
*
* @author Firstname Lastname
*/
public class Blah extends SomeClass {
/** classVar1 documentation comment */
public static int classVar1;

/**
* classVar2 documentation comment that happens to be
* more than one line long
*/
private static Object classVar2;

/** instanceVar1 documentation comment */

public Object instanceVar1;

/** instanceVar2 documentation comment */

protected int instanceVar2;

/** instanceVar3 documentation comment */

private Object[] instanceVar3;

/**
* ...constructor Blah documentation comment...
*/
public Blah() {
// ...implementation goes here...
}

/**
* ...method doSomething documentation comment...
*/
public void doSomething() {
// ...implementation goes here...
}

/**
* ...method doSomethingElse documentation comment...
* @param someParam description
*/
public void doSomethingElse(Object someParam) {
// ...implementation goes here...
}
}

Os principais pontos do código acima, na ordem, são:

• A declaração deve ser precedida com um bloco de comentário
de documentação (/** .. */).
• As variáveis internas da classe devem ser declaradas na or-
dem com as public, depois protected, nı́vel de pacote
(sem modificador) e, por fim private.
• Após devem ser apresentados os construtores.
76 Apêndice A Padrões de Codificação

• Por fim os métodos, preferencialmente agrupados por fun-

cionalidade. Neste caso o agrupamento por modificador
(private, etc.) não deve ser utilizado, priorizando a pro-
ximidade dos métodos relacionados para facilitar o enten-
dimento do código.

A.2.4 Organização e Indentação

A correta indentação do código em um arquivo é importante para

facilitar a sua leitura. O Java não é sensı́vel a indentação, ela
é utilizada apenas para a organização do código. Algumas regras
importantes seguem:

• Evitar linhas de código muito longas (mais do que 80 ca-

racteres).

• Colocar operadores entre espaços e 1 espaço após uma

vı́rgula.

• Não colocar espaços nos parentêses.

• Não utilizar uma linha separa para abrir chaves {.

• Se o comando ou documentação não couber em uma li-

nha de aproximadamente 80 caracteres quebrar a linha uti-
lizando os seguintes princı́pios:

– Depois de uma vı́rgula.

– Antes de algum operador.

– Uma linha de comando que é uma continuação de uma

linha anterior deve ser indentada mais a direita.

Alguns exemplos de quebras de linha seguem:

someMethod(longExpression1, longExpression2, longExpression3,
longExpression4, longExpression5);

var = someMethod1(longExpression1,
someMethod2(longExpression2,
longExpression3));

Dica: No Eclipse o comando Source I Correct Indentation faz

uma boa organização da identação do texto atualmente selecio-
nado no editor. A tecla de atalho é Ctrl+I.
A.3 Convenções de Nomes 77

A.3 Convenções de Nomes

Utilizar uma convernção para os nomes de classes, pacotes e etc.
também tornam o código mais fácil de ler. Seguindo as con-
venções a seguir é mais fácil identificar quando estamos nos re-
ferenciando a uma constante, classe ou pacote, o que é útil para
entender o código.
Na Tabela A.1 são apresentadas as convenções recomendadas
para nomes em Java.
78 Apêndice A Padrões de Codificação

Tipo Regra Exemplos

Classes Nomes de classes devem ser com-
postos por uma ou mais palavras, class Raster
onde cada palavra inicia com uma class ImageSprite
letra maiúscula. Tente manter o
nome simples, porém descritivo.
Se possı́vel evite siglas e abre-
viações.
Interfaces Seguem o mesmo padrão dos no-
mes de classes. interface RasterDelegate
interface Storing

Métodos Devem conter verbos, iniciando

com letra minúscula e com uma run();
letra maiúscula para cada nova runFast();
palavra. getBackground();

Variáveis Devem iniciar com minúsculas,

com uma letra maiúscula para int i;
cada nova palavra. Devem ser char c;
curtas mas com significado. A double tankVolume;
escolha do nome deve ser mne-
monica, ou seja, que indique o
seu objetivo para um observador
externo. Variáveis com nome de
um caracter apenas devem ser evi-
tadas, exceto para variáveis tem-
porárias ou contadores de loops.
Nomes comuns para estes tipos
de variáveis são i, j, k, l, m e
n para inteiros e c para caracte-
res.
Constantes Os nomes de constantes de-
vem ser declarados com todas double PI = 3.14159;
as letras maiúsculas, preferenci- double AVOGADRO = 6.022e23;
almente precedidos de static double PLANK = 6.26068e-34;
final para garantir que não será
possı́vel alterar o seu valor em ne-
nhum ponto do código.
Tabela A.1: Padrões de nomes em Java.
Índice 79

Índice

Ajuste, 66 chamando, 39
Applets, 9 declaração, 38
Arquivos, 54 Funções matemáticas, 37
ArrayList, 54 Funções Monovariáveis
Atribuição, 28 ajuste, 66
definindo, 66
boolean, 24 Integral, 66
break, 36 Interpolação, 66
Newton, 66
Cast, 28, 29
raı́zes, 66
Classes
abstratas, 54 Getter, 46, 48
Comentários, 26
documentação, 27 Herança, 52
Javadoc, 27 Hora, 38
por bloco, 26 hora, 51
por linha, 26
Console if, 37
imprimindo e lendo do, 18 int, 24
Construtores, 44 Interfaces, 54
continue, 36 Java
Convenções não é lento?, 8
comentários, 74 não é para internet?, 9
declaração, 75 porque?, 6
nomes, 77 virtual machine, 7
Data, 51 java.util, 51
Data e hora, 38 Javadoc, 27
Date, 38, 51 JDK
Derivadas, 66 instalando, 9
Documentação, 27 JRE
double, 24 instalando, 9

Listas, 54
Eclipse
instalando, 11 Método de Newton, 66
tutorial, 12 Math, 37
Matrizes, 49, 68
Fit, 66
float, 24 Notação Cientı́fica, 29
for, 36
Funções Objetos, 41
de objetos, 41 construtores, 44
80 Índice

getter, 46, 48
setter, 46, 48
Operadores, 27
Aritméticos, 28
atribuição, 28
Booleanos, 32
Decremento, 29
Incremento, 29
precedência, 32
Relacionais, 31

Precedência, 32
Precisão dos números, 36
print, 18
println, 18
private, 46
public, 46

Scanner, 18
seno, coseno, etc., 37
Setter, 46, 48
Sistemas de Equações
diferenciais ordinárias, 68
lineares, 68
não-lineares, 68
sqrt, 37
static, 37
String, 33
System.in, 18
System.out, 18

Tipos, 23
Tipos primitivos, 24

Unidades de Medida, 54

Variáveis, 23
de objetos, 41
estáticas, 37
locais, 39
membro, 39
static, 39
Vetores, 49
Virtual Machine, 7
instalando, 9

while, 36

Você também pode gostar

Java – Guia do Programador – 4ª Edição (Peter Jandl Junior)
Ainda não há avaliações
Java – Guia do Programador – 4ª Edição (Peter Jandl Junior)
594 páginas
Java Guia Do Programador - 4a Edição
Ainda não há avaliações
Java Guia Do Programador - 4a Edição
462 páginas
JAVA Como Programar. 10.ed. (S.L.) Pearson Prentice Hall, DeITEL, Paul DeITEL, Harvey.
Ainda não há avaliações
JAVA Como Programar. 10.ed. (S.L.) Pearson Prentice Hall, DeITEL, Paul DeITEL, Harvey.
11 páginas
Manual Datacom dm2500
60% (5)
Manual Datacom dm2500
81 páginas
Java para Iniciantes
100% (3)
Java para Iniciantes
703 páginas
05 - Livro-Completo-Java-Para-Iniciantes-Herbert-Schildt PDF
Ainda não há avaliações
05 - Livro-Completo-Java-Para-Iniciantes-Herbert-Schildt PDF
703 páginas
Resumo Da Linguagem Java
Ainda não há avaliações
Resumo Da Linguagem Java
7 páginas
Loteca
Ainda não há avaliações
Loteca
4 páginas
CURSO SWAT 2019 - Pontal
Ainda não há avaliações
CURSO SWAT 2019 - Pontal
60 páginas
Apostila Java
Ainda não há avaliações
Apostila Java
86 páginas
Apostila - Java Jse Programacao Basica - Atulizada PDF
Ainda não há avaliações
Apostila - Java Jse Programacao Basica - Atulizada PDF
105 páginas
Introdução À Ciência Da Computação Com Java e Orientação A Objetos Autor Alfredo Goldman, Fabio Kon e Paulo J. S. Silva
Ainda não há avaliações
Introdução À Ciência Da Computação Com Java e Orientação A Objetos Autor Alfredo Goldman, Fabio Kon e Paulo J. S. Silva
190 páginas
Introdução A POO em Java (Delano) PDF
Ainda não há avaliações
Introdução A POO em Java (Delano) PDF
243 páginas
299969
Ainda não há avaliações
299969
46 páginas
Programando Em Python Do Básico `a Web
No Everand
Programando Em Python Do Básico `a Web
Antonio Sérgio Nogueira
Ainda não há avaliações
Curso Java Atual 4 Pag
Ainda não há avaliações
Curso Java Atual 4 Pag
81 páginas
Lógica de Programação (Npg5072)
100% (1)
Lógica de Programação (Npg5072)
81 páginas
Slide de Aula de POO 1-2-3-4
Ainda não há avaliações
Slide de Aula de POO 1-2-3-4
79 páginas
Aula 04 - Linguagem Java
Ainda não há avaliações
Aula 04 - Linguagem Java
117 páginas
JavaIntro POO
Ainda não há avaliações
JavaIntro POO
70 páginas
Livro Completo Java para Iniciantes Herbert Schildt PDF Free
Ainda não há avaliações
Livro Completo Java para Iniciantes Herbert Schildt PDF Free
703 páginas
Apostila Blabla4
Ainda não há avaliações
Apostila Blabla4
46 páginas
Apostila Blabla5
Ainda não há avaliações
Apostila Blabla5
76 páginas
Resumo Java PDF
100% (1)
Resumo Java PDF
2 páginas
Guia de Referência (Resumo) para Linguagem de Programação Java
100% (1)
Guia de Referência (Resumo) para Linguagem de Programação Java
2 páginas
Apostila Java de Orientação A Objetos
100% (7)
Apostila Java de Orientação A Objetos
118 páginas
Pooja Va
Ainda não há avaliações
Pooja Va
118 páginas
Java Poo
Ainda não há avaliações
Java Poo
237 páginas
Sebenta de Java-Caps1a4
Ainda não há avaliações
Sebenta de Java-Caps1a4
35 páginas
Aula 02 - ConceitosIniciais - Exemplos
Ainda não há avaliações
Aula 02 - ConceitosIniciais - Exemplos
28 páginas
Java - Prof. Fábio
Ainda não há avaliações
Java - Prof. Fábio
70 páginas
Algoritmos Em C
No Everand
Algoritmos Em C
Rodrigo Luis De Souza Da Silva / Alessandreia Marta De Oliveira
Ainda não há avaliações
Programação Orientada A Objetos e Algoritmos em Java
Ainda não há avaliações
Programação Orientada A Objetos e Algoritmos em Java
437 páginas
1. Apresentao Da Disciplina e Introduo Ao Java
Ainda não há avaliações
1. Apresentao Da Disciplina e Introduo Ao Java
71 páginas
TRHB 4 B 656 B
Ainda não há avaliações
TRHB 4 B 656 B
98 páginas
Resumo Java
Ainda não há avaliações
Resumo Java
2 páginas
Apostila Completa de Java
Ainda não há avaliações
Apostila Completa de Java
6 páginas
02 Java Topicos Basicos PDF
Ainda não há avaliações
02 Java Topicos Basicos PDF
68 páginas
Resumo Java (Parte 1) - Anna Raquel Sandrini
Ainda não há avaliações
Resumo Java (Parte 1) - Anna Raquel Sandrini
5 páginas
Cópia de Atividade - 1
Ainda não há avaliações
Cópia de Atividade - 1
7 páginas
Introdução A Linguagem Java1 PDF
Ainda não há avaliações
Introdução A Linguagem Java1 PDF
368 páginas
Explorando Algoritmos
No Everand
Explorando Algoritmos
Wellington Barbosa Rodrigues
Ainda não há avaliações
Módulo II - 1 - Java Básico Part
Ainda não há avaliações
Módulo II - 1 - Java Básico Part
35 páginas
0789 - Fundamentos de Linguagem JAVA - Parte I
Ainda não há avaliações
0789 - Fundamentos de Linguagem JAVA - Parte I
97 páginas
Lógica de Programação
Ainda não há avaliações
Lógica de Programação
13 páginas
Apostila PCIA
Ainda não há avaliações
Apostila PCIA
180 páginas
Cplus
Ainda não há avaliações
Cplus
331 páginas
Caderno_de_POO (1)
Ainda não há avaliações
Caderno_de_POO (1)
10 páginas
Python Para Começar
No Everand
Python Para Começar
José Humberto De Souza Prates
Ainda não há avaliações
Um Primeiro Curso Direto De Calculo Diferencial E Integral
No Everand
Um Primeiro Curso Direto De Calculo Diferencial E Integral
Emerson De Castro Junior
Ainda não há avaliações
Coleção Livro De Bolso Jsp
No Everand
Coleção Livro De Bolso Jsp
Rogério Laureano Martins
Ainda não há avaliações
Um Primeiro Curso Direto De Álgebra Linear
No Everand
Um Primeiro Curso Direto De Álgebra Linear
Emerson De Castro Junior
Ainda não há avaliações
Introdução A Interface Gráfica No Java
No Everand
Introdução A Interface Gráfica No Java
Vitor Amadeu Souza
Ainda não há avaliações
Programação Para Google Android
No Everand
Programação Para Google Android
Vitor Amadeu Souza
Ainda não há avaliações
Análise Da Estrutura Do Banco De Dados Mongodb: Testes De Desempenho Mongodb X Mysql
No Everand
Análise Da Estrutura Do Banco De Dados Mongodb: Testes De Desempenho Mongodb X Mysql
Adriano Guzzo Rosa
Ainda não há avaliações
Programação Java Para Blackberry
No Everand
Programação Java Para Blackberry
Vitor Amadeu Souza
Ainda não há avaliações
Introdução A Estrutura De Dados
No Everand
Introdução A Estrutura De Dados
Vitor Amadeu Souza
Ainda não há avaliações
Introdução Ao Geogebra
No Everand
Introdução Ao Geogebra
Vitor Amadeu Souza
Ainda não há avaliações
Aprenda A Programar Computadores
No Everand
Aprenda A Programar Computadores
Davi Antonio Quierelli
Ainda não há avaliações
Coleção Programador Volume 4
No Everand
Coleção Programador Volume 4
Rogério Laureano Martins
Ainda não há avaliações
Apostila Técnica Linguagem C# Modo Console
No Everand
Apostila Técnica Linguagem C# Modo Console
Nelson Sadala Tavares
Ainda não há avaliações
Modelagem Numérica e Computacional com Similitude e Elementos Finitos: Desenvolvimento de Equação Preditiva para o Cálculo da Força de Retenção em Freios de Estampagem
No Everand
Modelagem Numérica e Computacional com Similitude e Elementos Finitos: Desenvolvimento de Equação Preditiva para o Cálculo da Força de Retenção em Freios de Estampagem
Marcos Vinícius Melconian
Ainda não há avaliações
Programação Em Basic Para O 8051
No Everand
Programação Em Basic Para O 8051
Vitor Amadeu Souza
Ainda não há avaliações
DIC002
Ainda não há avaliações
DIC002
4 páginas
Cartilha Iso 9001 2015 Perguntas e Respostas
100% (1)
Cartilha Iso 9001 2015 Perguntas e Respostas
13 páginas
Prova Avançada 3
Ainda não há avaliações
Prova Avançada 3
127 páginas
09122017gvtinv 755540808954
Ainda não há avaliações
09122017gvtinv 755540808954
4 páginas
1 Programação Básica em C++
Ainda não há avaliações
1 Programação Básica em C++
87 páginas
Conversor Analógico Digital Com ADC0804
Ainda não há avaliações
Conversor Analógico Digital Com ADC0804
13 páginas
Jboss Seam
Ainda não há avaliações
Jboss Seam
18 páginas
ABAP Raquel Gil Perrella Assurance IT 04 2011
Ainda não há avaliações
ABAP Raquel Gil Perrella Assurance IT 04 2011
6 páginas
Back Feed
Ainda não há avaliações
Back Feed
6 páginas
Curriculo Leonardo 2020
0% (1)
Curriculo Leonardo 2020
1 página
Tutorial
Ainda não há avaliações
Tutorial
17 páginas
Trabalho de ICC
100% (1)
Trabalho de ICC
18 páginas
Apostila Fuzzy - Osvaldo Saavedra
100% (1)
Apostila Fuzzy - Osvaldo Saavedra
54 páginas
Tutorial Rosto em Nota de Cem GIMP
Ainda não há avaliações
Tutorial Rosto em Nota de Cem GIMP
9 páginas
Estrutura Repeticao Resolvida
Ainda não há avaliações
Estrutura Repeticao Resolvida
6 páginas
Configuração GPS G3 PDF
100% (2)
Configuração GPS G3 PDF
56 páginas
Inventor Avançado 2013
100% (1)
Inventor Avançado 2013
201 páginas
Guia Do Usuário Da Suite de Aplicativos Gráficos Coreldraw 12
100% (2)
Guia Do Usuário Da Suite de Aplicativos Gráficos Coreldraw 12
639 páginas
Ranfs 1.2 PDF
Ainda não há avaliações
Ranfs 1.2 PDF
33 páginas
Pirâmide Da Automação Industrial
Ainda não há avaliações
Pirâmide Da Automação Industrial
2 páginas
Calculo 2111082497
Ainda não há avaliações
Calculo 2111082497
5 páginas
Introducao A Mecanica Lagrangiana
Ainda não há avaliações
Introducao A Mecanica Lagrangiana
38 páginas
Apostila Treinamento White Belt Online MI Domenech
100% (1)
Apostila Treinamento White Belt Online MI Domenech
113 páginas
Questões de Interface 11-10-2018
0% (1)
Questões de Interface 11-10-2018
2 páginas
Microsoft Excel 2003
Ainda não há avaliações
Microsoft Excel 2003
109 páginas
Conceitos Básicos e Regras de Derivação
Ainda não há avaliações
Conceitos Básicos e Regras de Derivação
5 páginas
Curso Excel VBA - Apostila
100% (1)
Curso Excel VBA - Apostila
87 páginas