Apostila Introducao A Linguagem Java

Introduo Linguagem de Programao JAVA
www.primebean.com.br
contato@primebean.com.br
www.primebean.com.br/joeydecurcio
Introduo Linguagem de Programao Java

por Joey Decurcio
Edio de 31/03/2014
2014 Primebean Solues em
Multiplataforma. Todos os direitos reservados.
Tecnologia
O Contedo desta apostila foi elaborada atravs de

pesquisas realizadas via internet, livros, revistas, etc.
Primebean Solues em Tecnologia Multiplataforma.
contato@primebean.com.br
+55 (18) 99111-0896
Sumrio
1. Introduo.........................................................................................................................................1
1.1 Oque Java................................................................................................................................1
1.2 Histrico.....................................................................................................................................1
1.3. Padronizao.............................................................................................................................3
1.4. Principais Caractersticas da Linguagem Java..........................................................................3
1.5. Mquina Virtual Java................................................................................................................4
1.6. Extenses..................................................................................................................................6
1.7. Frameworks..............................................................................................................................7
1.8. Ambientes de desenvolvimento................................................................................................7
1.9. Certificaes.............................................................................................................................8
1.10. Comunidade............................................................................................................................9
1.11. Licena....................................................................................................................................9
1.12. O que necessrio para programar em JAVA.........................................................................9
2. Desenvolvendo o Primeiro Programa em Java...............................................................................11
2.1. public class MeuPrimeiroPrograma........................................................................................12
2.2. public static void main............................................................................................................12
2.3. (String[ ] args).........................................................................................................................13
2.4. Inicio e Fim { }.......................................................................................................................13
2.5. System.out.println...................................................................................................................13
2.6. ("Bem vindo ao mundo Java!")...............................................................................................13
3. Regras e convenes de nomenclatura...........................................................................................14
3.1. Nome de Classes.....................................................................................................................15
3.2. Nome de Pacotes.....................................................................................................................15
3.3. Criando Pacotes......................................................................................................................16
3.4. Definindo Pacotes...................................................................................................................17
3.5. Importando Pacotes.................................................................................................................17
3.6. importando um pacote usamos o comando import.................................................................18
3.7. Nome de atributos ou variveis..............................................................................................19
3.8. Nome de atributos finais ou constantes..................................................................................19
3.9. Tipos de dados e declarao de atributos................................................................................20
3.10. Atribuio de Valores a Variveis ou Atributos....................................................................22
3.11. Inicializao de variveis ou atributos..................................................................................22
3.12. Mtodo de Sada Padro.......................................................................................................25
3.13. Controle de Texto..................................................................................................................26
3.14. Apresentando valores de variveis ou atributos....................................................................27
3.15. Concatenao........................................................................................................................28
3.15.1. Cuidados ao concatenar.................................................................................................30
3.16. Operadores e Processos........................................................................................................31

4. Controle de Fluxo...........................................................................................................................32
4.1. Execuo condicional - IF e ELSE.........................................................................................33
4.2.1. Usando IF........................................................................................................................33
4.2.2. Usando ELSE..................................................................................................................34
4.3. Switch, Case e Default............................................................................................................35
4.3.1. Default.............................................................................................................................36
4.4. Break e Continue....................................................................................................................37
4.4.1. Break...............................................................................................................................38
4.4.2. Continue..........................................................................................................................38
4.3. Estruturas de Repetio..........................................................................................................39
4.3.1. While....................................................................................................................................40
4.3.2. Do While..............................................................................................................................41
4.3.3. For........................................................................................................................................41
5. O que so e para que servem as Classes e Objetos.........................................................................43
5.1. O que so Classes e Objetos em Java.....................................................................................43
5.2. Utilidade das Classes e Objetos em Java................................................................................44
5.2.1. Agrupar coisas semelhantes............................................................................................44
5.2.2. Crie uma vez, use quantas vezes quiser..........................................................................45
5.2.3. Altere uma parte do cdigo, e a mudana se propagar em todo o cdigo.....................45
5.2.4. Classe parte, vida parte..............................................................................................45
5.2.5.Como saber quando usar Classes e Objetos em Java.......................................................46
5.3. Criao de Classe....................................................................................................................47
5.4. Mtodos Construtores.............................................................................................................48
6. Estrutura de Dados.........................................................................................................................49
6.1. Vetores e Matrizes...................................................................................................................52
6.2. Vetor........................................................................................................................................53
6.2.1 Inicializao direta de Vetor.............................................................................................55
6.3. Matrizes..................................................................................................................................55
6.4. ArrayList.................................................................................................................................56
6.4.1. O que so ArrayList em Java..........................................................................................57
6.4.2. Como declarar e usar ArrayList em Java........................................................................58
6.4.3. Exemplo de uso do ArrayList..........................................................................................58
7. Constantes.......................................................................................................................................61
8. Funes...........................................................................................................................................63
8.1. Criando funes sem argumentos...........................................................................................63
8.2. Funes com argumentos........................................................................................................64
8.3. Funes que retornam valores................................................................................................65
9. Igualdade de Objetos em java - equals() e hashCode()..................................................................67
9.1. Equals:....................................................................................................................................69
9.2. HashCode:...............................................................................................................................71
10. Representao textual de objetos - mtodo toString()..................................................................73
11. Instanciando Objetos....................................................................................................................76

12. Auto Referencia de Objetos - This...............................................................................................77
13. Sobrecarga de mtodos.................................................................................................................78
14. Acesso a Membros e Mtodos......................................................................................................81
15. Encapsulamento - public, private e protected...............................................................................84
15.1. Public....................................................................................................................................85
15.2. Private...................................................................................................................................86
15.3. Protected...............................................................................................................................86
15.4. Sem Modificador (Padro)....................................................................................................86
15.5. Mtodos Acessores - Getters e Setters..................................................................................87
15.5.1. Set..................................................................................................................................87
15.5.2. Get.................................................................................................................................88
15.5.3. Is....................................................................................................................................88
16. Herana.........................................................................................................................................89
17. Enum.............................................................................................................................................93
18. Interfaces......................................................................................................................................98
18.1. Usando uma Interface em uma Classe..................................................................................98
19. Annotations.................................................................................................................................102
19.1. Uso de Annotations.............................................................................................................102
19.2. Criando uma Annotation.....................................................................................................103
19.3. Adicionar Annotations ao Javadoc......................................................................................105
20. Classes Abstratas e Mtodos Abstratos......................................................................................105
21. Polimorfismo..............................................................................................................................110
22. Typecast - Casting.......................................................................................................................112
22.1. Typecast de Dados Primitivos.............................................................................................113
22.2. Typecast de Classes e Objetos.............................................................................................114
23. Instanceof....................................................................................................................................116
24. Generics......................................................................................................................................117
24.1.Criando classes usando generics..........................................................................................117
24.2. Instanciar uma classe genrica............................................................................................119
25. Excees.....................................................................................................................................121
25.1. Try e Catch..........................................................................................................................121
25.2. Finally.................................................................................................................................122
26. Classes Numricas......................................................................................................................124
26.1. Obtendo Tipo Primitivo de um Objeto Numrico..............................................................125
26.2. Comparando Nmeros........................................................................................................126
26.7. Classes Integer, Float, Short, Byte, Long e Double............................................................126
26.7.1. Anlise de Dados.........................................................................................................126
26.7.2. Converso Para String.................................................................................................128
26.8. Classe Math.........................................................................................................................128
26.8.1. Constantes...................................................................................................................129
26.8.2. Mximo e Mnimo......................................................................................................130
26.8.3. Potncias e razes........................................................................................................130

26.8.4. Logaritmo....................................................................................................................131
26.8.5. Arredondamentos e Valores Absolutos........................................................................132
26.8.6. Trigonometria..............................................................................................................133
26.8.7. Nmeros Randmicos.................................................................................................134
27. String..........................................................................................................................................135
27.1. Concatenao de Strings.....................................................................................................137
27.2. Tamanho da string - length()...............................................................................................137
24.3. Letras Maisculas e Minsculas.........................................................................................138
24.4. Comparao........................................................................................................................138
24.5. Incio e fim..........................................................................................................................140
24.6. Caracter na posio.............................................................................................................141
24.7. ndice da String...................................................................................................................141
24.8. Substituir string ou parte dela.............................................................................................142
24.9. Verificar contedo da string................................................................................................143
24.10. Dividindo em vrios vetores ou arrays.............................................................................143
24.11. Substring...........................................................................................................................144
25. Manipulando datas em Java........................................................................................................145
25.1. Date(java.util.Date).............................................................................................................146
25.3. DateFormat(java.text.DateFormat).....................................................................................148
26. Uma Introduo API Swing.....................................................................................................151
26.1. JoptionPane.........................................................................................................................151
26.2. Caixas de Dilogo Input Text.............................................................................................152
26.3. Caixas de Dilogo Confirm................................................................................................153
26.4. Caixa de Dilogo de Mensagem.........................................................................................154
26.5. Input Dialogs.......................................................................................................................156
26.5.1. Obter valor de showInputDialog.................................................................................158
26.5.2. Input Dialog com lista de opes................................................................................159
1. Introduo
1.1 Oque Java
Java uma linguagem de programao orientada a objeto desenvolvida na dcada
de 90 por uma equipe de programadores chefiada por James Gosling, na empresa Sun
Microsystems. Diferentemente das linguagens convencionais, que so compiladas para
cdigo nativo, a linguagem Java compilada para um "bytecode" que executado por
uma mquina virtual. A linguagem de programao Java a linguagem convencional
da Plataforma Java, mas no sua nica linguagem.
1.2 Histrico
Em 1991, na Sun Microsystems, foi iniciado o Green Project, o bero do Java, uma
linguagem de programao orientada a objetos. Os mentores do projeto eram Patrick
Naughton, Mike Sheridan, e James Gosling. O objetivo do projeto no era a criao de
uma nova linguagem de programao, mas antecipar e planejar a prxima onda do
mundo digital. Eles acreditavam que, em algum tempo, haveria uma convergncia dos
computadores com os equipamentos e eletrodomsticos comumente usados pelas
pessoas no seu dia-a-dia.
Para provar a viabilidade desta idia, 13 pessoas trabalharam arduamente durante
18 meses. No vero de 1992 eles emergiram de um escritrio de Sand Hill Road no Menlo
Park com uma demonstrao funcional da idia inicial. O prottipo se chamava *7 (leia-se
StarSeven), um controle remoto com uma interface grfica touchscreen. Para o *7, foi
criado um mascote, hoje amplamente conhecido no mundo Java, o Duke. O trabalho do
Duke no *7 era ser um guia virtual ajudando e ensinando o usurio a utilizar o
equipamento.
O *7 tinha a habilidade de controlar diversos dispositivos e aplicaes. James

Gosling especificou uma nova linguagem de programao para o *7. Gosling decidiu
batiz-la de Oak, que quer dizer carvalho, uma rvore que ele podia observar quando
olhava pela sua janela. O prximo passo era encontrar um mercado para o *7. A equipe
achava que uma boa idia seria controlar televises e vdeo por demanda com o
equipamento. Eles construram um demo chamado MovieWood, mas infelizmente era
muito cedo para que o vdeo por demanda bem como as empresas de TV a cabo
pudessem viabilizar o negcio.
A idia que o *7 tentava vender, hoje j realidade em programas interativos e
tambm na televiso digital. Permitir ao telespectador interagir com a emissora e com a
programao em uma grande rede cabos, era algo muito visionrio e estava muito longe
do que as empresas de TV a cabo tinham capacidade de entender e comprar. A idia
certa, na poca errada.
Entretanto, o estouro da Internet aconteceu e rapidamente uma grande rede
interativa estava se estabelecendo. Era este tipo de rede interativa que a equipe do *7
estava tentando vender para as empresas de TV a cabo. E, da noite para o dia, no era
mais necessrio construir a infra-estrutura para a rede, ela simplesmente estava l.
Gosling foi incumbido de adaptar o Oak para a Internet e em janeiro 1995 foi lanada uma
nova verso do Oak que foi rebatizada para Java. A tecnologia Java tinha sido projetada
para se mover por meio das redes de dispositivos heterogneos, redes como a Internet.
Agora aplicaes poderiam ser executadas dentro dos browsers nos Applets Java e
tudo seria disponibilizado pela Internet instantaneamente. Foi o esttico HTML dos
browsers que promoveu a rpida disseminao da dinmica tecnologia Java. A velocidade
dos acontecimentos seguintes foi assustadora, o nmero de usurios cresceu
rapidamente, grandes fornecedores de tecnologia, como a IBM anunciaram suporte para
a tecnologia Java.
Desde seu lanamento, em maio de 1995, a plataforma Java foi adotada mais
rapidamente do que qualquer outra linguagem de programao na histria da
computao. Em 2003 Java atingiu a marca de 4 milhes de desenvolvedores em todo

mundo. Java continuou crescendo e hoje uma referncia no mercado de
desenvolvimento de software. Java tornou-se popular pelo seu uso na Internet e hoje
possui seu ambiente de execuo presente em web browsers, mainframes, SOs,
celulares, palmtops e cartes inteligentes, entre outros.
1.3. Padronizao
Em 1997 a Sun Microsystems tentou submeter a linguagem a padronizao pelos
orgos ISO/IEC e ECMA, mas acabou desistindo. Java ainda um standard de fato, que
controlada atravs da JCP Java Community Process. Em 13 de Novembro de 2006, a
Sun lanou a maior parte do Java como Software Livre sob os termos da GNU General
Public License (GPL). Em 8 de Maio de 2007 a Sun finalizou o processo, tornando
praticamente todo o cdigo Java como software de cdigo aberto, menos uma pequena
poro que a Sun no possui copyright.
1.4. Principais Caractersticas da Linguagem Java

A linguagem Java foi projetada tendo em vista os seguintes objetivos:
Orientao a objeto - Baseado no modelo de Smalltalk e Simula67;
Portabilidade - Independncia de plataforma - "write once run anywhere";
Recursos de Rede - Possui extensa biblioteca de rotinas que facilitam a cooperao com
protocolos TCP/IP, como HTTP e FTP;
Segurana - Pode executar programas via rede com restries de execuo;
Alm disso, podem-se destacar outras vantagens apresentadas pela linguagem:
Sintaxe similar a Linguagem C/C++.

Facilidades de Internacionalizao - Suporta nativamente caracteres Unicode;
Simplicidade na especificao, tanto da linguagem como do "ambiente" de execuo
(JVM);
distribuda com um vasto conjunto de bibliotecas (ou APIs);
Possui facilidades para criao de programas distribudos e multitarefa (mltiplas linhas
de execuo num mesmo programa);
Desalocao de memria automtica por processo de coletor de lixo (garbage collector);
Carga Dinmica de Cdigo - Programas em Java so formados por uma coleo de
classes armazenadas independentemente e que podem ser carregadas no momento de
utilizao.
1.5. Mquina Virtual Java

Programas Java no so traduzidos para a linguagem de mquina,como outras
linguagens estaticamente compiladas e sim para uma representao intermediria,
chamada de bytecodes.
Os bytecodes so interpretados pela mquina virtual Java (JVM - Java Virtual
Machine). Muitas pessoas acreditam que por causa desse processo, o cdigo interpretado
Java tem baixo desempenho. Durante muito
tempo esta foi uma afirmao verdadeira.
Porm novos avanos tm tornado o compilador dinmico (a
JVM),
em
muitos
casos, mais eficiente que o compilador esttico.

Java hoje j possui um desempenho prximo do C++. Isto possvel graas a
otimizaes como a
compilao especulativa, que aproveita o tempo ocioso do
processador para pr-compilar bytecode para cdigo nativo. Outros mecanismos ainda
mais elaborados como o HotSpot da Sun, que guarda informaes disponveis somente
em tempo de execuo (ex.: nmero de usurios, processamento usado, memria
disponvel), para otimizar o funcionamento da JVM, possibilitando que a JVM v
"aprendendo" e melhorando seu desempenho. Isto uma realidade to presente que hoje
fcil encontrar programas corporativos e de misso crtica usando tecnologia Java. No
Brasil, por exemplo, a maioria dos Bancos utiliza a tecnologia Java para construir seus
home banks, que so acessados por milhares de usurios diariamente.
Grandes stios como o eBay utilizam Java para garantir alto desempenho. E a cada
ano Java tem se tornado mais rpido, na medida que se evolui o compilador dinmico.
Essa implementao no entanto tem algumas intrnsecas. A pr-compilao exige
tempo, o que faz com que programas Java demorem um tempo significativamente maior
para comearem a funcionar. Soma-se a isso o tempo de carregamento da mquina
virtual. Isso no um grande problema para programas que rodam em servidores e que
deveriam ser inicializados apenas uma vez. No entanto isso pode ser bastante indesejvel
para computadores pessoais onde o usurio deseja que o programa rode logo depois de
abri-lo.
A prxima verso da mquina virtual produzida pela Sun promete novos recursos
que iro minimizar este fato. O Java ainda possui uma outra desvantagem considervel
em programas que usam bastante processamento numrico. O padro Java tem uma
especificao rgida de como devem funcionar os tipos numricos. Essa especificao
no condiz com a implementao de pontos flutuantes na maioria dos processadores o
que faz com que o Java seja significativamente mais lento para estas aplicaes quando
comparado a outras linguagens.
Os bytecodes produzidos pelos compiladores Java podem ser usados num
processo de engenharia reversa para a recuperao do programa-fonte original. Esta
uma caracterstica que atinge em menor grau todas as linguagens compiladas. No entanto
j existem hoje tecnologias que "embaralham" e at mesmo criptografam os bytecodes
praticamente impedindo a engenharia reversa.
1.6. Extenses
Extenses em Java:
J2SE (Standard Edition)
J2EE (Enterprise Edition)
J2ME (Micro-Edition for PDAs and cellular phones)
JCE (Java Cryptography Extension)
JMF (Java Media Framework)
JNDI (Java Naming and Directory Interface)
JSML (Java Speech API Markup Language)
JDBC (Java Database Connectivity)
JMS (Java Message Service)
JAAS (Java Authentication and Authorization Service)
JDO (Java Data Objects)
JAIN (Java API for Integrated Networks)
JDMK (Java Dynamic Management Kit)
Jini (a network architecture for the construction of distributed systems)
Jiro
JXTA (open source-based peer-to-peer infrastructure)
Java Card
JavaSpaces
JMI (Java Metadata Interface)
JMX (Java Management Extensions)
JSP (JavaServer Pages)
JSF (JavaServer Faces)
JNI (Java Native Interface)
J3D (A high level API for 3D graphics programming)
JOGL (A low level API for 3D graphics programming, using OpenGL)

OSGi (Dynamic Service Management and Remote Maintenance)
SuperWaba (JavaVMs for handhelds)
MARF (Modular Audio Recognition Framework)
JavaFX
1.7. Frameworks
possvel utilizar frameworks para facilitar o desenvolvimento de aplicaes.
Dentre os mais utilizados pode-se destacar:
Hibernate ferramenta para ORM;
Spring ferramenta que auxilia principalmente implementao de injeo de
dependncias e inverso de controle;
Log4j ferramenta para facilitar a criao de logs na aplicao;
Junit ferramenta para auxiliar na criao de testes unitrios;
Struts controlador MVC (Model 2) web.
JSF Framework para desenvolvimento WEB MVC Atual Especificao Java
1.8. Ambientes de desenvolvimento

possvel desenvolver aplicaes em Java atravs de vrios ambientes de
desenvolvimento integrado (IDE's). Dentre as opes mais utilizadas pode-se destacar:
Eclipse um projeto aberto iniciado pela IBM;
NetBeans um ambiente criado pela empresa Sun Microsystems;
JBuilder um ambiente desenvolvido pela empresa Borland;

JDeveloper uma IDE desenvolvida pela empresa Oracle;
JCreator um ambiente desenvolvido pela Xinox.
BlueJ um ambiente desenvolvido por uma faculdade australiana(muito bom para
iniciantes).
Greenfoot bem parecido com o BlueJ
JGRASP bom para intermedirios, feito pela equipe do projeto GRASP.
IntelliJ IDEA uma IDE desenvolvida pela JetBrains (considerada por muitos a melhor
IDE do mercado).
1.9. Certificaes
A linguagem Java est consolidada entre as mais utilizadas em todo mundo, com
ela podemos desenvolver diversos tipos de sistemas, dos mais simples aos mais robustos
funcionando em diferentes plataformas. Uma tima maneira conseguir uma oportunidade
nesse mercado to promissor conhecendo a fundo como a linguagem funciona, e uma
certificao Java com certeza um timo caminho para isso.
Os benefcios que uma certificao pode trazer so muitos, na viso do mercado
um profissional certificado comprova no s proficincia na tecnologia, mas tambm
outras qualidades como disciplina, autodidatismo e dedicao alm de claro
diferenciao em relao a outros candidatos com experincia equivalente.
Embora a valorizao do seu currculo no mercado seja muito importante, o
benefcio maior ser o aprendizado que voc ser capaz de adquirir para ser um bom
profissional. Alguns pontos que podem ser destacados em relao ao aprendizado que
essa certificao pode trazer so:

Melhor entendimento de orientao a objetos;
Melhor capacidade de analisar e resolver problemas;
Melhor qualidade de cdigo;
Conhecimento diferenciado da linguagem Java.
1.10. Comunidade
A comunidade de desenvolvedores Java rene-se em grupo denominados JUGs
(Java User Groups). No Brasil o movimento de grupos de usurios expandiu-se bastante
e tem formado alguns dos maiores grupos de usurios Java do mundo, como por exemplo
o PortalJava e o GUJ.
1.11. Licena
A Sun disponibiliza a maioria das distribuies Java gratuitamente e obtm receita
com programas mais especializados como o Java Enterprise System. Em 13 de novembro
de 2006, Sun liberou partes de Java como software livre, sob a licena GNU General
Public License (GPL).
1.12. O que necessrio para programar em JAVA

Para programar em Java, no necessrio ter programado antes. Porm, ficaria
mais fcil se tiver conhecimento em linguagem Orientada a Objeto, porque Java
totalmente estruturada em objetos (Classes, mtodos, abstrao, etc).
10
Para comear a programar ser necessrio fazer o download do JDK (Java

Development Kit - Kit de desenvolvimento Java) que gratuito e pode ser obtido direto do
site da Oracle, a Oracle comprou a Sun Microsystem e atualmente mantm a tecnologia
Java.
Alm disso, tambm, um compilador de Java. Existem vrios tipos, uns mais leves
e simples e outros mais pesados e complexos de usar. Se no souber qual usar, verifique
a lista abaixo.
Para baixar os compiladores ou para mais informaes, clique no nome do compilador.
Nome
Eclipse
JBuilder
JEdit
JDeveloper
Gratuito Descrio
sim
Eclipse uma IDE de cdigo aberto desenvolvido inicialmente

pela IBM e posteriormente doada para a comunidade do sofware
livre. Utilizada largamente, tem grandes diferenciais como a
possibilidade de instalao de vrios plug-ins. Uma verso em
portugus mantida no site oficial que conhecida como Eclipse
Europa.
sim
JBuilder uma IDE para desenvolvimento de aplicaes mais

grficas, a partir de JFames. O JBuilder foi desenvolvido pela
Borland (a mesma que produz o C++ Builder) utilizando
tecnologias da comunidade do Eclipse Europa. O site CodeGear
que faz a distribuio dos softwares da Borland mantm duas
verses: uma Enterprise (pago) e a verso trial (mais bsica,
porm gratuita). O problema maior do JBuilder para quem no
tem internet de banda larga, pois os arquivos de downloads
chegam a exagerados 1,8 Gb.
sim
JEdit um Ambiente de Desenvolvimento Integrado criado pela

Xinox Software com o ncleo desenvolvido por Slava Pestov.
Atualmente, distribudo sobre a licena GPL 2.0 (software livre)
tem uma interface mais limpa e simples que outras IDEs, bom
para quem est comeando.
sim
IDE desenvolvido pela Oracle. Cobre todo processo de produo

do software em java, desde o desenvolvimento do cdigo at a
implantao do software. Oferece uma tima estrutura de UML
com diagramao do cdigo.
NetBeans
sim
11
O compilador que faz parte da prpria gama de produtos da Sun

Microsystems. Com capacidade de programao em vrios
ambientes como C++, Desenvolvimento para sofwares de celular
(mobile), Ruby on Rails e vrios outros. Netbeans uma
ferramenta de desenvolvimento Java poderosa, mas todo este
poder requer uma mquina no muito modesta.
Ento, mos obra, instale um compilador e comece seu projeto.
2. Desenvolvendo o Primeiro Programa em Java

Veremos aqui o nosso primeiro cdigo em linguagem Java. A nica coisa que esse
programa faz imprimir (mostrar) na tela uma mensagem dizendo: Bem vindo ao mundo
Java!.
//Primeiro programa em Java
public class MeuPrimeiroPrograma {
public static void main(String[] args) {
System.out.println("Ol, Mundo!");
}
}
Primeiramente, iremos entender algumas estruturas bsicas da linguagem.
//
Usamos // para indicar que foi iniciado um comentrio. Um comentrio serve
apenas para documentar o cdigo. Isso quer dizer que, ao ser executado este programa,
as linhas marcadas como comentrio sero ignoradas.
Este tipo de comentrio de linha nica, ou seja, comea nas barras e termina no
final da linha. Se quisermos criar comentrio de vrias linhas podemos utilizar /* */, no
12
qual /* inicia o comentrio e */ termina.
Por exemplo:
//Este um comentrio de uma linha
/*Este um um comentrio
de vrias
linhas*/
2.1. public class MeuPrimeiroPrograma

public class MeuPrimeiroPrograma a criao da classe. Como Java totalmente
orientado a objeto, sua programao feita dentro de classes e mais classes. O assunto
de classes ser abordado mais afrente. O importante a princpio entender que o
programa para funcionar deve ter pelo menos uma classe com o mtodo principal (main).
2.2. public static void main

public static void main o mtodo principal do cdigo. Quando executamos um
programa esse mtodo que chamado. Em outras palavras, sem ele no h programa.
13
2.3. (String[ ] args)

(String[] args) o argumento passado ao mtodo main. Qualquer programa pode
ser iniciado ou no com argumentos que modificam sua execuo, trataremos
futuramente de argumentos com programas.
2.4. Inicio e Fim { }

As chaves so usadas para marcar o inicio e o fim de um bloco de dados. No caso
deste algortmo, ele marca o cdigo que ser executado na classe MeuPrimeiroPrograma
e tambm todo o cdigo que ser executado quando o mtodo main for chamado.
2.5. System.out.println
System.out.println a sada padro de Java. este mtodo que indica o que deve
aparecer na tela.
2.6. ("Bem vindo ao mundo Java!")

("Bem vindo ao mundo Java!") o argumento do mtodo System.out.println. Neste
caso o que deve ser apresentado na tela.
Toda linha de comando em Java termina com um ponto-e-vrgula (;).
14
Bem, isso o necessrio para comearmos a programar em Java. Logicamente,

muitos conceitos foram deixados de lado nesta pequena prvia, mas veremos mais
aprofundadamente nas prximas pginas.
3. Regras e convenes de nomenclatura

Quando programamos em Java, devemos levar em considerao as convenes
de nomenclatura para deixar nosso cdigo o mais legvel e documentvel possvel, pois
um dos objetivos da programao orientada a objetos o reaproveitamento do cdigo.
muito provvel que quem no tenha experincia com programao sinta
dificuldade de identificar todos os termos utilizados neste artigo, mas garantimos que tudo
que ser visto aqui ser detalhado mais adiante, embora que este artigo se torna trivial a
medida que programamos. Portanto, quem j conhece programao em algum outro tipo
de linguagem (como Delphi ou C++) aconselhamos que prossiga para a prxima pgina.
Porm, se nunca programou antes, com certeza, este artigo ser didtico o
suficiente para que entenda essas regras. Muitos compiladores como Eclipse e NetBeans
do um grande auxilio na hora de criarmos nosso projeto nos informando sobre as
convenes de nomenclatura no momento que estamos criando os pacotes, classes,
etc...
15
3.1. Nome de Classes

Por conveno, toda classe deve comear com uma letra maiscula e, de
preferncia, no pode conter letras no ASCII (caracteres de lngua de origem latina,
como caracteres acentuados). Portanto, no possvel declarar uma classe com qualquer
caracter especial (@, #, $, %, &, *, _, etc...) ou nmero.
Caso o nome de uma classe seja composto por mais de uma palavra, a primeira
letra de cada palavra deve ser em maiscula. O nome da classe deve ser exatamente o
mesmo nome de seu arquivo fonte ( .java ).
O nome da classe deve fazer referncia total ao seu objeto (atributos e mtodos
contidos dentro da classe).
Por exemplo: se tivermos uma classe com os atributos canal, volume e sintonia; e
os mtodos mudarCanal (), aumentarVolume () e diminuirVolume (); ento, possivelmente
chamaramos esta classe de TV ou Televisao. Contudo, em uma classe que contivesse o
atributo corDasPenas e o mtodo voar () jamais chamaramos de Pessoa (por que
pessoas no tem penas e nem voam).
Exemplos
de
nomes
de
classes:
Pessoa,
ImpostoDeRenda,
Conta,
AgenciaDeEmprego, ...
3.2. Nome de Pacotes

O padro da sun para dar nome aos pacotes relativo ao nome da empresa que
desenvolveu a classe:
br.com.nomedaempresa.nomedoprojeto.subpacote
br.com.nomedaempresa.nomedoprojeto.subpacote2
16
br.com.nomedaempresa.nomedoprojeto.subpacote2.subpacote3
Os pacotes s possuem letras minsculas, no importa quantas palavras estejam
contidas nele. Esse padro existe para evitar ao mximo o conflito de pacotes de
empresas diferentes.
Usamos pacotes para organizar as classes semelhantes. Pacotes, a grosso modo,
so apenas pastas ou diretrios do sistema operacional onde ficam armazenados os
arquivos fonte Java e so essenciais para o conceito de encapsulamento, no qual so
dados nveis de acesso as classes.
PS: Java possui um pacote padro que utilizado quando programamos. As classes do
pacote padro de bibliotecas no seguem essa nomenclatura, que foi dada para
bibliotecas de terceiros.
O nome do pacote deve fazer referncia total s funes exercidas pelas classes
dentro do pacote, pois pacotes servem basicamente para organizar os arquivos de cdigo
fonte de nosso projeto.
Exemplos de nomes de pacotes:
br.com.nomedaempresa.nomedoprojeto.criptografia;
br.com.nomedaempresa.nomedoprojeto.entidade;
br.com.nomedaempresa.nomedoprojeto.dao;
3.3. Criando Pacotes

Muitas IDE's criam automaticamente os pacotes como uma forma eficaz de
organizao, mas a criao de pacote pode ser feita diretamente no sistema operacional.
Basta que criemos uma pasta e lhe demos um nome. Aps isso, devemos gravar todos os
arquivos fonte de java dentro desta pasta.
17
3.4. Definindo Pacotes

Agora que j possumos a pasta que ser nosso pacote, devemos definir em nossa
classe a qual pacote ela pertence. Isso feito pela palavra reservada package. Package
deve ser a primeira linha de comando a ser compilada de nossa classe.
Portanto, se tivssemos criado uma sequencia de pastas: br.com.primebean e
fossemos criar uma classe nesta pasta (pacote), o comeo de nosso cdigo seria:
br.com.primebean;.
3.5. Importando Pacotes

Java possui vrios pacotes com outros pacotes internos e vrias classes j prontas
para serem utilizadas. Dentre os pacotes Java podemos determinar dois grandes pacotes:
o pacote java, que possui as classes padres para o funcionamento do algortmo; e o
pacote javax, que possui pacotes de extenso que fornecem classes e objetos que
implementam ainda mais o pacote java.
Exemplo: o pacote AWT (Abstract Windowing Toolkit) possui as classes necessrias para
se criar um ambiente grfico API (Janelas) e est fortemente ligado as funes nativas do
Sistema Operacional, ou seja, ele pertence ao pacote java. Mas, o pacote SWING no
ligado fortemente as funes nativas do Sistema Operacional, mas as funes do AWT, ou
seja, SWING complementa o AWT, portanto SWING faz parte do pacote de extenso
javax.
Para utilizar as milhares de classes contidas nos inmeros pacotes de Java
devemos ou nos referenciar diretamente a classe ou import-la.
18
3.6. importando um pacote usamos o comando import.

Para separar um pacote de seu sub-pacote usamos um ponto (como no acesso a
membros de classe). Ao importarmos um pacote podemos utilizar um coringa, o astersco
(*). O astersco serve para importar todos os sub-pacotes e classes do pacote que est
definido.
Ex.: import java.awt.*;. Isso importar todos os sub-pacotes pertencentes ao pacote AWT.
Ou podemos definir diretamente qual pacote desejamos.
Ex.: import javax.swing.JoptionPane;.
Isso ir importar apenas o sub-pacote JOptionPane do pacote SWING.
A diferena entre as duas formas de importao de pacotes o consumo de
recursos do computador. Como o asterisco importa todos os sub-pacotes, o consumo de
memria ser alto e, muito provavelmente, no usaremos todas as classes de todos os
pacotes importados. Por isso, o recomendado sempre importar apenas o pacote que
ser utilizado.
Para consolidar o que foi visto at aqui, o cdigo abaixo ilustra o uso de pacotes.
package br.com.primebean.mensagem;
import javax.swing.JOptionPane;
public class Mensagem {
public static void main (String args[]){
JoptionPane.showMessageDialog(null, "Bem vindo ao mundo de Java!");
}
}
A classe acima est no pacote br.com.primebean.mensagem. No nosso programa
estamos utilizando o mtodo showMessageDialog que pertence classe JOptionPane
que est no pacote de extenso SWING que tivemos que importar.
19
3.7. Nome de atributos ou variveis

Para quem j programou antes em alguma linguagem de programao no
orientada a objetos, deve achar estranho o termo atributo porque, na verdade, est mais
acostumado com o termo varivel.
Mas, qual a diferena entre atributos e variveis? Nenhuma.
Atributos e variveis so a mesma coisa em questo de funcionalidade. Ambos so
endereos de memria que tem um espao ou tamanho definido de acordo com o tipo de
dado que ser guardado, por exemplo:
caracter, nmero, nmero decimal, etc. Em Java, costumamos utilizar o termo atributo,
que nada alm do que uma varivel que est dentro de uma classe. Como tudo que
fazemos em Java est contido dentro de uma classe, ento usamos o termo atributo ao
invs de varivel.
Os atributos (variveis) podem comear com qualquer letra e os caracteres $ ou _,
porm no podem comear com nmeros. Caso o nome de um atributo (varivel) seja
composto por mais de uma palavra, a primeira letra de cada palavra deve ser em
maiscula.
Exemplos de nomes de atributos ou variveis: x, y, resultado, valorDeX, valorDeY,
ligado, ...
3.8. Nome de atributos finais ou constantes

Os atributos finais (constantes) devem ser escritos em letras maisculas. Usamos
underline (_) para separar nomes compostos de atributos finais (constantes).
Exemplos
de
nomes
de
PARAR_DE_EXECUTAR,
atributos
finais
ou
constantes:
TAMANHO,
20
3.9. Tipos de dados e declarao de atributos

Todo programa de computador deve ser capaz de lidar com dados para conseguir
fazer seus processos como, por exemplo, somar, multiplicar, dividir, etc... Usar atributos
a melhor forma de manipular os dados. Os tipos de dados so o que definem a
quantidade de memria do computador que ser utilizado para guardar tal dado. Cada
tipo de dado tem um tamanho diferente e por consequncia seu alcance tambm.
O que queremos dizer que se declararmos um atributo para guardar um nmero
inteiro, jamais poderemos guardar um nmero decimal, porque um nmero decimal ocupa
mais espao de memria que um inteiro. Para declararmos qualquer tipo de atributo,
usamos a seguinte ordem: primeiro o tipo de dado e depois o nome do atributo. Se no
souber como nomear um atributo, veja as regras e convenes de nomenclatura.
Vamos iniciar com os tipos de dados inteiros que so os mais simples. Em Java, os
nmeros inteiros so divididos em quatro tipos: byte, short, int e long. Esses quatro
guardam o mesmo tipo de dado, mas ocupam espaos de memria diferente, o que afeta
em seu alcance.
O tipo byte o de menor alcance entre os inteiros. Como o prprio nome sugere,
ele consome apenas um byte (8 bits) e pode guardar valores entre -128 e 127. O tipo
short guarda inteiros de 2 bytes (16 bits) e pode guardar nmeros entre -32.768 a 32.767.
O tipo int o tipo de dado mais comum. Ele consome 4 bytes (32 bits) e guarda
valores entre -2.147.483.648 e 2.147.483.647. Long o tipo de dado com maior alcance
entre os inteiros. Consequentemente, tambm o que ocupa mais espao (8 bytes ou 64
bits).
Tem
um
grande
alcance
que
fica
entre
-9,22E+18
(exatos
-9.223.372.036.854.775.808) e 9,22E+18 (exatos 9.223.372.036.854.775.807).

Existe os tipos de dados prprios para caracteres que o char.
O tipo char ocupa 2 bytes, o que torna Java ideal para programar em lngas
latinas, asiticas ou qualquer outra que utilize caracteres diferentes do padro ASCII. O
21
padro ASCII utiliza apenas um byte que fornece 256 letras diferentes, mas o padro
utilizado em Java (ISO) nos d a possibilidade de at 65.536 caracteres diferentes. Para
nmeros decimais utilizamos dois tipos de dados, dependendo da necessidade de seu
alcance e preciso (nmeros aps a vrgula).
O tipo de dado mais comum para nmero decimal o float. Em um tipo de dado
float, podemos guardar nmeros grandes que vo desde 1,4E-45 at 3,4028235E+38.
Para nmero decimais com grande preciso ou valores extraordinrios (geralmente
utilizados em matemtica aplicada e complexa como clculos fsicos, qumicos,
astrolgicos, meteorolgicos, etc) utilizamos o tipo de dado double. Double o tipo de
dado mais complexo que h em Java e o maior valor possvel de se armazenar
1,797.693.134.862.315.7E+308. Muito mais do que qualquer programador precisa.
Para ilustra melhor essa explicao, abaixo est um pequeno algortmo com alguns
atributos e seus valores mnimos e mximos.
public class TiposDeDados {
System.out.println("Tipos de dados em Java: \n" +
"\nMenor Byte: " + Byte.MIN_VALUE +
"\nMaior Byte: " + Byte.MAX_VALUE +
"\nMenor Short Int: " + Short.MIN_VALUE +
"\nMaior Short Int: " + Short.MAX_VALUE +
"\nMenor Int: " + Integer.MIN_VALUE +
"\nMaior Int: " + Integer.MAX_VALUE +
"\nMenor Long: " + Long.MIN_VALUE +
"\nMaior Long:" + Long.MAX_VALUE +
"\nMenor Float: " + Float.MIN_VALUE +
"\nMaior Float: " + Float.MAX_VALUE +
"\nMenor Double: " + Double.MIN_VALUE +
"\nMaior Double: " + Double.MAX_VALUE);
}
}
22
3.10. Atribuio de Valores a Variveis ou Atributos

Como vimos, h vrios tipos de dados em Java, cada um com um consumo de
memria determinado que afeta diretamente o seu alcance. Veremos agora como atribuir
valores a esses endereos de memria (atributo ou varivel).
Para atribuirmos valor a uma varivel ou atributo usamos o operador =. Neste caso,
o sinal de igual no significa igualdade, mas que um valor ser atribudo. A regra bsica
que sempre o que estiver esquerda do "=" receber o valor que estiver direita.
Por exemplo: se expressarmos var1 = 10 queremos dizer que a varivel var1
receber o nmero 10. Pronto!
Agora, temos o nmero 10 gravado na memria.
Podemos tambm atribuir valores contidos em outras variveis. Por exemplo:
var1 = 20;
var2 = var1;
A varivel var1 recebe o nmero 20, depois a varivel var2 recebe o valor de var1 (que
20). Pronto! Agora,
temos duas variveis guardando o mesmo nmero (20).
3.11. Inicializao de variveis ou atributos

Muitas vezes, precisamos inicializar as variveis ou atributos para que possuam um
valor desde o incio do programa. Como h muitos tipos de dados em Java, seus
criadores desenvolveram formas de escrita para que diferenciam os vrios tipos de dados.
Primeiramente, comearemos com os mais simples: os inteiros.
23
Os nmero inteiros comuns e do tipo byte so os mais simples de se inicializar,

pois basta atribuirmos seu valor diretamente. Logicamente, precavendo-se dos limites de
alcance do tipo inteiro vistos na pgina de tipos de dados. Por exemplo:
int var1 = 10;
int var2 = 500;
int var3 = 65000;
byte var1 = -100;
byte var2 = 50;
Os nmeros inteiros longos tm duas formas de serem inicializados. Podemos
escrev-lo diretamente se, e somente se, seu valor for menor que o alcance de um inteiro
comum. Mas se o valor atribudo for maior que o valor permitido por um inteiro comum,
ento, no final deve ser acrescentado uma letra L (maiscula ou minscula, no h
diferena aqui).
Exemplo:
long var1 = -65000;
long var2 = 3590;
long var3 = 15000000000L;
long var4 = -6740000000L;
A inicializao do tipo double e float um pouco diferente. possvel apenas
digitar um nmero como sendo inteiro que o compilador entender facilmente, porm, se
quisermos utilizar as casas decimais, devemos utilizar um ponto para separar a parte
inteira da decimal. Outro fato ao utilizar casas decimais que o tipo float deve ser
diferenciado do tipo double. Conseguimos fazer isso facilmente digitando uma letra F ao
final do nmero (no importa se a letra maiscula ou minscula).
24
Exemplo:
double var1 = 12045741359;
float var1 = 745621;
double var2 = 10.658745965;
float var2 = 0.5f;
Char deve ser inicializado com uma letra entre aspas simples. O importante
entender que em uma varivel do tipo char s pode ser colocada uma letra, no uma
frase. Alm do mais, neste caso h diferena entre maisculas e minsculas.
Exemplo:
char var1 = 'a';
char var2 = 'A';
Se quisermos criar uma frase devemos guarda-la em uma string. Apesar de String
no ser um tipo de dado em Java, mas sim uma classe, este com certeza o elemento
mais utilizado. Uma cadeia de caracteres (string) pode ser inicializada de trs formas: 1)
Como uma string inexistente, ou seja, sem valor algum. Para isso utilizamos a
palavra reservada null; 2) Como uma frase vazia; 3) Como uma string completa. Com
exceo da inexistente, toda string deve estar dentro de aspas duplas ( " " ). Se por
acaso, precisarmos digitar uma aspas dentro de uma string, estas aspas devem vir
precedidas de uma barra invertida (\).
Exemplo:
String var1 = null;
String var2 = "";
String var3 = "Cadeia de caracteres";
25
String var4 = "entre aspas: \"String em Java\".";

O tipo booleano possui apenas dois valores: verdadeiro e falso. True para
verdadeiro e False para falso.
Exemplo:
boolean var1 = true;
boolean var2 = false;
Neste tipo de dado no h possibilidade de ter outro valor.
3.12. Mtodo de Sada Padro

Um mtodo de sada utilizado para mostrar alguma coisa ao usurio. No caso de
Java, existe um mtodo padro que utiliza uma sada padro (monitor de vdeo) para criar
a comunicao com o usurio estamos falando de println. O mtodo println faz parte da
classe System que controla a maioria das funcionalidades do computador, e se tratando
de uma sada, mais especificamente de out.
Basicamente, o mtodo println imprime na tela uma string (cadeia de caracteres frase) que passada ao mtodo como argumento entre parnteses. A sada padro
exibida sempre no console e no em uma janela. O importante saber que o mtodo
PRINTLN sempre pular uma linha quando seu argumento chega ao final.
Ento, procedemos da seguinte maneira: 1) A classe ao qual pertence (System); 2)
o membro que indica a sada (out); 3) o mtodo (println); 4) O argumento contendo a
string que deve ser apresentada na tela. O mtodo, resumidamente, ficaria assim:
System.out.println ("string")
26
public class ExemploDeSaidaPadrao {

System.out.println("Sada Padro em Java");
System.out.println("Linha 1");
}
}
Uma outra forma de sada padro o print. A nica diferena entre println e print
que ao final de seu argumento ele no ir pular nenhuma linha. Dessa forma podemos
criar uma linha contnua com vrios print em linhas diferentes.
public class ExemploDeSaidaComPrint {
System.out.print("Sada Padro ");
System.out.print("usando ");
System.out.print("o mtodo ");
System.out.print("print");
}
}
3.13. Controle de Texto

Outra possibilidade interessante nos mtodos de sada so os controles de texto.
Os controles de texto so dados por caracteres chaves que so indicados com uma barra
invertida antes dele. Veja a lista abaixo:
\n - pula uma linha
\t - cria uma tabulao (o mesmo que apertar a tecla TAB)
\b - retorna o cursor um carcter
27
\r - retorna o cursor ao incio da linha

public class ExemploDeControleDeTexto{
System.out.print("Empresa:\t"); // cria uma tabulao
System.out.print("primebean\n"); //pula uma linha
System.out.print("Solues em Tecnologia Multiplataforma\r");
// pe o cursor no incio da linha
}
}
3.14. Apresentando valores de variveis ou atributos

Podemos facilmente demonstrar o valor de uma varivel ou atributo bastando
apenas dar como argumento a varivel. O prprio mtodo println ou print se encarrega de
converter o valor em uma string, ou seja, ele transforma o valor nmero em um texto que
o representa. Veja o exemplo:
public class ApresentandoVariaveis{
int inteiro = 200;
float decimal = 0.5f;
char letra = 'J';
System.out.println (inteiro);
System.out.println (decimal);
System.out.println (letra);
}
}
Tambm possvel exibir o resultado de uma operao matemtica (processo)
executado dentro da prpria sada padro.
public class ApresentandoResultados{
int inteiro = 200;
float decimal = 0.5f;
28
System.out.println (inteiro + decimal);

}
}
Obs.: Tenha cuidado ao apresentar resultados de nmeros junto com texto, pois nesse
caso haver a concatenao de string, ou seja, a juno de duas ou mais cadeias de
caracteres.
3.15. Concatenao
Concatenao o ato de unir duas ou mais cadeias de caracteres (strings). Por
muito tempo, operaes envolvendo strings eram os pesadelos de qualquer programador,
pois havia a necessidade de tratar o elemento pelo seu dado bruto, ou seja, carcter por
carcter. Ento, juntar por exemplo, duas frases era um trabalho rduo.
Com o surgimento da orientao a objeto e o advento do Java, as operaes
envolvendo strings foram muito simplificadas. A melhoria mais significativa nesse assunto,
sem sombra de dvidas, foi utilizar a concatenao de strings.
A concatenao de strings dada pelo operador +, mas no o confunda com o
operador de adio que utiliza o mesmo smbolo. Dessa forma, com apenas este smbolo,
podemos unir duas cadeias de caracteres diferentes em apenas uma.
Veja este exemplo, que apesar de bobo, ilustra exatamente o que acontece na
concatenao:
Joo + zinho = Joozinho; Passa + tempo = Passatempo; beija + - + flor = beija-flor.
Acredite, simples desse jeito.
29
Colocando isso em um cdigo ficaria:

public class ConcatenacaoSimples {
String palavra1 = "tele";
String palavra2 = "fone";
System.out.println(palavra1 + palavra2);
}
}
O melhor da concatenao que no precisa ser uma palavra que faa sentido
porque o computador no verifica se faz sentido, ele simplesmente junta a cadeia de
caracteres. Portanto, poderamos muito bem fazer isso:
public class ConcatenacaoComposta {
String part1 = "De";
String part2 = "se";
String part3 = "nc";
String part4 = "or";
String part5 = "aj";
String part6 = "ad";
String part7 = "o";
System.out.println(part1+part2+part3+part4+part5+part6+part7);
}
}
A concatenao de strings ajuda muito no momento que usamos o mtodo de
sada padro println, porque ao invs de utilizarmos vrias vezes o mesmo mtodo,
podemos apenas concatenar a string anterior com a string posterior, ou seja, juntar a
string de cima com a string da linha de baixo. Veja o exemplo:
public class ConcatenacaoComPrintln {
System.out.println("Bem vindo ao mundo Java!\n\n" +
30
"Este um exemplo prtico de concatenao de string.\n" +

"Aqui, a string da linha de cima " +
"sempre concatenada com a string da linha de baixo" );
}
}
3.15.1. Cuidados ao concatenar

Apesar da concatenao ser algo bem simples de ser feito, devemos ter alguns
cuidados. Pois como podemos perceber, ele tambm o smbolo utilizado para fazer
operaes de adio. O que queremos dizer que, se por exemplo, quisermos marcar um
nmero de telefone em uma nica string e tivermos na verdade dois nmeros inteiros
distintos, o resultado ser desastroso. Veja:
Telefone: 998 + 1234, resultaria em Telefone: 2232. Acabamos de perder o nmero de
telefone. Ento, o mais sensato se lembrar que concatenao s ocorre entre uma
string e outro dado (no necessariamente precisa ser uma string tambm).
Ento, para conseguirmos juntar os dois nmeros acima, pelo menos um deles
deve ser uma string. Telefone: "998" + 1234, ou Telefone: 998 + "1234".
Esse pensamento se torna mais complicado a medida que temos que concatenar
uma uma operao no meio da string.
Exemplo:
"CCXXVI em algarismos romanos so " + 200 + 20 + 6. Aqui, ao invs de representar a
soma de 200 + 20 + 6, que seria 226, representada a total concatenao de todos os
elementos. O que resultaria em "CCXXVI em algarismos romanos so 200206".
Mas este problema fcil de resolver, basta indicarmos com os parnteses que a
operao matemtica deve ser executada primeiro. Representando ficaria:
"CCXXVI em algarismos romanos so " + (200 + 20 + 6). O que consequentemente,
31
representaria "CCXXVI em algarismos romanos so 226".

3.16. Operadores e Processos
Os processos so contas matemtica (clculos) que podem ser feitos com
nmeros, variveis ou ambos. Abaixo est uma tabela com os operadores mais comuns.
+
adio ou concatenao
Subtrao
Multiplicao
Diviso
Mdulo (diviso no qual obtido o resto)
++
Incremento de 1
--
Decremento de 1
Java segue a conveno de expresses matemticas. Por exemplo:
Se voc fizer 10-2/4, o resultado ser -9,5 e no 2, pois a diviso deve ser
calculada primeiro. Para esta conta dar 2 devemos indicar que a subtrao deve ser feita
antes da diviso. Ela ficaria assim, (10-2)/4.
O que est entre parnteses deve ser calculado primeiro. Em Java, podemos
facilmente simplificar operaes que envolvam a prpria varivel. Por exemplo, vamos
imaginar que o novo valor de var1 seja o valor da prpria varivel var1 mais o valor da
varivel var2.
Podemos construir, ento, a seguinte sentena -> var1 = var1 + var2, ou podemos
simplific-la em -> var1 += var2.
Veja abaixo a tabela de todas as operaes possveis:
Smbolo
Operao
32
+=
somar (quando os dados forem algum nmero)
+=
concatenar (quando um dos dados for String)
-=
subtrao
*=
multiplicao
/=
diviso
%=
mdulo (a varivel esquerda recebe o resto da diviso dele com a

varivel direita)
4. Controle de Fluxo
Controle de fluxo a habilidade de ajustar a maneira como um programa realiza
suas tarefas. Por meio de instrues especiais, chamadas comandos, essas tarefas
podem ser executadas seletivamente, repetidamente ou excepcionalmente. No fosse o
controle de fluxo, um programa poderia executar apenas uma nica seqncia de tarefas,
perdendo completamente uma das caractersticas mais interessantes da programao: a
dinmica. Podemos classificar os comandos aceitos pela linguagem Java em
basicamente quatro categorias:
Comando
Palavras-chave
Tomada de decises
If-else, switch-case
Laos ou repeties
For, while, do-while
Apontamento e tratamento de excesses
Try-catch-finally, throw
Outros
break,continue,label:,return
33
4.1. Execuo condicional - IF e ELSE

Uma ao muito importante que o processador de qualquer computador executa, e
que o torna diferente de qualquer outra mquina, a tomada de deciso definindo o que
verdadeiro e o que falso.
Se quisermos fazer um bom programa, esse programa deve ser capaz de definir
caminhos diferentes de acordo com decises que o prprio programa toma. Para isso,
precisamos de uma estrutura seletiva da qual o nico valor possvel o bit 1 ou 0,
resumindo: retornar o valor VERDADEIRO ou FALSO.
Em Java, como em muitas linguagens de programao, quem faz isso o IF (SE
traduzindo). O ELSE o que chamamos de caso contrrio, ou seja, se for falso execute o
que est no ELSE.
Exemplificando: Se (IF) for tal coisa, faa isso! Caso contrrio (ELSE), faa aquilo!
4.2.1. Usando IF
Para usar o IF basta digitar entre parnteses o que deve ser comparado.
IMPORTANTE: IF uma palavra reservada que no aceita ponto-e-vrgula (;) no final. Se
for verdadeiro, o programa executar a primeira linha logo abaixo do if. Mas, e se
quisermos executar vrias linhas se if for verdadeiro?
Se o if tiver que executar vrias linhas, todas as linhas que devem ser enquadradas
dentro do bloco de dados - as chaves ({}).
34
4.2.2. Usando ELSE

O ELSE s existe se tiver um IF. O else s ser executado se o IF for falso. Else
executar s a primeira linha abaixo dele. Se o else tiver que executar vrias linhas, vale
a mesma regra de if. Todas as linhas a ser executadas devero estar contidas dentro do
bloco de dados ({}).
Para que IF chegue a uma deciso de falso e verdadeiro so necessrios
operadores lgicos. Dos quais destacam-se 6:
> - maior que
< - menor que
>= - maior ou igual a
<= - menor ou igula a
== - igual a
!= - diferente de
Importante
O operador lgico ! (negao) serve para inverter o valor, ou seja, se algo for falso,
ir se tornar verdadeiro e vice-e-versa.
Uma construo sem comparao entre duas variveis sempre entendida como
sendo verdadeira. Ex.: if (var1) -> entenda como: se var1 for verdadeiro.
Uma construo sem comparao entre duas variveis ser entendida como false
se usarmos o operador de negao antes da varivel. Ex.: if (!var1) -> entenda como: se
var1 for falso.
public class UsandoIf {
public static void main(String args[]) {
35
boolean var1 = true;

// Se var1 for verdadeiro
if (var1) {
System.out.println("var1: Verdadeiro");
} else {
System.out.println("var1: Falso");
}
// Se var1 for falso
if (!var1) {
System.out.println("!var1: Verdadeiro");
} else {
System.out.println("!var1: Falso");
}
}
}
4.3. Switch, Case e Default

Uma estrutura muito utilizada em programao o switch. A estrutura switch
verifica uma varivel e age de acordo com seus cases. Os cases so as possibilidades de
resultados que so obtidos por switch. Basicamente, o switch serve para controlar vrias
aes diferentes de acordo com o case definido dentro dele.
A estrutura do Switch :
SWITCH (varivel) {
CASE valor :
Cdigo a ser executado caso o valor de case seja o mesmo da varivel de switch
}
Ento, detalhadamente, switch recebe uma varivel e abre um bloco de dados
( { } ), dentro desse bloco de dados h os cases. Cada case recebe um valor nico, ou
36
seja, que no pode ser repetido no mesmo bloco de dados. Ento, marcamos cada case
com dois pontos ( : ). Aps os dois pontos colocamos todo cdigo que dever ser
executado que pode conter quantas linhas ns quisermos.
Dica importante: um bom costume sempre terminar um cdigo aps o case com um
comando break. Assim, ns evitamos que o resto do cdigo seja executado por acidente.
E vale tambm ressaltar que case no gera resultados booleanos, portanto, no h a
possibilidade de fazer comparaes (Ex. Isso est totalmente errado-> case var1 > var2:).
4.3.1. Default
Como switch pode receber vrias possibilidades, pode ocorrer de algum caso estar
fora do alcance ou no definido. Nesse momento, default faz seu papel. Default pega
qualquer resultado que no esteja definido no case. Ou seja, ele o bloco de cdigo
padro que deve ser executado quando nenhum case for satisfeito.
Podemos coloc-lo onde quisermos dentro de switch , mas, geralmente, o
colocamos no final. Para exemplificar, vamos ver o cdigo abaixo.
public class ExemploSwitch {
int diaDaSemana = 1;
switch (diaDaSemana) {
case 1:
System.out.println("Domingo");
break;
case 2:
System.out.println("Segunda-feira");
break;
case 3:
System.out.println("Tera-feira");
break;
case 4:
System.out.println("Quarta-feira");
37
break;
case 5:
System.out.println("Quinta-feira");
break;
case 6:
System.out.println("Sexta-feira");
break;
case 7:
System.out.println("Sbado");
break;
default:
System.out.println("Este no um dia vlido!");
}
}
}
Como podemos perceber, existe uma varivel inteira chamada diaDaSemana. Essa
varivel passada ao switch e dentro desse switch h 7 cases que correspondem aos
dias da semana. Como o valor inicial 1, ento, o bloco logo abaixo de case 1
executado, ou seja, ele imprimir Domingo no monitor. Para evitar que o cdigo dos
outros cases sejam executados, logo aps o mtodo println h um comando BREAK;
Se quiser, copie este cdigo e modifique o valor inicial de diaDaSemana para
verificar os possveis resultados e como este algoritmo funciona.
4.4. Break e Continue
Break e Continue so dois comandos de controle de estruturas largamente
utilizados em loops (repeties) como for e while.
38
4.4.1. Break
O comando break serve para determinar uma quebra de estrutura, ou seja, ele faz
com que, por exemplo, um loop (repetio) pare. No comando switch, por exemplo, ele
determina que no pode ser executado o case seguinte, e assim por diante.
No exemplo abaixo, temos uma repetio que se inicia em 1 e deve terminar em
mil (1.000), mas dentro desta estrutura h uma condio: se a varivel for igual a 10 saia
da estrutura de repetio. Vejamos:
public class ExemploBreak {
public static void main (String args []){
for (int contador=1; contador<=1000; contador++){
System.out.println("Esta a repetio nr: "+contador);
if (contador==10)
break;
}
}
}
Como podemos observar, mesmo a estrutura de repetio for determinando que a
repetio deve ir at 1000, ao executarmos esse cdigo, apenas conseguimos chegar at
a repetio nmero 10. Isso ocorre porque quando if for verdadeiro ele executa o break.
Dessa forma, conseguimos sair do loop sem ele ter terminado.
4.4.2. Continue
Continue tambm muito utilizado em estruturas e repetio e sua funo
ignorar o cdigo, e no sair como acontece com o break.
39
Exemplificando, faremos um cdigo contendo uma estrutura de repetio que ir contar

de 1 a 100, mas sempre que o nmero no for mltiplo de 5 o cdigo para apresentar o
nmero na tela ser ignorado e a repetio continuar com o nmero seguinte.
public class ExemploContinue {
for (int contador=1; contador<=100; contador++){
if (contador%5!=0)
continue;
/* Se o contador no for mltiplo de 5
* Todo o cdigo abaixo ser ignorado
* e o loop continua com o prximo nr */
System.out.println("Contador: "+contador);
}
}
}
Ou seja, desta forma, apenas os mltiplos de 5 entre 1 e 100 aparecem na tela.
4.3. Estruturas de Repetio
Trata-se de comandos que permitiro a execuo repetida de vrios outros

comandos descritos no algoritmo. Usaremos uma estrutura de repetio para executar
repetidas vezes comandos, em funo de uma condio que determinar o numero de
repetio a serem executadas .
As repeties podero ser controladas de varias formas diferentes . Em geral
aparecer a figura de uma varivel que ser utilizada como elemento de controle das
repeties. A est varivel daremos o nome de contador.
40
4.3.1. While
While uma estrutura de repetio. O mesmo executa uma comparao com a
varivel. Se a comparao for verdadeira, ele executa o bloco de instrues ( { } ) ou
apenas a prxima linha de cdigo logo abaixo.
Procedemos da seguinte maneira:
While(comparao)
O problema com estruturas de repetio, principalmente com while, o que
chamamos de looping infinito.
Damos esse nome ao fato de que o programa fica repetindo a mesma sequncia
de cdigos esperando por um resultado que nunca ir acontecer. Portanto,
imprescindvel que uma determinada varivel seja modificada de acordo com cda loop.
Veja o exemplo
public class ExemploWhile {
int contador = 0;
while (contador < 50) {
System.out.println("Repetio nr: " + contador);
contador++;
}
}
}
Como podemos ver, existe a varivel contador que iniciada valendo 0, a cada
41
loop executado (repetio) somado 1 ao contador. Perceba que o while ir manter a

repetio enquanto a varivel contador for menor que 50.
Outro ponto importante que a varivel contador inicializada antes de chegar ao
while, porque o while ir comparar a sentena e s depois permitir a execuo do bloco.
Se quisermos fazer todo o bloco primeiro e s depois fazer a comparao, devemos
utilizar o comando do While
4.3.2. Do While
Do While uma estrutura de repetio, tal como o prprio while. A principal
diferena entre os dois que Do While ir fazer a comparao apenas no final do bloco
de cdigo, sendo representado da seguinte forma:
DO { cdigo } WHILE (comparao);
Neste caso, devemos ter as mesmas precaues quanto while, no que diz respeito
a looping infinito. Mas no necessrio inicializar a varivel antes do bloco de cdigo
como acontece com while, pois a comparao s ser feita aps todo o cdigo ter sido
executado.
4.3.3. For
For uma estrutura de repetio que exerce a mesma funo que WHILE e DO
WHILE. A principal diferena entre eles a sintaxe e tambm a forma de trabalhar.
O For necessita de trs parmetros: a inicializao da varivel, a condio que ir
manter o looping (repetio) e o modificador da varivel inicializada que pode ser
incrementada ou decrementada, ou seja, pode aumentar seu valor ou diminuir. Um ponto
42
importante que todos os parmetros devem ser separados por ponto-e-vrgula ( ; ).

Dessa forma, temos resumidamente a seguinte construo: FOR (inicializao ;
condio ; incremento ou decremento).
Por exemplo, vamos criar um cdigo que nos d o resultado do fatorial de 5. Como
sabemos para calcular o fatorial de algum nmero basta multiplicarmos ele pelo nmero
anterior regressivamente at 1, ou seja, seria algo como 5 4 3 2 1. Dessa forma,
sabemos exatamente em quanto devemos comear nossa conta (5), sabemos por quanto
tempo o looping ir continuar executando (enquanto a varivel for maior que 1) e
sabemos quanto devemos modificar essa varivel (para cada repetio ir subtrair decrementar - 1).
Em um cdigo ficaria:
public class Fatorial {
public static void main (String args[]){
int fator, resultado=1;
for (fator=5; fator>1; fator--)
resultado*=fator;
System.out.println(resultado);
}
}
Observemos apenas um detalhe, como toda varivel automaticamente
inicializada como nulo (NULL), ento, necessitamos inicializar a varivel resultado em 1,
porque seria impossvel multiplicar a varivel resultado pela varivel fator (ex. NULL 5
= ?).
43
5. O que so e para que servem as Classes e Objetos

O conceito de orientao a objetos, , sem dvida, o mais importante em Java.
Por ser um conceito um pouco abstrato, normal que demore um pouco at entender
tudo.
E at entender bem, vai demorar mais ainda. Porm, vamos ensinar, ao longo de
vrios exemplos, divididos em vrias sees, estes to importantes detalhes.
At este momento s vimos o bsico e laos da programao Java, vamos apenas
ensinar como declarar as classes, instanciar os objetos (com e sem construtores) e como
usar
testes
condicionais
dentro
das
classes
que
criamos.
Isso dar uma idia do que so classes e objetos, e importante que se habitue a estas
idias.
5.1. O que so Classes e Objetos em Java
Classes podem ser vistas como abstraes ou definies maiores das coisas , j
um objeto j algo mais real, mais concreto, um elemento ou tipo daquela classe.
Usando essas definies, realmente difcil entender os conceitos, por isso vamos usar
exemplos.
Por exemplo, podemos ver "Pessoa" como uma classe. uma classe que
representa seres humanos, que possuem cabea, corao, crebro etc. uma
generalizao maior.
Podemos declarar voc, caro leitor, como um objeto dessa classe, com seu nome e
caractersticas especficas de uma "Pessoa". Voc pertence a classe "Pessoa". Eu
tambm,
pois
possumos
cabea,
corao,
crebro
etc.
Ns temos essas caractersticas gerais, que todos da classe "Pessoa" possuem. Ou seja,
44
em Java, dizemos que somos instncias da classe "Pessoa".
5.2. Utilidade das Classes e Objetos em Java
Esse tipo de representao vai nos ajudar muito em programao Java. Por
exemplo, imagine que voc foi contratado para criar um aplicativo Java para uma
empresa.
Voc
precisar
cadastrar
os
milhares
de
funcionrios
da
empresa.
claro que voc no vai declarar milhares de strings para armazenar o nome de cada
um, nem de inteiros para armazenar seus nmeros nem de floats para armazenar seus
salrios. Seria humanamente impossvel fazer isso.
5.2.1. Agrupar coisas semelhantes

A que entra a vantagem da programao orientada a objetos. Podemos ver todos
esses funcionrios de uma mesma maneira: como a classe Funcionario. O que a classe
"Funcionario" tem em comum?
Tem um nome, uma idade, uma data de contratao, um salrio, um setor em que
trabalham
outras
coisas
especficas
da
empresa.
Pronto.
Voc pode ver essa classe como um tipo de dado.

Assim como 'int' ou 'float', agora existe o tipo 'Funcionario'. Toda vez que entrar
algum novo na empresa, voc declara esse elemento como fazendo parte do tipo
'Funcionario'. Ou seja, estar criando um objeto dessa classe.
O objeto, diferente da classe, algo mais especfico, ele que ter as informaes
pessoais de cada funcionrio.
45
5.2.2. Crie uma vez, use quantas vezes quiser

A grande vantagem desse tipo de 'viso', que, ao declarar a classe, voc declara
dentro dela os tipos: string, float, int etc, que esto dentro da classe. Ento, quando for
criar
um
objeto,
automaticamente
esses
dados
estaro
criados!
A que reside a beleza do Java e da orientao a objetos. muito, mas muito til e
prtico. um novo jeito de pensar e ver o mundo.
5.2.3. Altere uma parte do cdigo, e a mudana se propagar em todo o cdigo

Ok, voc criou seu aplicativo usando a classe "Funcionario". Porm, a pessoa que
te contratou - que muitas vezes no so da rea de TI - esqueceu de te informar que os
funcionrios devem ter uma informao no cadastro: se possuem carro ou no.
E a? Alterar tudo? Comear do zero?
Claro que no. Simplesmente v na classe e coloque esse atributo (informao), e
automaticamente todos os objetos passaro a ter esse dado, "carro". Ento s pedir
para os funcionrios preencherem esse dado no seu aplicativo de cadastro.
5.2.4. Classe parte, vida parte

Uma coisa interessante que a programao orientada a objetos nos proporciona
a diviso das partes do programa. Dois programadores podem programar duas classes de
forma totalmente independente e fazer com que elas funcionem perfeitamente. Coisa que
em outros paradigmas de programao quase impossvel.
Por exemplo, voc criou a classe "Funcionario".
46
Nessa classe voc precisa a informao do salrio de cada funcionrio, porm

voc no tem acesso aos detalhes financeiros da empresa. Ora, nem precisa e nem deve
ter, algo mais restrito.
Outro programador, responsvel pelo setor financeiro, pode ter criado a classe
"Salario" que recebe os dados de cada pessoa, sua posio na empresa, bnus, horas
extras etc etc, e te d somente o resultado final: o nmero. Esse dado o que voc vai
usar na sua classe "Funcionario".
Isso tudo pode ser feito de uma maneira totalmente eficiente, segura e
independente, tanto por voc como pelo programador que fez a outra classe. A nica
troca de informao que voc pega um float dele e ele pega o nome do seu funcionrio
ou cdigo dele da empresa. O mais importante disso : em nenhum momento foi
necessrio um ver o cdigo do outro!
Na hora de trabalhar, isso nos diz muito em termos de rendimento!
5.2.5.Como saber quando usar Classes e Objetos em Java

Como voc pode notar, atravs dos exemplos dos Carros, das Pessoas e dos
Funcionrios, as Classes so nada mais que um grupo de informaes. Sempre que
quiser usar essas informaes, declare um Objeto daquela classe.
Ou seja, sempre que quiser generalizar ou criar um grupo com caractersticas
parecidas, no tenha dvida, use Classe e Objetos.
Em um jogo, Worms Armageddon ou Counter-Strike, por exemplo. Existem vrios
jogadores. Ora, eles so parecidos, tem semelhanas e caractersticas em comum. No
perca tempo declarando seus atributos individualmente, use classes e objetos.
Na verdade, em Java, tudo so classes e objetos, ento no h muito essa
preocupao.
47
Em C, no existe Orientao a Objetos.

Em C++, voc escolhe se usa ou no.
Adiante, veremos que uma classe pode se parecer com uma e outra, pegar
'emprestado' detalhe de outras, implementar ou estender outras. Existem vrios recursos
para serem usados nas Classes, inclusive de segurana, que permitem que alguns
objetos tenham acesso a alguns dados, outros no.
Recursos grficos: por exemplo, as janelas dos aplicativos Java, botes, menu e
tudo mais so classes. Como dissemos, Java gira em torno de orientao a objetos, e
Java uma linguagem de programao riqussima e ilimitada. Logo, o que possvel
fazer com as classes e objetos tambm bem vasto.
5.3. Criao de Classe

Comearemos agora a ver a alma da programao Java que a orientao a
objeto. Sempre que programamos em Java, devemos pensar em como montar as
definies de nosso objeto. Ou seja, quais atributos uma classe deve conter,
simplificando, quais caractersticas tem tal objeto.
como pensar em alguma coisa. Por exemplo, se pensarmos em relgio, a
primeira coisa que ns vem a cabea hora, minuto, segundo e assim por diante. Ns
tambm podemos ajustar as horas, ajustar o alarme, etc.
A princpio, vamos nos ater aos detalhes tcnicos da programao de uma classe.
Para criar uma classe usamos a palavra chave class, e aps a definio do nome de
nossa classe, ns definimos seus atributos. Para exemplificar, criaremos uma classe que
ter as caractersticas mais simples de uma televiso.
48
pubic class TV{

int tamanho;
int canal;
boolean ligada;
}
Pronto, esses so os atributos de uma classe, ou seja, ns definimos que existe um
objeto chamado TV e que ele tem trs caractersticas: uma dessas caractersticas o
tamanho, outra um valor inteiro identificado por canal e mais outra caracterstica que
determina se ele est ligado ou no.
Como podemos perceber, isso mais um conceito (paradigma) de como devemos
pensar. Uma classe (ou objeto) pode ser muito implementado, tornando-se um objeto com
vrias caractersticas que pode ser facilmente manipulado e incorporado por outros
objetos. Isso o que chamamos de reutilizao de cdigo, que envolve vrios aspectos
importantes da orientao a objeto como herana, interface, enumeradores, sobrecarga
de mtodos entre outros que ns estudaremos nas prximas pginas.
5.4. Mtodos Construtores

Vimos anteriormente que simples criar uma classe. Mas, para realmente
conseguirmos utilizar a classe, ela deve conter pelo menos um mtodo construtor.
O mtodo construtor desenvolvido da mesma forma que uma funo, a nica
diferena que ele tem o mesmo nome da classe. Isso se deve ao fato de que um objeto
deve ser construdo cada vez que chamamos a classe.
E a responsabilidade de fazer isso do construtor. Isso parte do princpio que
podemos ter dois objetos com a mesma caracterstica, mas que no so os mesmos
objetos. Ou seja, ns podemos ter uma TV de 29" ligada no canal 15 e nosso amigo tem
49
uma outra TV que tambm de 29" e est ligada no canal 15. Perceba que ambas as TVs
tm as mesmas caractersticas, mas continuam sendo duas TVs diferentes.
Sempre que criamos uma classe, Java automaticamente vincula um mtodo
construtor padro interno com o mesmo nome da classe, mas sem inicializar nenhum
atributo. Para demonstrar um mtodo construtor, criaremos um construtor padro sem
argumentos no qual j contm os valores dos atributos definidos por ns mesmos.
Ento, vamos imaginar que sempre que uma TV construda, o seu padro
tamanho 21", desligada e no canal 0. Ento, podemos defini-lo como:
public class TV {
int tamanho;
int canal;
boolean ligada;
TV(){
tamanho=21;
canal=0;
ligada=false;
}
}
6. Estrutura de Dados
Hoje em dia, a grande maioria das pessoas utilizam a agenda do celular para
armazenar seus contatos. As tarefas de uma agenda de contatos so basicamente duas:
1.Definir como as informaes dos contatos sero armazenadas. Uma informao
armazenada em algum lugar (pedao de papel, livro, computador, etc) um dado.
2.Disponibilizar operaes para criar, recuperar, ordenar, atualizar e remover
contatos. Alm de operaes para informar o estado da agenda (a quantidade de
contatos existentes na agenda ou a quantidade de espao disponvel para novos
50
contatos).
A primeira tarefa crucial para o desempenho. Se a agenda armazena as
informaes de uma forma desorganizada ento ser muito mais complicado manipular
os dados de forma eficiente. A escolha de como guardar as informaes deve levar em
considerao as operaes que sero disponibilizadas pela agenda. Por exemplo, seria
interessante manter os contatos em ordem alfabtica para facilitar a busca.
Mas, apesar da importncia de como os contatos so armazenados, a organizao
interna da agenda no precisa e no deve ser exposta ao usurio. Afinal de contas, o que
o usurio deseja usar a agenda atravs das operaes e que tudo seja feito o mais
rpido possvel.
A nica coisa que precisa ser mostrada para o usurio so as operaes que ele
pode fazer na agenda (inserir, recuperar, atualizar, remover contato, saber quantos
contatos esto na agenda, etc). Este conjunto de operaes interface que o usurio
tem com a agenda.
Cada celular pode implementar a sua agenda de contatos de uma forma totalmente
diferente um do outro, na tentativa de obter mais performance, ser mais confivel ou
gastar menos memria. Porm o conjunto bsico de operaes oferecidas pelas agendas
sempre o mesmo. Isso facilita a vida do usurio pois se ele tiver que trocar de celular
no vai ter que aprender novamente como usar uma agenda de contatos.
Essa a grande vantagem em se pensar em interface. Mantida a interface,
podemos trocar uma agenda que no to eficiente ou que j no atende mais as nossas
necessidades por outra mais eficiente ou adequada, sem problemas em ter de aprender a
usar a nova agenda: troca-se a implementao, mas no mudamos a interface.
51
Uma agenda de celular pode ser vista como uma estrutura de dados. Uma
estrutura de dados mantm os dados organizados seguindo alguma lgica e disponibiliza
operaes para o usurio manipular os dados.
importante, quando programar, no misturar dado e estrutura de dados em uma
coisa s. Um dado uma informao armazenada e estrutura de dados quem
administra os dados. O ideal que a estrutura de dados seja o mais independente
possvel dos dados que ela vai armazenar. Desta forma pode-se aproveitar a mesma
estrutura de dados para diversos tipos de dados. Por exemplo, melhor ter uma agenda
genrica do que uma agenda de telefones. Uma agenda genrica pode ser utilizada para
guardar telefones, ou emails, ou at mesmo guardar uma outra estrutura dentro dela:
contatos, que seriam compostos por nome, telefone e email.
Algumas estruturas de dados so apenas agrupamentos de dados sem um objetivo
de aplicar algum algoritmo ou tirar proveito de sua estrutura. Um exemplo seria a estrutura
Contato. Algumas outras estruturas so mais espertas e trabalhosas, como a Agenda,
assim como Listas Ligadas, Vetores, Tabelas de Espalhamento e outras que veremos no
decorrer da apostila.
Estas estruturas, por sua caracterstica mais complexa e de poder ser reutilizada
em outros contextos, devem ser criadas da forma mais independente possvel dos dados
que estaro dentro dela. Em outras palavras, no devemos misturar a Agenda e o
Contato de maneira rgida, para que com isso possamos criar outras Agendas, como por
exemplo uma Agenda de Fornecedor.
52
6.1. Vetores e Matrizes

Vetores e Matrizes so estruturas de dados muito simples que podem nos ajudar
muito quando temos muitas variveis do mesmo tipo em um algoritmo. Imagine o seguinte
problema: Voc precisa criar um algoritmo que l o nome e as 4 notas de 50 alunos,
calcular a mdia de cada aluno e informar quais foram aprovados e quais foram
reprovados.
Conseguiu imaginar quantas variveis voc vai precisar? Muitas n? Vamos fazer
uma conta rpida: 50 variveis para armazenar os nomes dos alunos, (4 * 50 = ) 200
variveis para armazenar as 4 notas de cada aluno e por fim, 50 variveis para armazenar
as mdias de cada aluno.
300 variveis no total, sem contar a quantidade de linhas de cdigo que voc vai
precisar para ler todos os dados do usurio, calcular as mdias e apresentar os
resultados. Mas eu tenho uma boa notcia pra voc. Ns no precisamos criar 300
variveis! Podemos utilizar Vetores e Matrizes (tambm conhecidos como ARRAYs).
Vetor (array uni-dimensional) uma varivel que armazena vrias variveis do mesmo
tipo. No problema apresentado anteriormente, ns podemos utilizar um vetor de 50
posies para armazenar os nomes dos 50 alunos.
Matriz (array multi-dimensional) um vetor de vetores. No nosso problema, imagine
uma matriz para armazenar as 4 notas de cada um dos 50 alunos. Ou seja, um vetor de
50 posies, e em cada posio do vetor, h outro vetor com 4 posies. Isso uma
matriz. Cada item do vetor (ou matriz) acessado por um nmero chamado de ndice.
53
6.2. Vetor
Vetores, tambm muito conhecidos como arrays, so variveis que servem para
guardar vrios valores do mesmo tipo de forma uniforme na memria. Por exemplo, se
tivemos que criar 20 variveis do mesmo tipo que querem dizer a mesma coisa, ns no
criaramos -> int var1, var2, var3, var4, var5, ... ao invs disso, criaramos apenas uma
varivel de vetor para guardar todos os 20 nmeros de uma vez.
Como um vetor pode guardar vrios valores temos que definir quantos valores ele
deve guardar para que seja reservado o espao necessrio em memria. Primeiramente,
vamos aprender como declarar um vetor. Para declarar um vetor devemos especificar o
tipo ou classe de dado que ser armazenado nele. Aps isso, damos um nome a esse
vetor. E, para finalizar, indicamos que ele um vetor, simplesmente abrindo e fechando
colchetes ( [ ] ).
Portanto, se quisssemos um vetor de nmeros inteiros chamado meu vetor,
declararamos da seguinte forma:
int meuVetor [ ];
Agora que j declaramos o vetor, devemos dar um tamanho a ele, para que seja
reservado espao suficiente em memria. Para fazermos isso, utilizaremos um
instanciador chamado new.
New muito importante, pois ele ir criar de fato o vetor. Para indicarmos o
tamanho usamos o instanciador new, depois o tipo de dado do vetor e entre colchetes o
tamanho do vetor.
Tomando o exemplo acima, vamos indicar que meuVetor ter o tamanho 4. Ento,
a linha de cima ficaria:
int meuVetor[ ] = new int [4];
54
Na memria representado da seguinte forma:
Uma nica varivel com 4 espaos nos quais podem ser guardados nmeros
inteiros. Acessando uma posio no Vetor Agora, para acessarmos um local especfico
dessa memria devemos indicar entre colchetes a posio desejada no vetor que
chamamos de index.
O importante mesmo saber que no importa o tamanho do vetor, o index (nmero
que indica a posio) sempre comea em 0. Ou seja, um vetor de tamanho 20 vai da
posio 0 a 19, um vetor de tamanho 180 vai da posio 0 a 179. Portanto, um vetor de
tamanho 4 vai da posio 0 a 3.
Agora, se quisermos atribuir os valores 540 na posio 1 e 8456 na posio 3,

faramos: meuVetor [1]=540; meuVetor [3]=8456.
55
No podemos nunca nos esquecer que o limite do vetor sempre seu tamanho
menos 1. Usando o exemplo: vetor de tamanho 4, posio mxima 3 (pois 4-1=3).
Ento, se atribuirmos um valor a posio 4 ocorrer um erro. Resumidamente, jamais
poderamos fazer meuVetor [4]=200.
6.2.1 Inicializao direta de Vetor

Podemos inicializar um vetor diretamente, sem a necessidade de instanci-lo com
new. Para isso, aps a declarao do vetor, basta colocar seus valores em chaves,
separando cada valor por vrgula. Por exemplo, se quisssemos inicializar o meuVetor
com os valores 450, 200, 1000, 700, faramos:
int meuVetor [ ] = { 450, 200, 1000, 700 };
6.3. Matrizes
Matrizes so vetores multidimensionais, ou seja, eles no so totalmente lineares,
e sim, geomtricos. Enquanto um vetor tem apenas uma linha com vrios valores, uma
matriz pode, por exemplo, tem vrias linhas com vrios valores, que comumente
chamamos de linhas e colunas.
Para criarmos um vetor multidimensional (ou matriz), procedemos da mesma forma
56
que um vetor normal, porm com mais um dimensionador (os colchetes). Ento, se
quisermos criar um vetor (matriz) bidimensional com 3 linha e 5 colunas, faramos:
int minhaMatriz [ ][ ] = new int [3][5];
Na memria representado como:
Isso tambm pode ser feito para adquirirmos o formato de matriz que quisermos.
Ou seja, se fosse uma matriz tridimensional, bastaria ter trs dimensionadores, se fosse
4D, ento, 4 dimensionadores, se fosse 5D (apesar de geometricamente difcil de
imaginar) seriam 5 dimensionadores. E assim por diante.
6.4. ArrayList
At o momento, nessa seo de Estrutura de Dados de nosso curso de Java,
vimos o quo til so os arrays e as operaes que podemos fazer com esses arrays,
tambm conhecidos por vetores.
Porm, h um grande problema neles: so estticos. Ou seja, tem tamanho
definido, no podemos adicionar nem excluir nada neles, o que bastante incmodo e faz
com que arrays em Java sejam limitados.
E por que arrays no so muito teis?
57
Porque na vida real as coisas no so assim estticas, elas mudam. O nmero de

funcionrios de um empresa tendem a crescer, em uma faculdade alunos se formam e
outros se matriculam, em um jogo de RPG vamos colecionando itens no decorrer do jogo,
ao passo que vamos usando outros.
Agora vamos aprender como usar os ArrayList, que so arrays mais 'flexveis', ou
dinmicos, j que podemos adicionar ou retirar elementos, alm de fazer outras coisas
que no so possveis com os Arrays.
6.4.1. O que so ArrayList em Java
O Java, por padro, possui uma srie de recursos prontos (APIs) para que
possamos tratar de estrutura de dados, tambm chamados de colees (collections).
Podemos dizer que ArrayList uma classe para colees. Uma classe genrica (generic
classes), para ser mais exato. Colees mesmo, de qualquer tipo de 'coisa' ou dado, no
somente de tipos primitivos.
Voc pode criar seus objetos - atravs de uma classe - e agrup-los atravs de
ArrayList e realizar, nessa coleo, vrias operaes, como: adicionar e retirar elementos,
orden-los, procurar por um elemento especfico, apagar um elemento especfico, limpar
o ArrayList dentre outras possibilidades.
58
6.4.2. Como declarar e usar ArrayList em Java
Importe:
import
java.util.ArrayList;
Por ser um tipo diferente, sua sintaxe um pouco diferente do que voc j viu at
ento:
ArrayList< Qualquer_Tipo > nomeDoArrayList = new ArrayList< Qualquer_Tipo >();
No exemplo a seguir, vamos usar um ArrayList de String para trabalhar com o
nome de vrias Bandas de msica:
ArrayList<String> bandas = new ArrayList<String> ();
6.4.3. Exemplo de uso do ArrayList
Aps declarar a ArrayList 'bandas' que armazenar Strings, vamos adicionar alguns
nomes. Primeiro adicionamos a banda "Rush":
bandas.add("Rush");
Existe um mtodo do ArrayList chamado 'toArray()' que coloca todos os elementos
de um ArrayList em um Array.
Ou seja: bandas.toArray() um Array!
Porm, j vimos que existe um mtodo 'toString' da classe Arrays que retorna uma
String com os elementos de um Array. Vamos usar esse mtodo parar exibir todos os
elementos do ArrayList, que transformamos em Array atravs do mtodo 'toArray()':
59
Arrays.toString( bandas.toArray() );
Vamos adicionar a segunda banda, "Beatles" e imprimir, usando o mesmo mtodo.
Note que quando usamos 'add', sempre adicionamos o elemento pro fim da ArrayList.
Confirme isso agora, vendo que a banda "Iron Maiden" ficar depois de "Beatles".
Vamos pegar o primeiro elemento, o elemento '0', atravs do mtodo 'get':
bandas.get(0);
Note que a banda "Rush", pois ela foi a primeira a ser adicionada.
Vamos adicionar o "Tiririca" na posio do "Rush", ou seja, na posio '0':
bandas.add(0,"Tiririca");
ou
bandas.add( bandas.indexOf("Rush"), "Tiririca");
Pois o mtodo 'indexOf' retorna o ndice em que ocorre "Rush".
Para saber o tamanho que tem seu ArrayList, basta usar o mtodo 'size()':
bandas.size();
Feito isso, rapidamente remova o "Tiririca", pois algum pode ver.
Para tal, use o mtodo 'remove':
bandas.remove("Tiririca");
Ok. No quer mais brincar de ArrayList? Remova tudo
bandas.clear();
import java.util.ArrayList;
import java.util.Arrays;
public class arrayLists{
public static void main(String[] args){
ArrayList<String> bandas = new ArrayList<String> ();
bandas.add("Rush");
System.out.print( "Adicionando a banda Rush: " );
System.out.println( Arrays.toString( bandas.toArray() ) );
bandas.add("Beatles");
System.out.print( "Adicionando a banda Beatles: " );
bandas.add("Iron Maiden");
System.out.print( "Adicionando a banda Iron Maiden: " );
System.out.print( "Quem est na ndice 0: " );
System.out.println( bandas.get(0) );
System.out.print( "Adicionando Tiririca onde estava o Rush: " );
bandas.add( bandas.indexOf("Rush"), "Tiririca");
System.out.print( "Nmero de elementos na lista: " );
System.out.println( bandas.size() );
System.out.print( "Removendo o Tiririca: " );
bandas.remove("Tiririca");
System.out.print( "Removendo tudo: " );
bandas.clear();
}
}
Sada
60
61
Adicionando a banda Rush: [Rush]

Adicionando a banda Beatles: [Rush, Beatles]
Adicionando a banda Iron Maiden: [Rush, Beatles, Iron Maiden]
Quem est na ndice 0: Rush
Adicionando Tiririca onde estava o Rush: [Tiririca, Rush, Beatles, Iron Maiden]
Nmero de elementos na lista: 4
Removendo o Tiririca: [Rush, Beatles, Iron Maiden]
Removendo tudo: []
7. Constantes
Constantes so o oposto das variveis. A diferena est em no podermos atribuir
um novo valor, pois ele recebe um valor final imutvel. Isso ajuda na hora que temos que
lembrar de algum nmero muito grande ou muito pequeno, ou at mesmo um valor que
aparentemente no nos diz nada, mas que significa alguma coisa.
Um exemplo bem simples seria 000000. Mas, o que 000000? difcil saber o que
ele significa, mas muito mais fcil entender que preto em Java Color.BLACK. Ou seja,
BLACK uma constante que guarda sempre o mesmo valor (000000).
Para criarmos uma constante em Java muito simples. Primero nos atemos ao fato
de que uma constante criada dentro de uma classe deve ser acessada por qualquer
membro da classe, ento, por definio, essa constante tambm global ou esttica
(static). Como uma constante no muda seu valor, ento, marcamos ela com a palavra
chave final, que far com que o valor nunca seja modificado.
Toda constante um dado, portanto, o seu tipo de dado tambm obrigatrio
declarar. Ento, para declarar uma constante faramos:
static final long CONST1 = 1L; ou final long CONST2 = 1L;
62
No qual, CONST1 seria uma constante global (ou seja, foi declarada no corpo da classe)
e CONST2 seria uma constante local (ou seja, foi declarada no corpo de alguma funo
ou mtodo, por exemplo, dentro de main)
Para ilustrar bem o uso de constantes, vamos calcular a rea e o comprimento de
um crculo. O porque deste clculo que necessitaremos de um nmero constante
chamado PI. PI um nmero irracional, ou seja, no h uma representao exata dele,
mas, para o nosso exemplo, usaremos ele com uma preciso de 8 casas decimais.
Portanto, nosso pi ser do tipo double que valer 3,14159265. Ento, perceba que
muito mais fcil se lembrar da palavra pi do que do nmero 3,14159265. Alm de,
obviamente, digitarmos bem menos.
Ento, s para esclarecer o que ir acontecer: O clculo da rea do crculo
equivale a raio2 pi, e o comprimento medido em 2 raio pi, no qual o raio a
distncia entre a borda do crculo e seu centro.
Vamos usar um raio de 25cm. Vejamos o resultado.
public class Constantes {
static final float PI = 3.14159265f;
float raio = 25f;
float comprimento = raio * 2 * PI;
float area = (raio * raio) * PI;
System.out.println("Dados de um crculo de " + raio + "cm:\n"
+ "comprimento: " + comprimento + "cm\n"
+ "rea: " + area + "cm2");
}
}
Exite uma infinidade de constantes que so implementadas em vrias classes
diferentes como por exemplo BLACK da classe Color, PLAIN_MESSAGE da classe
JOptionPane e at mesmo o PI da classe Math com muito mais preciso do que este que
63
usamos no exemplo.
8. Funes
Funes so rotinas ou sub-rotinas automatizadas. Sempre que pretendemos usar
a mesma codificao para algo especfico, criamos uma funo. Dessa forma, sempre
que quisermos utilizar aquela codificao, ao invs de ns a digitarmos inteira novamente,
simplesmente chamamos a funo. Funes so extremamente teis e adaptveis, e o
conceito de funes importante para mais a frente entendermos o funcionamento e
criao dos mtodos.
8.1. Criando funes sem argumentos

Para criar uma funo, temos que ter sempre em mente que toda funo global,
ou seja, esttica (static). As funes mais bsicas so aquelas que apenas executam
uma rotina, portanto, no recebem nenhum argumento. No cdigo, digitaramos dentro da
classe, mas fora da funo main o seguinte:
public static void nomeDaFuno () {
cdigo da funo
}
Static porque pode ser acessado globalmente; void porque no retorna nenhum valor;
mesmo no tendo argumentos, necessrio ter parnteses.
64
Vamos ver o exemplo:

public class ExemploFuncao {
//criando a funo
public static void mostrarMensagem() {
System.out.println("Minha Mensagem");
}
//chamando a funo dentro do programa
mostrarMensagem();
}
}
O cdigo acima funciona da seguinte maneira:
Primeiro criada a funo mostrarMensagem(), que em seu corpo tem apenas um
println com uma mensagem. Depois iniciamos nosso programa com o main. Dentro do
main chamamos a funo. Para isso, basta colocar o nome da funo. Quando a funo
chamada, o cdigo dentro do corpo da funo executado. Concluindo, o programa
acima apenas mostra na tela a mensagem Minha Mensagem.
8.2. Funes com argumentos

Funes com argumentos funcionam e so criadas da mesma forma que uma
funo sem argumento, porm com uma diferena. A diferena est que haver
informaes necessrias para que a funo processe, e essas informaes sero
descritas dentro dos parnteses.
Uma funo pode ter um ou vrios argumentos desde que separados por vrgula
(,). Cada argumento deve ter seu tipo de dado declarado. Ento, todos os exemplos
abaixo so funes vlidas:
65
public static void funcao1 (String arg1){}

public static void funcao2 (int arg1, int arg2){}
public static void funcao3 (String arg1, char arg2, int arg3, float arg4, Object arg5) {}
Para demonstrar este tipo de funo criaremos uma funo que mostra na tela o
resultado fatorial de um nmero. Alm disso, colocaremos esta funo dentro de um loop
que ir de 1 a 10 para ele mostrar cada um desses fatoriais.
public class FatorialComFuncao {
public static void fatorar(int numero) {
int fator = 1;
for (int i = numero; i > 1; i--) {
fator *= i;
}
System.out.println(numero + "! = " + fator);
}
for (int x=1; x<=10; x++)
fatorar (x);
}
}
Simplificando, x que est sendo passado pelo main para fatorar() ser o valor int
numero da funo fatorar.
8.3. Funes que retornam valores
Aqui veremos a grande vantagem de se criar uma funo. Funes podem retornar
valores de um processo executado dentro delas e esse valor pode ser guardado dentro de
66
uma varivel no programa. Isso com certeza deixa nosso cdigo mais simples, pois
podemos destacar processos repetitivos e guardar em uma varivel apenas o resultado
daquele processo.
Para criar uma funo que retorna valores temos que nos ater ao fato retorno.
Como todas as outras funes no retornavam valores, ento, seu retorno era vazio void. Agora, temos que declarar que tipo de retorno vir da funo.
O retorno dado pelo comando return, que finaliza a funo e mostra o retorno. A
varivel ou valor que utilizarmos para return ser o tipo de retorno da funo.
Vamos imaginar que trs funes, sendo que a primeira ir retornar um inteiro, a
segunda um double e a terceira uma string. Ento, as criaramos da seguinte maneira:
public static int funcaoDeInteiro (){}

public static double funcaoDeDouble (){}
public static String funcaoDeString (){}
No exemplo abaixo, ns criaremos uma funo que ir retornar um valor booleano

(verdadeiro ou falso). Usando este retorno, determinaremos o que fazer dentro de uma
estrutura seletiva (if).
public class Primo {
public static boolean ehPrimo(long nr) {
if (nr < 2)
return false;
for (long i = 2; i <= (nr / 2); i++) {
if (nr % i == 0)
return false;
}
return true;
67
}
long x = 5;
if (ehPrimo(x)) // se for primo
System.out.println(x + " primo");
else // se no for primo
System.out.println(x + " no primo");
}
}
O algoritmo utilizado acima muito solicitado em cursos de programao e
faculdades. O que a funo faz verificar se um nmero primo ou no.
9. Igualdade de Objetos em java - equals() e hashCode()

Um dos maiores problemas que os programadores encontram ao inciar seu
trabalho em java o de entender os testes de igualdade. A igualdade em java no pode
ser testada atravs do operador == , estes operador apenas verifica se duas variveis
fazem referencia a mesma instancia de um objetos.
Para ser um pouco mais claro, imaginemos uma classe Pessoa, como segue
abaixo.
public class Pessoa {
private String nome;
private String cpf;
public Pessoa(String nome, String cpf){
this.nome= nome;
this.cpf = cpf;
68
}
public String getNome(){
return nome;
}
public String getCpf() {
return cpf;
}
}
Como posso eu falar que duas pessoas so as mesmas pessoas ? a JVM (Java
Virutal Machine) por se s no tem como identificar como duas pessoas podem ser ditas
iguais, desta forma o teste abaixo, verifica apenas se estas so instancias de um mesmo
objeto.
Pessoa maria = new Pessoa("Maria da Silva","111.222.333-44");

Pessoa mariaDaSilva = new Pessoa("Maria da Silva","333.555.222-11");
Apesar dos nomes iguais de maria e mariaDaSilva, os cpfs so diferentes e desta

forma posso falar que so pessoas diferentes.
Pessoa mariaDaSilva2 = new Pessoa("Maria da Silva","333.555.222-11");
Os Objetos mariaDaSilva e mariaDaSilva2 so pessoas iguais, em um teste de

igualdade eu vou querer que para esses 2 objetos ele seja positivo, porem so 2
instancias de de objetos diferentes, portanto:
69
boolean referencia = mariaDaSilva == mariaDaSilva2;

System.out.println("Referencia falso ("+ referencia +)");
Isso ocorre porque a varivel mariaDaSilva aponta para um objeto enquanto a

varivel mariaDaSilva2 aponta para outro objeto.
9.1. Equals:
Para resolver esse problema em java existe um mecanismo de igualdade que vem
em todo objeto, e descende da classe Object, onde voc pode testar a igualdade entre
objetos atravs de: este teste, quando no sobrescrito apenas testa se os 2 objetos so
referencia de uma mesma instancia.
Antes de implementar um equals em nossos objetos preciso saber de cinco
regras.
reflexivo: para qualquer qualquer referencia no nula a, a.equals(a) tem sempre

que ser verdadeiro, ou seja, um objeto sempre igual a se mesmo.
simtrico: para quaisquer referencias no nulas de a e b, a.equals(b) so poder

retornar verdade se b.equals(a) retornar verdade, o mesmo raciocnio vale para
falso.
transitivo: para quisquer referencias no nulas de a,b e c, se a.equals(b) e

b.equals(c) so verdade ento tambm tem que ser verdade que a.equals(c).
consistente - para quaisquer referencias no nulas de a e b, mltiplas invocaes

de a.equals(b) ter sempre que retornar true ou sempre retornar false, enquanto
informaes usadas na comparao do equals no sejam alteradas.
O resultado de equals() entre um objeto e nulo deve retornar sempre falso,
70
a.equals(null) sempre falso.
Com essa ideia podemos pensar em como implementar o equals para nossa classe
Pessoa, sabemos que, duas Pessoas de mesmo nome podem ser diferente, portanto
esse no pode ser nosso parmetro para teste. Duas pessoas no podem ter o mesmo
nmero de CPF, ento este nmero nico, e pode identificar uma pessoa, sendo assim
nosso teste de igualdade entre duas pessoa pode ser.
Com essa ideia podemos pensar em como implementar o equals para nossa classe
Pessoa, sabemos que, duas Pessoas de mesmo nome podem ser diferente, portanto
esse no pode ser nosso parmetro para teste. Duas pessoas no podem ter o mesmo
nmero de CPF, ento este nmero nico, e pode identificar uma pessoa, sendo assim
nosso teste de igualdade entre duas pessoa pode ser:
@Override
public boolean equals(Object obj){
if(obj == null){
return false;//nenhum objeto pode ser igual a null
}
if(!obj instanceof Pessoa) {//uma pessoa s pode ser igual a outra pessoa
return false;
}
final Pessoa other = (Pessoa) obj;
if (getCpf() ==null)//se no houver CPF no h como testar as duas pessoas.
return false;
return getCpf().equals(other.getCpf()); //duas pessoas sero iguais...
//se seus CPFs forem iguais...
}
71
9.2. HashCode:
Assim como h um teste de igualdade, Java ainda dispem de outro teste, onde
possvel rapidamente, atravs de integer, restringir o campo de igualdade, atravs de
hashCode(). assim como equals, o hashCode segue um contrato descrito abaixo:
constante: A qualquer momento durante a excecuo de um programa java, o

mtodo hashCode deve constantemente retornar o mesmo inteiro, enquanto
informaes usadas na comparao do equals no sejam alteradas. O hashCode
no precisa ser constante de uma execuo da aplicao para outra.
Se dois objetos a e b, so iguais, a.equals(b) retorna verdadeiro, ento os inteiros

produzidos por a e b devem ser os mesmos, ou seja a.hashCode() ==
b.hashCode()
O inverso no necessariamente verdadeiro, dois objetos que produzirem o

mesmo hashCode podem ser diferentes
Diante disso a utilizao do hashCode principalmente para excluir igualdade, ou

seja, ele serve como uma peneira, e largamente utilizado por Collection em buscas
como contains, remove, removeAll, retainAll entre outras coisas. A ideia se os hashCode
so diferentes ento no preciso testar a igualdade, pois j se garante que os objetos
no sero iguais, poupando processamento no momento da busca, pois hashCode usa
um calculo com int, que consome pouco processo, geralmente bem menos que o equals.
Existem varias estrategias para calculo do hashCode, desde a mais simples, onde
voc praticamente exclui a funcionalidade do hashCode, deixando seu valor constante
para qualquer objeto.
72
@Override
public int hashCode(){
return 0;
}
Este mtodo acima, funciona e respeita as regras de contrato de hashCode, porem
seu programa poder perder em velocidade. extremamente desaconselhvel o uso de
hashCode constante para qualquer objeto, pois vrias funcionalidade que otimizam
processos de busca no tero serventia com um hashCode mau projetado.
A melhor estratgia para hashCode olhar para equals, e verificar como a
igualdade exigida, e assim montar um hashCode, concatenando os hashCode dos
objetos que fazem a igualdade e designando um peso para as propriedades.
Por exemplo, para nossa classe Pessoa uma boa estrategia de hashCode seria:
@Override
public int hashCode() {
int hash = 7;
hash = 23 * hash + (getCpf() != null ? getCpf().hashCode() : 0);
return hash;
}
O nmero 7 contido nesse hashCode apenas um nmero randmico para startar
o hashCode, e diferenciar de outros objetos, por exemplo, um objeto empresa poderia
iniciar por 3. o nmero 23 outro nmero randmico, usado para quando h varias
propriedades e escalar o hashCode entre as varias propriedade que definem um objeto
igual.
Como no exemplo acima usamos o hashCode da string cpf, e como String tem seu
hashCode bem implementando, podemos assim garantir que sempre que os CPF forem
iguais os hashCode sero iguais.
73
A igualdade entre objetos uma parte fundamental da programao, e uma das

necessidades bsica de logica, saber se dois objetos so iguais. A implementao destes
dois mtodos importante, e deve ser implementado em todas as classes instanciveis
do projeto, de forma a prover mecanismos corretos de comparao de igualdade (equals),
assim
como
uma
forma
de
otimizar
os
processos
de
busca
(hashCode).
Muitos programadores s comeam a entender a real necessidade da correta

implementao destes dois mtodos ao utilizar mais largamente a Java Collection
Framework do pacote java.util, pois vrios de seus mtodos como contains, removeAll,
remove, ratainAll, etc, falham quando equals no esta corretamente implementado, e
perdem performance ou falham quando hashCode no esta otimizado ou corretamente
implementando.
10. Representao textual de objetos - mtodo toString()

O Java usa o mtodo toString() toda vez que for necessrio converter um objeto
em String, ou seja, para obter uma representao textual do objeto. Por exemplo para
imprimir um objeto qualquer usando System.out.println ou para mostrar os itens de um
JComboBox (usando o Renderer padro).
Esse mtodo toString() definido na classe Object, portanto herdado por todos
os objetos - todos os objetos so capazes de gerar uma representao textual. Mas o
mtodo do Object no conhece as classes derivadas, no sabe como o objeto deve ser
representado. Por isso usa um padro: o nome da classe seguido por um '@' e pelo
hashCode em hexadecimal da instncia em questo:
public String toString(){
return getClass().getName() + "@" + Integer.toHexString(hashCode());
}
74
Exemplo:
private final String nome;
private int idade;
public Pessoa(String oNome, int aIdade){
nome = oNome;
idade = aIdade;
}
Pessoa pessoa = new Pessoa("fulano", 21);
System.out.println(pessoa); //equivale a System.out.println(pessoa.toString());
}
}
vai imprimir algo como "Pessoa@1b533b0" (provavelemnte com outro nmero).
Esse formato normalmente no o que queremos! Por isso temos que sobrescrever o
mtodo
toString()
para
obter
representao
desejado.
Exemplo, para mostrar o nome e a idade (entre parnteses) da pessoa,

adicionamos o mtodo toString():
private int idade;
public Pessoa(String oNome, int aIdade) {
nome = oNome;
idade = aIdade;
}
@Override
public String toString() {
return nome + "(" + idade + ")";
}
75

Pessoa pessoa = new Pessoa("fulano", 21);
System.out.println(pessoa);
}
}
Dessa vez obteremos, como desejado "fulano(21)". O mesmo problema ocorre com
um vetor (Array):
...
int[] array = {1, 2, 3};
System.out.println(array);
}
...
Ir imprimir algo como "[I@15497e0" - "[I" representa um array de int's. O problema
que no tem como sobrescrever o toString() de um Array, mas podemos usar a classe
auxiliar Arrays do pacote java.util que contm vrios mtodos estticos para trabalhar com
um Array. No nosso caso podemos usar o toString(int[]):
...
int[] array = {1, 2, 3};
System.out.println(Arrays.toString(array));
}
...
Imprimir "[1, 2, 3]"@146c21b
A em sntese o problema sempre que obter algo como "Classe@146c21b"
porque a classe em questo no sobrescreveu o mtodo toString().
A soluo, implementar/sobrescrever o mtodo toString() do Objeto ou usar o
Arrays.toString() se for um Array. (Exemplos acima)
76
11. Instanciando Objetos

Objetos so estruturas de dados definidas e agrupas dentro de uma classe.
Sempre que utilizamos um objeto ou classe devemos reservar espao em memria para
que aquele objeto seja manipulado sem maiores problemas.
Alm do mais, tambm podemos utilizar a mesma classe (com todos os seus
mtodos e atributos) para manipular outros objetos que sero tratados de forma diferente
(mesmo se tiverem as mesmas caractersticas do objeto anterior), pois sero dois
endereos de memria diferentes.
A vantagem de Java nos possibilitar uma instanciao rpida e simples, sem
termos que nos preocupar com referncia a endereos e alocao dinmica de memria,
pois quem trata de manipular a memria o prprio Java. Sem contar que, se um objeto
no mais referenciado dentro do programa, o prprio Java trata de liberar os recursos
de memria consumidos pelo objeto usando o Garbage Colletor - Coletor de Lixo.
Quem faz o papel de instanciador em Java o new. New trata de reservar memria
o suficiente para o objeto e criar automaticamente uma referncia a ele. Para new
conseguir determinar o objeto, precisamos usar o mtodo construtor que ser usado
como base para instanciar a classe e gerar o objeto.
Tecnicamente, declaramos uma varivel qualquer como sendo do tipo da classe
(ex.: TV minhaTV; ), depois instanciamos o objeto atribuindo a varivel o resultado obtido
por new mais o mtodo construtor (ex.: minhaTV = new TV(); ).
Apesar de parecer muitos detalhes, isso fica mais facilmente visualizado no cdigo
abaixo.
77
public class TV {
int tamanho;
int canal;
boolean ligada;
TV() {
tamanho = 21;
canal = 0;
ligada = false;
}
TV objeto1 = new TV();
TV objeto2;
objeto2 = new TV();
}
}
No cdigo acima, criamos uma classe chamada TV com os mesmos atributos do
exemplo da pgina Criao de Classes, e criamos um mtodo construtor que inicializa os
atributos da classe TV com alguns valores. Declaramos duas variveis chamadas objeto1
e objeto2 sendo do tipo TV. Depois, instanciamos o objeto usando new e o mtodo
construtor.
12. Auto Referencia de Objetos - This

This usado para fazer auto-referncia ao prprio contexto em que se encontra.
Resumidamente, this sempre ser a prpria classe ou o objeto j instanciado.
Esse conceito de auto-referncia importante para que possamos criar mtodos
construtores sobrecarregados e mtodos assessores mais facilmente. Por base, se
criarmos um mtodo que receba um argumento chamado ligado que queremos atribuir
para o atributo da classe, que tambm se chama ligado, devemos diferenciar ambos
78
mostrando a quem cada um pertence.

Como this se refere ao contexto empregado, ento o usamos para identificar que
ligado ser o atributo da classe e ligado sem o this se refere ao parmetro do mtodo. O
que resultaria nisto:
public class TV {
//atributos
int tamanho;
int canal;
boolean ligada;
// mtodo contrutor com parmetro
TV(boolean ligada) {
this.ligada = ligada;
/**
* Onde this.ligada o atributo
* e ligada o valor do parmetro
*/
}
}
Traduzindo, this.ligada seria: a varivel ligada desta classe recebe o valor de
ligada, ou seja, o nico ligada que existe fora o atributo o parmetro.
13. Sobrecarga de mtodos

Java nos permite criar vrios mtodos com o mesmo nome desde que tenham
parmetros diferentes. Isso o que chamamos de sobrecarga de mtodos. A sobrecarga
de mtodos consiste em criarmos o mesmo mtodo com possibilidades de entradas
diferentes.
Essas entradas, caracterizadas como parmetros, devem sempre ser de tipos
diferentes, quantidades de parmetros diferentes ou posies dos tipos diferentes.
79
Para visualizarmos um cenrio, vejamos a classe abaixo:

public TV {
int canal;
int volume;
boolean ligada;
int tamanho;
}
Agora, criaremos o mtodo ligar. O mtodo ligar, simplesmente, muda o valor dos
atributos canal e volume para 3 e 25, respectivamente.
void ligar (){
canal = 3;
volume = 25;
ligada = true;
}
Agora, vamos personalizar este mtodo para que ele mude o atributo ligada de
acordo com o parmetro.
void ligar (boolean ligada){
canal = 3;
volume = 25;
}
Embora os dois mtodos tenham o mesmo nome, poderamos utilizar ambos os na
mesma classe se quisermos, porque um possui argumentos e o outro no.
void ligar (){
canal = 3;
volume = 25;
ligada = true;
}
void ligar (boolean ligada){
canal = 3;
80
volume = 25;
}
Porm, o mesmo no pode ser aplicado aos atributos canal e volume. Porque no
possvel criar um mtodo que recebe um inteiro e criar um outro mtodo com o mesmo
nome que tambm recebe um inteiro, mesmo que estes dois inteiros sejam totalmente
diferentes. Se visualizarmos como Java interpreta o mtodo, veramos:
void ligar (int volume) = void ligar (int canal)
void ligar (int) = void ligar (int)
Por outro lado, perfeitamente possvel criarmos dois mtodos que recebam um
booleano e um inteiro, inclusive se forem os mesmos, mas em posies diferentes. Isso
acontece porque Java no verifica o nome do parmetro, mas apenas o tipo dele.
void ligar (boolean ligada, int canal) void ligar (int canal, boolean ligada)
void ligar (boolean, int) void ligar (int, boolean)
Portanto, podemos fazer muitas combinaes desde que essas combinaes no
sejam em nmeros iguais, de tipos iguais e nas mesmas posies.
Abaixo, est a classe com algumas combinaes possveis. um bom costume
sempre referenciar para o mtodo que recebe mais argumentos.
public class TV {
int canal;
int volume;
boolean ligada;
int tamanho;
void ligar() {
this.ligar(3, 25, true);
}
81
void ligar(boolean ligada) {

this.ligar(3, 25, ligada);
}
void ligar(int canal, int volume) {
this.ligar(canal, volume, true);
}
void ligar(int canal, int volume, boolean ligada) {
this.canal = canal;
this.volume = volume;
}
}
14. Acesso a Membros e Mtodos

Vimos, at agora, como criar uma classe, definir um mtodo construtor,
sobrecarregar mtodos e instanciar objetos. Nesse momento, vamos ver como acessar
seus membros e mtodos.
Os acessos a membros ou mtodos de uma classe so dados a partir do objeto
instanciado usando um separador que o ponto (.).
Portanto, para acessar qualquer membro da classe, basta que usemos o nome do
objeto, mais um ponto e o nome do membro que queremos acessar. Ainda tomando como
exemplo a classe TV j vista antes, vamos modificar dentro do programa dois atributos: os
atributos canal e volume.
public class TV {
int canal;
int volume;
boolean ligada;
int tamanho;
82
public TV(){
this.tamanho = 21;
this.ligada = true;
}
TV minhaTV = new TV();
minhaTV.canal = 3;
minhaTV.volume = 25;
}
}
Como percebemos construdo um objeto chamado minhaTV da classe TV com o
tamanho de 21" e j ligada. Durante a execuo do programa modificamos diretamente
seu canal e volume usando o objeto que instanciamos.
Da mesma forma que acessamos um atributo, tambm podemos acessar um
mtodo. No exemplo abaixo, criaremos o mtodo para aumentar volume da TV.
public class TV {
int canal;
int volume;
boolean ligada;
int tamanho;
public TV(){
this.tamanho = 21;
this.ligada = true;
this.canal = 3;
this.volume = 25;
}
public void aumentarVolume(){
this.volume += 5;
}
83
TV minhaTV = new TV();

minhaTV.aumentarVolume();
}
}
Aqui, o objeto minhaTV comea com volume 25 e depois de chamar seu mtodo
aumentarVolume() fica com 30.
Algumas consideraes que devemos ter saber diferenciar funes de mtodos.
Apesar da essncia de ambos ser a mesma coisa, funes so chamadas estaticamente,
ou seja, ela pode ser chamada diretamente sem o intermdio de nenhum objeto.
J os mtodos so chamados de dentro das classes, portanto, obrigatoriamente
devemos ter um objeto instanciado para conseguirmos utilizar o mtodo. Vejamos a
diferena:
public class TV {
int canal;
int volume;
boolean ligada;
int tamanho;
public TV(){
this.tamanho = 21;
this.ligada = false;
this.canal = 0;
this.volume = 0;
}
// mtodo da classe
public void ligar(boolean ligada){
}
// funo
public static void estahLigada (TV objeto){
if (objeto.ligada)
System.out.println ("est ligada");
84
else
System.out.println ("no est ligada");
}
}
TV televisao1 = new TV();
TV televisao2 = new TV();
// chamando o mtodo ligar
televisao1.ligar(true);
televisao2.ligar(false);
System.out.print ("A televiso 1 ");
// chamando a funo estahLigada
estahLigada (televisao1);
System.out.print ("A televiso 2 ");
estahLigada (televisao2);
}
Observemos que chamamos o mtodo ligar() de cada objeto, portanto, existem
dois mtodos ligar distintos - o mtodo ligar() da televisao1 e o mtodo ligar() da
televisao2. A funo esttica, portanto, existe apenas uma funo estahLigada().
15. Encapsulamento - public, private e protected

Se outros programadores usam nossa classe, ns queremos garantir que erros
pelo mau uso no ocorram. Encapsulamento serve para controlar o acesso aos atributos
e mtodos de uma classe.
uma forma eficiente de proteger os dados manipulados dentro da classe, alm de
determinar onde esta classe poder ser manipulada. Usamos o nvel de acesso mais
restritivo que faa sentido para um membro particular. Sempre usamos private, a menos
que tenhamos um bom motivo para deix-lo com outro nvel de acesso.
No devemos permitir o acesso pblico aos membros, exceto em caso de ser
85
constantes. Isso porque membros pblicos tendem a nos ligar a uma implementao em
particular e limita a nossa flexibilidade em mudar o cdigo.
Basicamente, usamos quatro tipos de encapsulamento que so divididos em dois nveis:
Nvel de classe ou topo: Quando determinamos o acesso de uma classe inteira que
pode ser public ou package-private (padro);
Nvel de membro: Quando determinamos o acesso de atributos ou mtodos de uma
classe que podem ser public, private, protected ou package-private (padro).
Para utilizarmos estes modificadores de acesso, basta que ns os digitemos antes
do nome da varivel, atributo, mtodo, funo ou classe, com exceo de
package-private, que entendido como padro, portanto, qualquer membro ou classe
que no tenha modificador especificado.
Exemplo:
public class MinhaClasse { //classe public
private int inteiro; //atributo inteiro private
protected float decimal; //atributo float protected
boolean ativado; //atributo booleano package-private
}
15.1. Public
O modificador public deixar visvel a classe ou membro para todas as outras
classes, subclasses e pacotes do projeto Java.
86
15.2. Private
O modificador private deixar visvel o atributo apenas para a classe em que este
atributo se encontra.
15.3. Protected
O modificador protected deixar visvel o atributo para todas as outras classes e
subclasses que pertencem ao mesmo pacote. A principal diferena que apenas as
classes do mesmo pacote tem acesso ao membro. O pacote da subclasse no tem
acesso ao membro.
15.4. Sem Modificador (Padro)

Por padro, a linguagem Java permite acesso aos membros apenas ao pacote em
que ele se encontra. De forma ilustrativa, abaixo est uma tabela demonstrando todas
estas caractersticas.
Modificador
Classe
Pacote
Subclasse
Globalmente
Public
sim
sim
sim
sim
Protected
sim
sim
sim
no
Sem Modificador (Padro)
sim
sim
no
no
Private
sim
no
no
no
Fonte: Controlling Access to Members of a Class
87
15.5. Mtodos Acessores - Getters e Setters

Como visto anteriormente, o encapsulamento "protege" os atributos ou mtodos
dentro de uma classe, portanto devemos prover meios para acessar tais membros quando
eles so particulares, ou seja, quando possuem o modificador private.
O que torna isso possvel a criao de mtodos.
Em programao orientada a objetos, esses mtodos so chamados de mtodos
acessores ou getters e setters, pois eles provm acesso aos atributos da classe, e
geralmente, se iniciam com get ou set, da a origem de seu nome.
Na verdade, no h nada de diferente entre os mtodos comuns e os mtodos
acessores. A nica importncia est no fato da orientao a objeto. Pois, sempre que
formos acessar um membro em Java usaremos get ou set.
15.5.1. Set
Nomeamos um mtodo acessor com set toda vez que este mtodo for modificar
algum campo ou atributo de uma classe, ou seja, se no criarmos um mtodo acessor set
para algum atributo, isso quer dizer que este atributo no deve ser modificado.
Portanto, como o valor de um atributo da classe ser modificado, no necessrio
que este mtodo retorne nenhum valor, por isso, os mtodos setters so void. Porm,
obrigatoriamente, eles tem que receber um argumento que ser o novo valor do campo.
88
15.5.2. Get
Nomeamos um mtodo acessor com get toda vez que este mtodo for verificar
algum campo ou atributo de uma classe. Como este mtodo ir verificar um valor, ele
sempre ter um retorno como String, int, float, etc. Mas no ter nenhum argumento.
15.5.3. Is
Nomeamos um mtodo acessor com is toda vez que este mtodo for verificar
algum campo ou atributo de uma classe que tenha retorno do tipo boolean. Levando em
considerao as informaes acima, nossa classe de exemplo TV ficaria:
public class TV {
private int tamanho;
private int canal;
private int volume;
private boolean ligada;
public TV(int tamanho, int canal, int volume, boolean ligada) {
this.tamanho = tamanho;
this.canal = canal;
}
public int getTamanho() {
return tamanho;
}
public void setTamanho(int tamanho) {
}
89
public int getCanal() {

return canal;
}
public void setCanal(int canal) {
this.canal = canal;
}
public int getVolume() {
return volume;
}
public void setVolume(int volume) {
}
public boolean isLigada() {
return ligada;
}
public void setLigada(boolean ligada) {
}
}
16. Herana
Enquanto programamos em Java, h a necessidade de trabalharmos com vrias
classes. Muitas vezes, classes diferentes tem caractersticas comuns, ento, ao invs de
criarmos uma nova classe com todas essas caractersticas usamos as caractersticas de
um objeto ou classe j existente.
Ou seja, herana , na verdade, uma classe derivada de outra classe. Para
simplificar de uma forma mais direta, vejamos:
90
Vamos imaginar que exista uma classe chamada Eletrodomstico, e nela esto
definidos os seguintes atributos: ligado (boolean), voltagem (int) e consumo (int). Se
levarmos em conta a classe TV que estamos usando de exemplo at agora, podemos
dizer que TV deriva de Eletrodomstico. Ou seja, a classe TV possui todas as
caractersticas da classe Eletrodomstico, alm de ter suas prprias caractersticas.
Extends e Super Para fazermos uma classe herdar as caractersticas de uma outra,
usamos a palavra reservada extends logo aps a definio do nome da classe. Dessa
forma:
class NomeDaClasseASerCriada extends NomeDaClasseASerHerdada
Importante: Java permite que uma classe herde apenas as caractersticas de uma nica
classe, ou seja, no pode haver heranas mltiplas. Porm, permitido heranas em
cadeias, por exemplo: se a classe Mamifero herda a classe Animal, quando fizermos a
classe Cachorro herdar a classe Mamifero, a classe Cachorro tambm herdar as
caractersticas da classe Animal.
Como estamos tratando de herana de classes, toda classe tem seu mtodo
construtor. Portanto, se estamos trabalhando com duas classes, temos dois mtodos
construtores. Para acessarmos o mtodo construtor da classe que est sendo herdada
usamos o super().
91
Podemos usar o super para qualquer construtor da classe pai, pois o Java consegue
diferenciar os construtores por causa da sobrecarga de mtodos. Para finalizar, iremos
mostrar o exemplo citado mais acima da classe Eletrodomestico e TV.
Observe:
Classe 1: Eletrodomestico
package br.com.primebean;
public class Eletrodomestico {
private boolean ligado;
private int voltagem;
private int consumo;
public Eletrodomestico(boolean ligado, int voltagem, int consumo) {
this.ligado = ligado;
this.voltagem = voltagem;
this.consumo = consumo;
}
// (...)
}
Classe 2: TV
public class TV extends Eletrodomestico {
private int
private int
private int
public TV(int voltagem, int consumo, int canal, int volume, int tamanho) {
super(false, voltagem, consumo);
this.canal = canal;
}
//(...)
}
Classe que mostra a instanciao de TV.
public class ExemploHeranca {
public static void mostrarCaracteristicas(TV obj) {
System.out.print("Esta TV tem as seguintes caractersticas:\n"
+ "Tamanho: " + obj.getTamanho() + "\"\n"
+ "Voltagem Atual: "+ obj.getVoltagem() + "V\n"
+ "Consumo/h: " + obj.getConsumo() + "W\n");
if (obj.isLigado()) {
System.out.println("Ligado: Sim\n"
+ "Canal: " + obj.getCanal() + "\n"
+ "Volume: " + obj.getVolume()+"\n");
} else {
System.out.println("Ligado: No\n");
}
}
TV tv1 = new TV(110, 95, 0, 0, 21);
TV tv2 = new TV(220, 127, 0, 0, 29);
tv2.setLigado(true);
tv2.setCanal(3);
tv2.setVolume(25);
mostrarCaracteristicas(tv1);
mostrarCaracteristicas(tv2);
}
}
O cdigo acima ir mostrar o seguinte resultado:
Esta TV tem as seguintes caractersticas:
Tamanho: 21"
92
93
Voltagem Atual: 110V

Consumo/h: 95W
Ligado: No
Esta TV tem as seguintes caractersticas:
Tamanho: 29"
Voltagem Atual: 220V
Consumo/h: 127W
Ligado: Sim
Canal: 3
Volume: 25
17. Enum
Java nos possibilita criar uma estrutura de dados enumarada. Essas estruturas de
dados enumeradas so conjuntos de constantes organizados em ordem de declarao,
ou seja, o que declarado primeiro vir primeiro. A funcionalidade principal de enum
agrupar valores com o mesmo sentido dentro de uma nica estrutura, como por exemplo,
meses, dias da semana, cores, tabela peridica, etc. e tambm limitar ou determinar
nmero de valores que podem ser usados na programao.
Embora sua funcionalidade totalmente diferente, a criao de uma estrutura
enumerada parecida com uma classe. Basta trocarmos a palavra-chave class pela
palavra-chave enum. Mas, devemos levar em considerao alguns fatores:
94
1. Uma estrutura enum deve ter seu prprio arquivo da mesma forma que acontece com
as classes pblicas. Por exemplo, se ns implementarmos uma classe pblica chamada
HelloWorld, ento, deve haver um arquivo chamado HelloWorld.java. Se criarmos um
enumerador chamado Cores, ento, deve haver um arquivo chamado Cores.java.
2. Estruturas enum no so instanciveis. Ou seja, estruturas enum no possuem um
mtodo construtor, portanto, no h como usar o instanciador new.
3. Estruturas enum so apenas declarveis. Portanto, toda a lista de constantes
declaradas dentro desta estruturas so acessados estaticamente. Ou seja, nome da
varivel, mais ponto (.) e o nome da constante (Suposio: mes.JANEIRO).
4. Toda estrutura enum possui um mtodo para acessar seus valores em forma de array
(vetor) chamado values().
Abaixo est uma estrutura enum:

public enum Cores {
PRETO, BRANCO, PRATA;
}
Agora que temos nosso "kit de constantes" podemos usar em nossa classe.
public class TV {
private int canal;
private int volume;
//declarao da varivel do tipo Enum Cores
private Cores cor;
public TV(int tamanho, Cores cor) {
this.canal = 0;
95
this.volume = 25;
this.cor = cor;
}
public int getTamanho() {
return tamanho;
}
public int getCanal() {
return canal;
}
public int getVolume() {
return volume;
}
public Cores getCor() {
return cor;
}
TV minhaTV = new TV(29, Cores.PRATA);
/**
* acessando estaticamente (diretamente)
* o valor PRATA do enum Cores
**/
System.out.println("Caractersticas da minha TV:" +
"\nTamanho:" + minhaTV.getTamanho() +
"\nCanal atual:" + minhaTV.getCanal() +
"\nVolume atual:" + minhaTV.getVolume() +
"\nCor: " + minhaTV.getCor());
}
}
Estruturas enum tambm podem ser determinadas. Dessa forma, podemos atribuir
mais valores a mesma constante. Por exemplo, podemos fazer uma estrutura enum da
tabela peridica com os smbolos qumicos tendo todos os valores possveis da tabela
(Nmero Atmico, Peso Atmico e Nome do Elemento). Para fazer isso, no final da
enumerao, temos que declarar as constantes que foram usadas, assim:
96
...
private final int numero; //constante para nmero atmico
private final double peso; //constante para peso atmico
private final String nome; //constante para nome do elemento
...
O fator do encapsulamento usando private aqui ser muito importante, pois dessa
forma no haver um meio de alterar o valor dessas constantes por acidente. Aps isso,
criamos mtodos para acessar esses valores.
...
private int numero();
private double peso();
private String nome();
...
Ento, criamos a definio usada nas constantes. Essas definies se parecem
muito com os construtores de classes, mas sua funo apenas indicar o que cada
uma das informaes contidas em cada constante.
...
NomeDoEnum (int numero, double peso, String nome){
this.numero = numero;
this.peso = peso;
this.nome = nome;
...
Relembrando: Todas estas definies sempre devem vir aps a definio das
constantes. No exemplo abaixo, est esta estrutura com apenas trs elementos qumicos.
public enum TabelaPeriodica {
// Declarao das constantes
H (1, 1.00794, "Hidrognio"),
HE (2, 4.002602, "Hlio"),
O (8, 15.9994, "Oxignio");
/**
* Por ser um exemplo,
* no foram colocados
* todos os elementos qumicos
* da Tabela Peridica
**/
// Definio das constantes
private final int numero;
private final double massa;
// mtodos para acessar os valores
private int numero() {
return this.numero;
}
private double massa() {
return this.massa;
}
private String nome() {
return this.nome;
}
//mtodo que define as constantes
private TabelaPeriodica(int numero, double massa, String nome) {
this.numero = numero;
this.massa = massa;
this.nome = nome;
}
System.out.println("Dados do elemento qumico H:");
System.out.println("\nNmero: " + TabelaPeriodica.H.numero() +
"\nMassa: " + TabelaPeriodica.H.massa() +
"\nElemento: " + TabelaPeriodica.H.nome());
}
}
97
98
18. Interfaces
Interface um recurso da orientao a objeto utilizado em Java que define aes
que devem ser obrigatoriamente executadas, mas que cada classe pode executar de
forma diferente. Interfaces contm valores constantes ou assinaturas de mtodos que
devem ser implementados dentro de uma classe. E por que isso?
Isso se deve ao fato que muitos objetos (classes) podem possuir a mesma ao
(mtodo), porm, podem execut-la de maneira diferente.
Usando um exemplo bem drstico, podemos ter uma interface chamada areo que
possui a assinatura do mtodo voar(). Ou seja, toda classe que implementar areo deve
dizer como voar(). Portanto, se eu tenho uma classe chamada pssaro e outra chamada
avio, ambas implementando a interface areo, ento, nestas duas classes devemos
codificar a forma como cada um ir voar(). Uma interface criada da mesma forma que
uma classe, mas utilizando a palavra-chave interface no lugar de class.
interface nomeDaInterface { mtodoAbstrato (argumentos); }
18.1. Usando uma Interface em uma Classe

Como vimos anteriormente, uma classe pode extender suas funcionalidades
obtendo as caractersticas de outra classe num processo que chamamos de herana.
Uma interface no herdada, mas sim, implementada. Porque todo o cdigo dos mtodos
da interface deve ser escrito dentro da classe que o chama. Dessa forma, obtemos as
assinaturas dos mtodos da interface em uma classe usando a palavra- chave
implements.
A vantagem principal das interfaces que no h limites de quantas interfaces uma
classe pode implementar. O que ajuda no caso de heranas mltiplas que no possvel
99
ser feito em Java, pois uma classe apenas pode herdar as caractersticas de uma outra
classe. Trazendo ao exemplo j usado por ns, teramos o seguinte conceito.
1) Teramos a classe principal que caracteriza a TV.
public class TV {
private int canal;
private int volume;
public TV(int tamanho) {
this.canal = 0;
this.volume = 0;
}
// abaixo teramos todos os mtodos construtores get e set...
}
2) Teramos as aes que comumente toda televiso executa, mas que cada modelo pode
executar de forma diferente. Como geralmente toda ao da TV executada pelo controle
remoto, ento chamaremos esta interface de controle remoto.
public interface ControleRemoto {
/*
* Perceba que apenas a assinatura dos mtodos esto aqui.
* E cada mtodo termina com um ponto-e-vrgula (;)
*/
void mudarCanal(int canal);
void aumentarVolume (int taxa);
void diminuirVolume (int taxa);
boolean ligar();
boolean desligar();
}
100
3) Agora que temos nossa interface e a definio do que a TV, vamos desenvolver duas
TVs diferentes, imaginando que fossem duas marcas completamente distintas e que uma
no tem nenhuma relao com a outra.
Como ambas as TVs iro implementar a interface ControleRemoto, ento, no corpo
das duas classes devem conter todos os mtodos da interface. No exemplo usado abaixo,
apenas implementaremos os mtodos ligar e desligar.
A TV modelo 001 uma TV simples, sem muitos recursos que quando acionarmos
o comando desligar ir simplesmente desligar.
public class ModeloTV001 extends TV implements ControleRemoto {
public final String MODELO = "TV001";
public ModeloTV001(int tamanho) {
super(tamanho);
}
public void desligar() {
super.setLigada(false);
}
public void ligar() {
super.setLigada(true);
}
public void aumentarVolume(int taxa) { }
public void diminuirVolume(int taxa) { }
public void mudarCanal(int canal) { }
}
O modelo SDX uma TV mais moderna, que quando acionarmos o comando
desligar ir apresentar uma mensagem dizendo "tchau!".
public class ModeloSDX extends TV implements ControleRemoto {
public final String MODELO = "TV-SDX";
public ModeloSDX(int tamanho) {
super(tamanho);
101
}
System.out.println("Tchau!");
super.setLigada(false);
}
super.setLigada(true);
}
public void aumentarVolume(int taxa) { }
public void diminuirVolume(int taxa) { }
public void mudarCanal(int canal) { }
}
Como pode ser visto, ambos possuem a mesma ao que desligar, porm cada
um executa de forma diferente.
public class ExemploInterfaceamento {
ModeloTV001 tv1 = new ModeloTV001(21);
ModeloSDX tv2 = new ModeloSDX (42);
tv1.ligar();
tv2.ligar();
System.out.print("TV1 - modelo " + tv1.MODELO + " est ");
System.out.println(tv1.isLigada() ? "ligada" : "desligada");
System.out.print("TV2 - modelo " + tv2.MODELO + " est ");
System.out.println(tv1.isLigada() ? "ligada" : "desligada");
}
// ambas as TVs esto ligadas e vamos deslig-las
System.out.println("Desligando modelo " + tv1.MODELO);
tv1.desligar();
System.out.println("Desligando modelo " + tv2.MODELO);
tv2.desligar();
}
Se prestarmos ateno, apenas a TV2 mostrar uma mensagem quando for
desligada. Para visualizar melhor este exemplo, baixe o cdigo exemplo e implemente os
102
mtodos que faltam.
19. Annotations
Annotations, traduzindo, quer dizer anotaes. Annotations do informaes sobre
o cdigo que est sendo escrito ou at mesmo do prprio programa, o que se assemelha
aos comentrios. Porm, annotations podem ser usados como objeto semntico de
compiladores, ou seja, compiladores podem interpretar as annotations.
Dessa forma possvel que compiladores entendam que, por exemplo, no para
mostrar mensagens de advertncias (Warnings), ou usar as annotations para detectar
erros de cdigo, criar documentaes usando XML, etc. Annotations podem possui
elementos ou no. Seus elementos so sempre pair values, ou seja, elemento tem um
nome e um valor.
19.1. Uso de Annotations

As annotations so sempre precedidas de arroba (@). Por conveno, usamos
annotations antes de um elemento qualquer, por exemplo, antes da criao de uma classe
ou do uso de um mtodo. Existem annotations com vrios pair values (valores diferentes)
que so separados por vrgula, que contenham apenas um valor ou simplesmente
nenhum valor. Exemplo: @SuppressWarnings(value = "unchecked").
Quando uma annotation possui apenas um elemento chamado value, ento,
apenas necessrio atribuir seu valor sem declarar o nome value. Exemplo:
@SuppressWarnings("unchecked").
Quando uma annotation no possui elementos, no necessrio usar os parnteses.
103
Exemplo: @Override.
Abaixo est uma lista com algumas das annotations mais utilizadas.
@Deprecated: Sempre que algum mtodo tem seu uso desencorajado por ser perigoso
ou por ter uma alternativa melhor desenvolvida, ento, ele recebe a anotao
@Deprecated.
@Override: Usado principalmente em casos de polimorfismo, sempre que formos
sobrescrever um mtodo da classe-pai (superclasse) devemos indicar ao compilador com
@Override. Mas, devemos tomar cuidado ao utilizar @Override, pois se marcarmos o
mtodo e ele no sobrescrever nenhum mtodo da classe-pai (superclasse), ento, o
compilador gerar uma mensagem erro.
@SuppressWarnings ("deprecation"): Todos os avisos da categoria "inadequado" so
ignorados.
@SuppressWarnings ("unchecked"): Todos os avisos da categoria "no verificado" so
ignorados.
@SuppressWarnings ({"unchecked", "deprecation"}): Todos os avisos de qualquer
categoria so ignorados.
19.2. Criando uma Annotation

Antes de criarmos uma annotation, primeiramente temos que nos ater ao fato de
que annotations apenas podem ser criadas em projetos que so compatveis com JDK
5.0. Annotations so criadas de forma muito parecida com interfaces, diferenciando pelo
fato de antes da palavra-chave interface h um smbolo arroba (@), cada elemento se
parece com a declarao de um mtodo abstrato, a nomenclatura utilizada a mesma
utilizada para nomear Classes e cada annotation fica em um arquivo .java da mesma
forma que uma classe, classe abstrata ou interface.
public @interface MinhaAnnotation {

String elemento1();
int elemento2();
}
Podemos definir um valor padro para um elemento utilizando a palavra-chave default.
public @interface MinhaAnnotation {
String elemento1() default "VALOR";
int elemento2() default 123;
}
Tambm podemos utilizar vetores para a definio de um elemento.
public @interface MinhaAnnotation
String elemento1(); //elemento de String
float elemento2(); //elemento de ponto flutuante
int elemento3() default 1; //elemento inteiro que vale 1 por padro
String[] elemento4(); // elemento vetor de Strings
}
Abaixo est um exemplo de como usar nossa prpria annotation.
public @interface DetalhesSoftware {
String [] desenvolvedor ();
String nomeProjeto ();
String software ();
float versao () default 1.0f;
}
Agora que temos nossa anotao, basta cham-la.
@DetalhesSoftware (
desenvolvedor = ("Desenvolvedor1", "Desenvolvedor2", "Desenvolvedor3"),
nomeProjeto = "Java Resources Checker",
104
105
software = "JRC",
versao = 1.0f
)
public class AlgumaClasse {
//cdigo da classe
}
19.3. Adicionar Annotations ao Javadoc

Para fazer com que nossas annotations fiquem registradas no Javadoc toda vez
que ele for gerado, devemos importar o pacote java.lang.annotation.Documented e antes
de criarmos nossa annotation usarmos @Documented. Vejamos o exemplo abaixo:
import java.lang.annotation.Documented;
@Documented
public @interface DetalhesSoftware {
String software ();
String nomeProjeto ();
float versao () default 1.0f;
String [] desenvolvedor ();
}
20. Classes Abstratas e Mtodos Abstratos

Classes abstratas tem uma funo importante na orientao a objeto em Java. De
forma objetiva, uma classe abstrata serve apenas como modelo para uma classe concreta
(classe que comumente usamos).
106
Como classes abstratas so modelos de classes, ento, no podem ser

instanciadas diretamente com o new, elas sempre devem ser herdadas por classes
concretas. Outro fato importante de classes abstratas que elas podem conter ou no
mtodos abstratos, que tem a mesma definio da assinatura de mtodo encontrada em
interfaces. Ou seja, uma classe abstrata pode implementar ou no um mtodo.
Os mtodos abstratos definidos em uma classe abstrata devem obrigatoriamente
ser implementados em uma classe concreta. Mas se uma classe abstrata herdar outra
classe abstrata, a classe que herda no precisa implementar os mtodos abstratos.
Para criarmos uma classe ou mtodo abstrato usamos a palavra-chave abstract.
Para demonstrar, usaremos uma classe abstrata chamada Eletrodomestico, que servir
de modelo para todos os objetos que possam ser eletrodomsticos.
package classeabstrata;
public abstract class Eletrodomestico {
private boolean ligado;
private int voltagem;
// mtodos abstratos //
/*
* no possuem corpo, da mesma forma que
* as assinaturas de mtodo de uma interface
*/
public abstract void ligar();
public abstract void desligar();
// mtodo construtor //
/*
* Classes Abstratas tambm podem ter mtodos construtores,
* porm, no podem ser usados para instanciar um objeto diretamente
*/
public Eletrodomestico(boolean ligado, int voltagem) {
}
// mtodos concretos
107
/*
* Uma classe abstrata pode possuir mtodos no abstratos
*/
public void setVoltagem(int voltagem) {
}
public int getVoltagem() {
return this.voltagem;
}
public void setLigado(boolean ligado) {
}
public boolean isLigado() {
return ligado;
}
}
Como podemos observar, criamos um modelo de classe que compreende a uma
gama enorme de outros objetos. Agora, qualquer objeto que derivar desse modelo deve
ter sua voltagem especificada e dizer se est ligado ou no.
Ento, vamos criar outras duas classes que herdam as caractersticas da classe
abstrata (modelo).
A primeira a classe TV:
public class TV extends Eletrodomestico {
private int canal;
private int volume;
public TV(int tamanho, int voltagem) {
super (false, voltagem); // construtor classe abstrata
this.canal = 0;
}
/* implementao dos mtodos abstratos */
super.setLigado(false);
setCanal(0);
setVolume(0);
}
super.setLigado(true);
setCanal(3);
setVolume(25);
}
//abaixo teramos todos os mtodos construtores get e set...
}
E essa a classe Radio.

public class Radio extends Eletrodomestico {
public static final short AM = 1;
public static final short FM = 2;
private int banda;
private float sintonia;
private int volume;
public Radio(int voltagem) {
super(false, voltagem);
setBanda(Radio.FM);
setSintonia(0);
setVolume(0);
}
/* implementao dos mtodos abstratos */
super.setLigado(false);
108
109
setSintonia(0);
setVolume(0);
}
super.setLigado(true);
setSintonia(88.1f);
setVolume(25);
}
// abaixo teramos todos os mtodos construtores get e set...
}
Pronto, como podemos ver, temos duas classes totalmente diferentes que tem
como base o mesmo modelo. Tambm perceptvel o fato de que em ambas as classes,
os mtodos abstratos ligar() e desligar() foram implementados, porm, no h a
implementao dos outros mtodos como setVoltagem() ou isLigado().
As classes abstratas servem de base para codificao de uma classe inteira,
diferentemente das interfaces que so apenas assinaturas dos mtodos. Sumarizando,
quando temos que definir variveis, constantes, regras, e pequenas aes definidas
devemos usar classes abstratas. Mas, se formos apenas criar a forma como objetos
devem realizar determinadas aes (mtodos) devemos optar por interfaces.
A boa combinao de heranas e implementaes de classes abstratas e
interfaces proporciona uma forma robusta de criao de softwares e uma tima alternativa
para heranas mltiplas comumente usadas em C++.
Abaixo est uma classe que testa a funcionalidade dessas classes.
package classeAbstrata;
public class Main {
TV tv1 = new TV(29, 110);
110
Radio radio1 = new Radio(110);

/*
* chamando os mtodos abstratos implementados
* dentro de cada classe (TV e Radio)
*/
tv1.ligar();
radio1.ligar();
System.out.print("Neste momento a TV est ");
System.out.println(tv1.isLigado() ? "ligada" : "desligada");
System.out.print("e o Rdio est ");
System.out.println(radio1.isLigado() ? "ligado." : "desligado.");
}
}
}
21. Polimorfismo
Polimorfismo, que vem do grego "muitas formas". o termo definido em linguagens
orientadas a objeto - como o Java - para a possibilidade de se usar o mesmo elemento de
forma diferente.
Especificamente em Java, polimorfismo se encontra no fato de podemos modificar
totalmente o cdigo de um mtodo herdado de uma classe diferente, ou seja,
sobrescrevemos o mtodo da classe pai.
Portanto, polimorfismo est intimamente ligado a herana de classes. Um pequeno
exemplo para simplificar essa caracterstica segue abaixo:
a. Classe 1 possui 2 mtodos: mtodoA() e mtodoB().
b. Classe 2 herda a classe 1.
c. Classe 2 reescreve todo o mtodoA() que pertence a classe 1.
111
Levando isso a um patamar mais prtico.

Sabemos que toda classe em Java herda implicitamente a classe Object. A classe
Object possui alguns mtodos, dentre eles o mtodo toString(). O mtodo toString()
original, descreve qual instncia de objeto est sendo utilizada. Resumidamente, ele cria
um texto com o nome da classe mais um cdigo hexadecimal que cada instncia possui
diferente de outra, chamado hash code ( como um RG daquela instncia).
Ento, se tivssemos a classe TV dentro do pacote primebean e usssemos o
comando: System.out.println (tv1.toString()). O que apareceria no console seria algo
como: primebean.TV@c17124. Ento o que faremos para melhorar ser usar o
polimorfismo para sobrescrever o mtodo toString(), colocando o texto da forma que
desejarmos.
package primebean;
public class TV {
private String marca;
private String modelo;
private int canal;
private int volume;
public TV(String marca, String modelo, int tamanho) {
this.marca = marca;
this.modelo = modelo;
this.canal = 1;
this.volume = 0;
}
// mtodos getters e setters
public String toString() {
return "TV" +
"\nMarca: " + this.marca +
112
"\nModelo: " + this.modelo +

"\nTamanho: " + this.tamanho;
}
TV tv1 = new TV("Marca1", "SDX-22", 29);
System.out.println(tv1.toString());
}
}
Agora, o resultado da linha System.out.println (tv1.toString()) no ser mais:
primebean.TV@c17124
Agora, ser: TV
Marca: Marca1
Modelo: SDX-22
Tamanho: 29
possvel que dependendo do seu JRE e compilador seja necessrio o uso da
annotation @override antes de sobrescrever o mtodo toString();
22. Typecast - Casting

Quando lidamos com linguagens de programao fortemente tipadas como Java,
nos confrontamos muitas vezes com a necessidade de variar de um tipo de dado para
outro. H casos, tambm, em que at mesmo o compilador no compreende que tipo de
dado estamos atribuindo a uma varivel.
Em Java, ns podemos fazer uso do que chamamos de induo de tipo, typecast
ou ate mesmo casting. O typecast dita ao compilador como tal dado deve ser interpretado
113
e manipulado. Essa induo de tipo ou typecast pode ser implcita ou explcita.

O typecast implcito feito automaticamente pelo compilador quando um tipo de
dado pode ser facilmente manipulado no lugar de outro tipo de dado. O typecast explcito
feito diretamente no algortmo para indicar ao compilador qual a forma de interpretao
de um dado quando ele entende que h ambiguidade ou formatos incompatveis.
O typecast explcito dado sempre dentro de parnteses que sempre vem antes
do dado a ser induzido. Ex.: (int) var1, (float) var2, (Object) var3,
22.1. Typecast de Dados Primitivos

O typecast de dados primitivos dado basicamente em questo de seu consumo
de memria. Se tentamos designar um tipo de dado que consome menos memria para
um que consome mais memria, o typecast realizado implicitamente. No exemplo
abaixo, atribumos um dado inteiro (varInt) a uma varivel do tipo float (varFloat).
public class ExemploTypecast1 {
float varFloat;
int varInt;
varInt = 200;
varFloat = varInt;
System.out.println(varFloat);
}
}
O contrrio no se aplica. Tentar atribuir um tipo de dado maior para um tipo de
dado menor ir resultar em um erro de tipos incompatveis (type mismatch). Para
demonstrar isso, usaremos dois tipos de dados inteiros. Porm, iremos atribuir um inteiro
longo (que consome mais memria) a um dado inteiro que consome menos. Nesse caso,
114
somos obrigados a usar typecast explcito.

long varLong;
int varInt;
varLong = 200;
varInt = (int) varLong;
System.out.println(varInt);
}
}
22.2. Typecast de Classes e Objetos

Typecast tambm pode ser usado em Classes e Objetos. Sempre e uma classe for
genrica, ela poder receber qualquer tipo de objeto que ser feito o typecast
implicitamente. Por exemplo, vamos utilizar a classe TV que vinhamos criando at agora.
package primebean;
public class TV {
int tamanho;
int canal;
int volume;
boolean ligada;
this.canal = canal;
}
}
115
Agora, vamos instanciar uma varivel da classe genrica Object com a classe TV.
package primebean;
Object obj = new TV(29, 1, 0, false);
System.out.println("A varivel obj "
+ obj.getClass());
}
}
Como podemos perceber, o resultado de getClass da varivel obj no sua classe
original (Object), mas sua instncia: class primebean.TV. Agora, no ser possvel criar
uma cpia desse objeto para uma varivel do mesmo tipo de sua instncia. Neste caso,
devemos fazer o typecast explcito da classe.
package primebean;
TV tv = (TV) obj;
TV tv2 = new TV(29, 1, 0, false);
System.out.println("A varivel tv cpia de obj" +
"\nobj: " + obj.toString() +
"\ntv: " + tv.toString());
System.out.println("TV2 outro objeto: " + tv2.toString());
}
}
O resultado do cdigo acima seria algo como:
A varivel tv cpia de obj
obj: primebean.TV@12345f
116
tv: primebean.TV@12345f
TV2 outro objeto: primebean.TV@abcde1
23. Instanceof
No exemplo anterior, se tentssemos atribuir obj diretamente a tv ocorreria um erro
de tipos incompatveis (type mismatch). Quando lidamos com classes, podemos testar
qual seu tipo de instancia usando o operador instanceof. Instanceof indica se um objeto
(j instanciado) pertence a uma classe.
O uso de instanceof : objeto instanceof nomeDaClasse. Para melhorar o exemplo
anterior, usaremos instanceof antes de atribuirmos obj a tv.
package primebean;
public class ExemploTypecast {
TV tv = null;
if (obj instanceof TV) {
tv = (TV) obj;
}
TV tv2 = new TV(29, 1, 0, false);
System.out.println("A varivel tv cpia de obj" +
"\nobj: " + obj.toString() +
"\ntv: " + tv.toString());
System.out.println("TV2 outro objeto: " + tv2.toString());
}
}
117
24. Generics
No artigo anterior de Java, vimos como usar typecast e instanceof. Aqui, veremos
uma pequena introduo de Generics ou programao genrica, na qual ser muito
importante quando formos tratar de classes e interfaces de coleo como, por exemplo, a
classe Vector.
Generics, ou programao genrica, serve para determinar para o compilador, qual
tipo de classe deve ser interpretada. Por exemplo, vamos imaginar que ser criada uma
classe chamada Aparelho que ir conter um objeto de alguma outra classe.
Para que essa classe possa aceitar qualquer tipo de classe, devemos fazer uso de
generics. Generics indicado como um identificador entre os sinais de maior e menor
(<>).
24.1.Criando classes usando generics
Para criar uma classe usando generics, basta que logo aps o nome da classe
coloquemos o indicador genrico. Esse indicador genrico simplesmente uma letra na
qual ser substituda dentro da classe no momento da execuo.
package primebean;
public class Aparelho <T> {
T objeto;
public Aparelho(T objeto) {
this.objeto = objeto;
}
public T getObjeto() {
118
return objeto;
}
public void setObjeto(T objeto) {
this.objeto = objeto;
}
}
Como a letra T identifica um tipo genrico, ela ser substituda por qualquer classe.
Vamos imaginar agora que temos duas classes distintas. A classe TV:
package primebean;
public class TV {
int tamanho;
int canal;
int volume;
boolean ligada;
this.canal = canal;
}
//mtodos get e set
}
E a classe Radio:
package primebean;
public class Radio {
public static int AM = 1;
public static int FM = 2;
private float frequencia;
private int volume;
119
private int banda;

public Radio(float frequencia, int volume, int banda) {
this.frequencia = frequencia;
this.banda = banda;
}
// mtodos get e set
}
24.2. Instanciar uma classe genrica

Se fossemos criar um programa que usa as duas classes de aparelhos acima,
faramos:
package primebean;
public class MinhaClasse {
Aparelho<TV> aparelho1 = new Aparelho<TV>(new TV(29, 0, 0, false));
Aparelho<Radio> aparelho2 = new Aparelho<Radio>(new Radio(88.1f, 0,
Radio.FM));
System.out.println(aparelho1.getObjeto().getClass());
System.out.println(aparelho2.getObjeto().getClass());
}
}
Perceba o seguinte: sem o uso de generics, o compilador no conseguiria saber
qual a diferena entre aparelho1 e aparelho2, pois ele os trataria da mesma forma. Nesse
caso, seria obrigatrio o uso de typecast para determinar ao compilador que dado est
sendo processado.
Se pensarmos em uma aplicao muito grande, alm de ficar cansativo ter que
120
usar typecast toda vez que fossemos usar um aparelho, seria muito provvel que
erraramos em algum momento. Java usa uma pequena conveno de nomenclatura para
as letras de identificao de generics (que so vastamente utilizadas no Framework de
colees Java), sendo:
E - Elemento
K - Chave
N - Nmero
T - Tipo
V - Valor
Generics um assunto bastante extenso com vrios tpicos que podem ser
abordados, dentre os quais podemos citar:
Multiplos tipos genricos. Ex.: <T, E, N>;
Tipos genricos limitados. Ex.: <U extends Number>;
Wildcards;
e Subtipos;
O intuito desta apostila apenas introduzir um conceito geral de programao
genrica (generics) para compreenso de classes e mtodos que utilizam generics.
121
25. Excees
As excees so, na verdade, instncias de classes. E como qualquer classe ou
objeto, podemos facilmente manipular. Existem mtodos comuns entre todas as classes
de Excees, dentre as quais podemos citar:
toString(): Converte os dados da exceo para String para visualizao.
printStackTrace(): Imprime na sada de erro padro (geralmente console) todos os
frames de onde foram detectados erros. til para depurao no desenvolvimento, pois
mostra todo o histrico do erro, alm das linhas onde foram ocasionados.
getCause(): Retorna a causa da Exceo, ou null se a causa for desconhecida ou no
existir.
getMessage(): Retorna uma string com o erro. uma forma simples e elegante de
mostrar a exceo causada, geralmente, utilizada como forma de apresentao ao
usurio.
25.1. Try e Catch
Umas das utilidades proporcionadas pela orientao a objetos de Java a

facilidade em tratar possveis erros de execuo chamados de excees. Sempre que um
mtodo de alguma classe passvel de causar algum erro, ento, podemos usar o
mtodo de tentativa - o try.
Tudo que estiver dentro do bloco try ser executado at que alguma exceo seja
lanada, ou seja, at que algo d errado. Quando uma exceo lanada, ela sempre
deve ser capturada. O trabalho de captura da exceo executado pelo bloco catch.
122
Um bloco try pode possuir vrios blocos de catch, dependendo do nmero de

excees que podem ser lanadas por uma classe ou mtodo. O bloco catch obtm o erro
criando uma instncia da exceo. Portanto, a sintaxe do bloco try
catch :
try {
// cdigo a ser executado
} catch (ClasseDeExceo instnciaDaExceo) {
// tratamento da exceo
}
25.2. Finally
Finally o trecho de cdigo final. A funo bsica de finally sempre executar seu
bloco de dados mesmo que uma exceo seja lanada. muito til para liberar recursos
do sistema quando utilizamos, por exemplo, conexes de banco de dados e abertura de
buffer para leitura ou escrita de arquivos.
Finally vir aps os blocos de catch.
try {
// cdigo a ser executado
} catch (ClasseDeExceo instnciaDaExceo) {
// tratamento da exceo
} finally {
// cdigo a ser executado mesmo que uma exceo seja lanada
}
Abaixo est um exemplo de tratamento de erro ou exceo. Tentaremos atribuir
uma string de letras a um objeto inteiro. Como no possvel atribuir uma string de letras
a um objeto inteiro, uma exceo de formato de nmero lanada.
123
public class ExemploDeExcecao {

String var = "ABC";
try {
Integer i = new Integer(var);
System.out.println("A varivel i vale " + i);
} catch (NumberFormatException nfe) {
System.out.println("No possvel atribuir a string " + var
+ " a um Objeto Inteiro.\n"
+ "A seguinte mensagem foi retornada:\n\n"
+ nfe.getMessage());
}
}
}
O cdigo acima apresentar algo como:
No possvel atribuir a string ABC a um Objeto Inteiro. A seguinte mensagem foi
retornada:
For input string: "ABC"
Perceba que a linha System.out.println("A varivel i vale " + i) no foi executada,
pois houve um erro na linha anterior. Portanto, apenas a mensagem de tratamento do erro
NumberFormatException foi impressa na tela.
124
26. Classes Numricas

Estamos seguindo para, em breve, entrarmos nos tutoriais de programao usando
SWING e AWT, resumidamente, janelas. Mas antes, veremos classes que se tornaro de
extrema importncia para o uso da manipulao dos dados. Essas classes so as que
tem por base a classe abstrata Numbers e a classe String.
Em Java, alm de podermos utilizar os tipos primitivos de dados, tambm podemos
usufruir de classes completas para o tratamento desses tipos primitivos. Isso uma
grande vantagem quando mtodos necessitam ou retornam objetos ao invs de tipos
primitivos (o que muito comum com os objetos do pacote SWING e AWT).
Outra vantagem dessas classes que o prprio compilador capaz de extrair os
dados do objeto implicitamente e manipular seus dados como sendo simples dados
primitivos, num processo descrito como box e unbox (encaixotar e desencaixotar).
Por exemplo, se quisermos somar dois inteiros que esto dentro de dois objetos
inteiros, no precisaramos fazer nada de especial, a no ser som-los de fato, como se
fossem dados primitivos. Veja:
public class SomarIntegers {
Integer var1 = 25;
Integer var2 = 75;
int resultado = var1 + var2; // somando dois objetos
System.out.println(resultado);
}
}
A princpio, a classe abstrata Number nos proporciona um conjunto de mtodos
que, logicamente, so possveis acessar de qualquer classe numrica.
125
26.1. Obtendo Tipo Primitivo de um Objeto Numrico

Podemos utilizar os mtodos *Value para obter um tipo primitivo de qualquer objeto
numrico.
byteValue(): Obtm um valor primitivo byte.
shortValue(): Obtm um valor primitivo short (inteiro curto).
intValue(): Obtm um valor primitivo int (inteiro).
longValue(): Obtm um valor primitivo long (inteiro longo).
floatValue(): Obtm um valor primitivo float.
doubleValue(): Obtm um valor primitivo double.
Esses mtodos so timos para passar de um tipo de dado para o outro sem nos
preocuparmos com induo de tipo ou typecasting, pois a mudana feita diretamente
pelo objeto.
public class ConverterNumeros {
Byte meuByte = 5;
Integer meuInt = 12345;
Double meuDouble = 1234567.89;
byte doubleParaByte = meuDouble.byteValue();
int byteParaInteiro = meuByte.intValue();
double inteiroParaDouble = meuInt.doubleValue();
System.out.println("Byte: " + meuByte +
" - para int: " + byteParaInteiro +
"\nInteger: " + meuInt +
" - para double: " + inteiroParaDouble +
"\nDouble: " + meuDouble +
" - para byte: " + doubleParaByte);
}
}
126
26.2. Comparando Nmeros
Para comparao de nmeros, h dois mtodos: compareTo() e equals(). O mtodo

compareTo() compara o objeto com um outro objeto da mesma classe ou nmero de tipo
primitivo do mesmo tipo. Ele retorna 0 se o nmero comparado for igual, -1 se o nmero
for menor ou 1 se o nmero for maior.
Equals() funciona de forma semelhante. Ele indica se o nmero comparado igual
ao argumento deste mtodo, porm no diz se o argumento maior ou menor que o valor
do objeto. Outra diferena fica por conta de seu retorno que um valor booleano (true ou
false).
26.7. Classes Integer, Float, Short, Byte, Long e Double
Agora que temos a base de todas as classes numricas, iremos para a descrio
dos mtodos contidos nessas classes, que apesar de diferentes, mantem uma
similaridade muito grande.
26.7.1. Anlise de Dados

A anlise de dados consiste em tentar usar uma String que possa ser interpretada
como tal objeto numrico usando o comando parse*. Caso a String no possa ser
interpretada como um nmero, uma exceo (erro) lanada.
Byte.parseByte(): analisa uma String para tenta atribuir um dado do tipo primitivo byte.
Short.parseShort(): analisa uma String para tenta atribuir um dado do tipo primitivo short.
127
Integer.parseInt(): analisa uma String para tenta atribuir um dado do tipo primitivo inteiro.
Long.parseLong(): analisa uma String para tenta atribuir um dado do tipo inteiro primitivo
longo.
Float.parseFloat(): analisa uma String para tenta atribuir um dado do tipo primitivo float.
Double.parseDouble(): analisa uma String para tenta atribuir um dado do tipo primitivo
double.
Se quisermos que, ao invs de um tipo primitivo de nmero, seja retornado um
objeto, podemos trocar qualquer parse* por valueOf(). Em tipos inteiros, alm de
valueOf(), tambm podemos trocar parseInt, parseByte, parseShort e parseLong por
decode().
Importante: As classes que se baseiam em nmeros inteiros (Byte, Short, Long e Integer)
possuem um segundo argumento do tipo inteiro opcional nos mtodos parse* que indica a
base do nmero inteiro, fazendo com que dessa forma possa ser interpretado nmeros
Decimais (base 10), Binrios (base 2), Octais (base 8) e Hexadecimais (base 16). Decode
tambm pode fazer este tipo de interpretao, mas no necessrio um segundo
argumento desde que a String respeite algumas convenes:
No so aceitos espaos;
No so aceitos nmeros negativos;
Nmeros octais devem comear com um 0 (ex.: "0377", "0400", "0401");
Nmeros hexadecimais devem comear com 0x, 0X ou # (ex.: "0xFF", "0X100", "#101").
public class ParseEDecode {
String numero = "256";
128
// retorna um dado do tipo int (inteiro)

int tipoInteiro = Integer.parseInt(numero);
// retorna um objeto da classe Integer (inteiro)
Integer objetoInteiro = Integer.decode(numero);
System.out.println("tipoInteiro: " + tipoInteiro +
"\nobjetoInteiro: " + objetoInteiro);
}
}
26.7.2. Converso Para String

Para converter qualquer objeto numrico para uma String podemos fazer uso de
toString() como qualquer outra classe.
26.8. Classe Math

Vimos anteriormente como tratar nmeros de vrios tipos. Veremos agora, como
aplicar conceitos matemticos mais complexos a nossos processamentos usando a
classe Math do pacote Java.lang.
A classe Math nos proporciona uma srie de operaes e constantes matemticas
que so facilmente acessadas estaticamente, ou seja, no precisamos instanciar um
objeto para podermos usar seus mtodos.
Dentro desta classe encontramos vrios mtodos e categorizamos os mais
utilizados da seguinte forma:
129
Mximo e Mnimo;
Potncias e Razes;
Logaritmo;
Arredondamentos e Valores Absolutos;
Trigonometria;
Nmeros Randmicos.
26.8.1. Constantes
A classe Math possui duas constantes que so o (pi) e E (base de logaritmos

naturais
ou
neperianos)
cada
uma
com
valor
de
3,141592653589793
2.718281828459045, respectivamente.
Abaixo est um exemplo simples com o clculo do comprimento do crculo:
public class ComprimentoCirculo {
float raio = 2.4f;
double comprimento = 2 * raio * Math.PI;
System.out.println(comprimento);
}
}
130
26.8.2. Mximo e Mnimo

Como o ttulo j sugere, a classe Math de Java possui dois mtodos que retornam
o maior e o menor valor de seus argumentos. Esses mtodos so max() e min().
public class MenorMaior {
float precoProdutoA[] = { 11.2f, 15.12f };
float precoProdutoB[] = { 19.7f, 20 };
System.out.println("O maior preo do produto A "
+ Math.max(precoProdutoA[0], precoProdutoA[1]));
System.out.println("O menor preo do produto B "
+ Math.min(precoProdutoB[0], precoProdutoB[1]));
}
}
26.8.3. Potncias e razes

Podemos fazer clculos de potncia e razes com facilidade usando os mtodos
disponveis em Math.
pow (base, expoente) - calcula a potncia da base elevada ao expoente.
sqrt (nmero) - calcula a raz quadrada de um nmero
cbrt (nmero) - calcula a raiz cbica de um nmero
exp (expoente) - calcula o valor da constante de Euler (E) elevado ao expoente
public class PotenciasRaizes {
131
System.out.println("1 MB tem " + Math.pow(2, 10) + " KB");

System.out.println("A raiz quadrada de 121 " + Math.sqrt(121)
+ " e a raiz cbica de 1331 tambm " + Math.cbrt(1331));
}
}
26.8.4. Logaritmo
Na classe Math encontramos funes para clculo de logaritmo natual, na base de
10 e a soma do nmero mais 1. Tais mtodos so:
log (nmero) - logaritmo natural de um nmero.
log10 (nmero) - logaritmo natural de um nmero na base 10
log1p (nmero) - logaritmo natual de um nmero somado a 1. Esse mtodo retorna um
resultado mais confivel se o nmero em questo for muito prximo a 0 ou um nmero
fracionado. Ou seja, o resultado no o mesmo entre os mtodos log1p (0.1f) e log
(1+0.1f).
public class Exemplo {
float nr = 0.1f;
System.out.println("Resultado 1: " + Math.log(nr+1));
System.out.println("Resultado 2: " + Math.log1p(nr));
}
}
132
26.8.5. Arredondamentos e Valores Absolutos
Existem algumas formas de arredondar um nmero fracionado (float e double)

transformando-o em um nmero inteiro e tambm como obter o valor absoluto de
qualquer nmero.
abs (nmero) - retorna o valor absoluto do mesmo tipo do parmetro (ex.: inteiro retorna
int positivo, decimal retorna float positivo, etc)
ceil (decimal) - este mtodo retorna o valor decimal do parmetro sem a parte
fracionada. Ex.: 2.1 ser 2, 6.0 ser 6, 10.8 ser 10...
floor (decimal) - este mtodo retorna o primeiro inteiro aps o valor decimal. Ex.: 2.1 ser
3, 6.0 ser 6, 10.8 ser 11...
rint (decimal) - retorna um valor double mais prximo do valor do parmetro.
round (decimal) - retorna o arredondamento aritmtico do nmero decimal passado
como parmetro
float nr = -5.75f;
System.out.println("Absoluto: " + Math.abs(nr) +
"\nInteiro mais baixo: " + Math.ceil(nr) +
"\nInteiro mais alto: " + Math.floor(nr) +
"\nDouble mais prximo: " + Math.rint(nr) +
"\nArredondamento: " + Math.round(nr));
}
}
133
26.8.6. Trigonometria
A maior parte dos mtodos encontrados na classe Math so trigonomtricas, o que
ajuda muito em clculos mais complexos que envolvem figuras.
sin (graus) - este mtodo retorna o valor do seno de acordo com o nmero de
graus passado como parmetro.
cos (graus) - este mtodo retorna o valor do coseno de acordo com o nmero de
tan (graus) - este mtodo retorna o valor da tangente de acordo com o nmero de
asin (graus) - este mtodo retorna o valor do arco seno de acordo com o nmero
de graus passado como parmetro.
acos (graus) - este mtodo retorna o valor do arco coseno de acordo com o
nmero de graus passado como parmetro.
atan (graus) - este mtodo retorna o valor do arco tangente de acordo com o
sinh (graus) - este mtodo retorna o valor hiperblico do seno de acordo com o
cosh (graus) - este mtodo retorna o valor hiperblico do coseno de acordo com o
tanh (graus) - este mtodo retorna o valor hiperblico da tangente de acordo com o
hypot (x , y) - retorna o valor da hipotenusa, ou, basicamente, a distncia entre dois

pontos fundamentada na frmula x2+y2 [sqrt (pow(x, 2) + pow(y,2))].
toRadians (graus) - retorna um valor aproximado de radianos de acordo com o
134
ngulomedido em graus.
toDegrees (raio) - retorna um valor aproximado de graus de acordo com o ngulo

medido em raios.
public class Hipotenusa {

double ponto1 = 30;
double ponto2 = 40;
System.out.println("A distancia entre o "
+ ponto1 + " e o " + ponto2 + " "
+ Math.hypot(ponto1, ponto2));
}
}
26.8.7. Nmeros Randmicos

Os nmeros randmicos so obtidos usando o mtodo random(). O mtodo
random() retorna um valor double em 0.0 e 1.0. Para conseguirmos um valor limite ou um
alcance (comumente chamado de range) delimitado, devemos fazer pequenas operaes
matemticas.
Essas operaes so simples e podem ser resumidas da seguinte maneira.
O limite inferior, ou valor inicial (start value) ser sempre somado ao nmero
randmico.
O limite superior, ou alcance (range) ser sempre o limite superior subtrado o

limite inferior e depois multiplicado ao nmero randmico.
Por exemplo, se quisermos que um nmero randmico sempre fique entre 5 e 10,
procederamos da seguinte maneira:
O menor nmero possvel 5, portanto ele ser nosso start value ou limite inferior.
135
O maior nmero possvel 10, ento 10 ser nosso limite superior.
Como temos ambos os limites (inferior e superior) devemos criar um alcance (range).
Para obtermos isso, subtrairemos o limite superior com o limite inferior (10-5=5).
int limiteInferior = 5;
int limiteSuperior = 10;
int alcance = limiteSuperior - limiteInferior;
double nrRandomico = Math.random();
System.out.println("O nmero randmico escolhido entre 5 e 10 foi "
+ Math.round(limiteInferior + nrRandomico * alcance));
}
}
27. String
Strings so utilizadas frequentemente em vrias linguagens de programao, no
apenas Java. Embora Strings sejam uma sequncia de caracteres em Java, e no um
array de caracteres.
Em Java, o importante entender que string no um tipo de dado, mas sim uma
classe. E suas variveis so, na verdade, objetos dessa classe. Em sntese, tanto um
array de caracteres como uma string se apresentam da mesma forma. Ento, qual a
vantagem de se usar uma classe e no um array de tipo primitivo?
A resposta se baseia exatamente no uso da orientao a objetos e no fato de que
existem muitos mtodos que podemos utilizar em um objeto instanciado da classe String,
mesmo sendo os objetos desta classe imutveis, ou seja, uma vez instanciados no
podemos mudar o que est guardado dentro do objeto String.
136
Dentre as possibilidades oferecidas pela classe String podemos destacar algumas como:
Concatenao;
Tamanho da String;
Converter para maisculas ou minsculas;
Fazer comparaes que incluem verificaes no incio e no fim;
Extrair um carcter especfico da string;
Achar um ndice da string, inclusive recursivamente (de trs para frente);
Substituir uma parte da string ou ela completamente;
Verificar se uma string contm outra;
Dividir uma string em array ou vetor;
Obter uma poro da string inteira, o que chamamos de substring.

Objetos Strings podem ser instanciadas usando um array de caracteres ou bytes
com o operador new. Ou por meio de uma string literal. String literal qualquer sequncia
de caracteres que estiver entre aspas (").
public class ExemploCriarString {
char[] charArray = { 'T', 'I', ' ', 'E', 'x', 'p', 'e', 'r', 't'};
/* construindo uma string a partir de um array de char */
String string1 = new String(charArray);
/* construindo uma string a partir de uma string literal */
String string2 = "www.primebean.com.br";
System.out.println(string1);
System.out.println(string2);
}
}
137
27.1. Concatenao de Strings

Concatenao nada mais do que juntar strings numa s. Isto pode ser feito de
duas formas:
A primeira utilizando o mtodo concat() da classe String ou usando o sinal de
adio (+) como operador de concatenao. O mtodo concat() retorna uma nova string
formada da juno da string principal com a string indicada como parmetro.
De uma forma mais simples, podemos usar o + para juntar vrias strings ao mesmo
tempo.
27.2. Tamanho da string - length()

A classe String possui um mtodo acessor que retorna o tamanho da String. Esse
mtodo length().
public class TamanhoString {
String str = "primebean";
System.out.println(str + " possui " + str.length() + " caracteres.");
}
}
138
24.3. Letras Maisculas e Minsculas

Podemos facilmente deixar todas as letras de uma sequncia de caracteres
maiscula
ou
minscula
usando
os
mtodos
toUpperCase()
toLowerCase()
respectivamente.
public class StringMaiusculoMinusculo {

String email = "MeuNoMe@MEUDominiO.coM.bR";
String hexadecimal = "#aa33ff";
System.out.println(email.toLowerCase());
System.out.println(hexadecimal.toUpperCase());
}
}
24.4. Comparao
H vrias formas de se fazer comparaes com uma string, mas vale sempre
lembrar que Java case sensitive - diferencia letras maiscula de minsculas e
vice-versa. Embora haja mtodos prprios para comparaes em que no h importncia
em diferenciar letras maisculas e minsculas.
A comparao mais simples usando o prprio operador de igualdade (==), mas
por se tratar de um objeto prefervel que se use o mtodo especfico chamado equals().
O mtodo equals() compara o objeto string com outro objeto, se ambos possurem
contedos iguais, ento, retornado verdadeiro (true), caso contrrio falso (false). Isso
quer dizer que se, por exemplo, tiver um objeto da classe Integer que vale 15 e uma string
contendo os caracteres 1 e 5, a comparao de ambos resultar em verdadeiro.
A funo equals() case sensitive, para fazer uma comparao ignorando esta
139
caracterstica basta usar o mtodo equalsIgnoreCase().

public class ComparacaoIgualdadeString {
String string1 = "PRIMEBEAN";
String string2 = "primebean";
System.out.println("So iguais? (case sensitive)");
System.out.println(string1.equals(string2) ? "sim" : "no");
System.out.println("So iguais? (sem case sensitive)");
System.out.println(string1.equalsIgnoreCase(string2) ? "sim" : "no");
}
}
H tambm uma forma de comparar strings lexicograficamente. Dessa forma,
podemos verificar se uma string idntica (quando retorna-se 0), ou se ela tem um valor
menor (quando retorna-se um nmero abaixo de 0) ou se ela tem um valor maior (quando
retorna-se um nmero acima de 0). O mtodo para fazer tais comparaes o
compareTo() (case sensitive) ou compareToIgnoreCase() (sem case sensitive).
public class ComparacaoString {
String string1 = "PRIMEBEAN";
int comparacao = string1.compareTo(string2);
System.out.println("Comparao entre string1 e string2 (sensitive case)");
if (comparacao > 0) {
System.out.println("string1 lexicograficamente maior que string2");
} else if (comparacao < 0) {
System.out.println("string1 lexicograficamente menor que string2");
} else {
System.out.println("string1 lexicograficamente igual a string2");
}
}
}
140
24.5. Incio e fim

Outra forma de fazer comparaes fazer testes no incio e no fim de uma string.
Podemos fazer tais comparaes usando dois mtodos: startsWith() e endsWith().
StartsWith() verifica se h uma string no comeo de outra string. StartsWith()
tambm possui um segundo parmetro opcional que determina a compensao inicial, ou
seja, caso necessite verificar a string no da posio 0, mas de uma posio mais
adiante.
EndsWith() verifica se h uma string no final de outra string. Diferentemente de
startsWith(), o mtodo endsWith() no possui compensao.
public class InicioFim {
String string1 = "http://www.primebean.com.br";
System.out.println("A string " + string1 + " :");
// verifica se h 'http:' no inicio da string
if (string1.startsWith("http:")) {
System.out.println("uma URL");
}
/*
* verifica se h 'www' no incio da string, mas apenas a partir do
* 8o. caracter, ou seja, aps o prefixo 'http://', portanto dever
* ser compensado 7 caracteres
*/
if (string1.startsWith("www", 7)) {
System.out.println("uma pgina da web");
}
if (string1.endsWith(".br")) {
System.out.println("um site registrado no Brasil");
} else {
System.out.println("no um site registrado no Brasil");
}
}
}
141
24.6. Caracter na posio

Podemos tambm obter um caracter que se encontra em alguma posio dentro da
string. Para isso, usaremos o mtodo charAt(). CharAt() recebe um inteiro como
argumento que indica a posio que queremos da string.
Importante: Strings seguem o mesmo conceito de vetores e arrays, portanto, seu
primeiro caracter no est na posio 1, mas na posio 0.
public class ExtrairCaracter {
char caracter = string1.charAt(3);
System.out.println("O 4o. caracter desta string " + caracter);
}
}
24.7. ndice da String

A classe string possui uma forma de encontrar o ndice da primeira ocorrncia de
uma string dentro de outra string. O mtodo indexOf() retorna um nmero inteiro que
indica exatamente em que posio ocorre uma string de busca, ou retorna um valor
menor que 0 caso no encontre o valor requisitado.
Assim como startsWith(), indexOf() tambm possui um segundo argumento que
determina a compensao a ser feita caso a busca no possa ser feita desde a posio 0,
mas de uma posio posterior. Alm do mtodo indexOf(), h tambm o mtodo
lastIndexOf() que faz a mesma coisa que indexOf(), porm de forma recursiva (de trs
para frente ou do fim da string para o comeo).
142
public class IndiceString {

String string1 = "www.primebean.com.br";
int posicao;
posicao = string1.indexOf("primebean");
if (posicao >= 0) {
System.out.println("A string primebean comea na posio " + posicao);
} else {
System.out.println("No h primebean na string");
}
posicao = string1.lastIndexOf(".com");
if (posicao >= 0) {
System.out.println("A string .com comea na posio " + posicao);
} else {
System.out.println("No h .com na string");
}
}
}
24.8. Substituir string ou parte dela

Podemos substituir todas as ocorrncias de uma string por uma nova string
resultando em uma nova string de retorno. Para executarmos esta operao usamos o
mtodo replace() que tem dois parmetros: o primeiro ser o que desejamos procurar
dentro da string e o segundo a string que colocaremos no lugar da antiga.
Nota: replace tambm funciona com o tipo primitivo char.
public class SubstituirString {
143
String string1 = "http://primebean.com.br";

System.out.println(string1.replace("http://", "www."));
}
}
24.9. Verificar contedo da string

Um mtodo muito til para verificar o contedo de uma string o contains().
Contains() retorna verdadeiro (true) se houver a sequncia de caracteres especificada no
parmetro.
public class VerificarConteudo {
String string1 = "http://www.primebean.com.br";
System.out.println(" uma pgina da web?");
System.out.println(string1.contains("www.") ? "sim" : "no");
}
}
24.10. Dividindo em vrios vetores ou arrays

Tambm possvel dividir uma string em um vetor ou array de strings, o que
possibilita trabalhar com pedaos menores e mais lgicos da string. Para dividir a string
podemos usar o mtodo split().
O mtodo split usa uma expresso regular para fazer a diviso. Para simplificar o
entendimento, podemos usar como parmetro uma outra string como base. Mas vale
atentar no fato de que a expresso utilizada para ser feita a quebra desaparece no fim do
processo. Ex.: Se minha string for 15:30:00, se utilizarmos os dois pontos (:) para a
144
separao conseguiremos um array com 3 posies que seriam: [0]->15, [1]->30, [2]->00.
String string1 = "15:30:00";
String[] stringDividida = string1.split(":");
for (int i = 0; i < stringDividida.length; i++) {
System.out.println("stringDividida[" + i + "]=" +
stringDividida[i]);
}
}
}
24.11. Substring
Substring uma poro ou parte da string principal da qual pode formar outra
string, ou seja, uma substring uma string formada a partir de uma string principal.
Para obtermos uma substring usamos um mtodo homnimo (de mesmo nome)
com um ou dois parmetros.
O primeiro parmetro, obrigatrio, a posio que a substring deve iniciar
(lembrando-se que strings sempre comeam da posio 0). O segundo parmetro,
opcional, a posio final da substring, caso este parmetro no seja indicado, a
substring sempre ir at o ltimo carcter encontrado.
Nota: O carcter na posio inicial far parte da substring, porm o carcter na posio
final no faz parte da substring. Vejamos o exemplo: Se tivermos uma string de 9
caracteres, portanto, de 0 a 8 posies, se fizermos a substring da seguinte forma:
stringOriginal.substring(5,8);
145
O resultado ser BEA. Ento, se quisermos que a 8a posio entre, devemos usar
a posio seguinte 9, assim: stringOriginal.substring(3,9);
public class ExemploSubstring {
String url = "www.primebean.com.br";
String dominio = url.substring(4);
String site = url.substring(url.indexOf('.') + 1,url.lastIndexOf('.'));
System.out.println("Anlise da string:");
System.out.println("Domnio: " + dominio);
System.out.println("Site: " + site);
}
}
25. Manipulando datas em Java

Para quem est comeando, trabalhar com datas em Java pode ser um pouco
complicado, j que a classe Date no fornece todos os recursos necessrios. Para
complet-la tambm utilizada a classe Calendar, que uma classe abstrata que permite
a manipulao de datas de forma mais fcil.
146
25.1. Date(java.util.Date)
A classe Date armazena uma data e hora, que internamente armazenada com
um inteiro long que o numero de milissegundos que se passou desde 01/01/1970. Esta
classe bem simples de se trabalhar, mas muitos de seus mtodos foram depreciados
por no trabalhar muito bem com internacionalizao e etc.
Date d = new Date();
25.2. Calendar(java.util.Calendar)
A classe Calendar sendo uma classe abstrata no pode ser instanciada com o
operador new, ela deve ser criada utilizando um operador esttico sobrecarregado
getInstance().
Na
maioria
das
vezes
voc
vai
receber
uma
instncia
de
Java.util.GregorianCalendar.
Calendar c = Calendar.getIntance();
Com a instncia de Calendar devemos configurar uma data e podemos fazer isso
de duas formas:
Mtodos set
c.set(ano,mes,dia);
c.set(ano,ms,dia,hora,minuto);
c.set(ano,ms,dia,hora,minuto,segundo);
Mtodo setTime
c.setTime(new Date() );
147
A classe Calendar tambm nos fornece vrias constantes que utilizaremos para
manipular uma data entre elas. Com a data devidamente configurada podemos realizar
diversas operaes com a data:
Para adicionar ou subtrair um dia, hora, ms ou ano utilizamos o mtodo add. O
mtodo add aceita dois parmetros, sendo o primeiro um constante inteira que representa
a unidade da data que queremos modificar(dia, ms , ano, etc) e o segundo quantas
vezes ser adicionada/subtrada esta unidade. A unidade informada utilizando
constantes fornecidas pela classe Calendar que pode ser:
Dia:
Calendar.DAY_OF_MONTH
Calendar.DAY_OF_WEEK
Calendar.DAY_OF_YEAR
Ms:
Calendar.MONTH
Ano:
Calendar.YEAR
Hora:
Calendar.HOUR
Calendar.HOUR_OF_DAY
148
Segundos:
Calendar.SECOND
Veja o Exemplo abaixo:

Date d= new Date();
Calendar c = Calendar.getInstance();
c.add(Calendar.DAY_OF_YEAR,5 );//adicionamos 5 dias a data aual
c.add(Calendar.MONTH,3 );//adicionamos 3 mses a data atual
c.add(Calendar.YEAR,1 );//adicionamos 1 ano a data atual
25.3. DateFormat(java.text.DateFormat)
Bom agora sabemos como manipula datas, agora precisamos formatar a data para
apresentao. A classe DateFormat nos fornece uma maneira simples de format-la e
permite a internacionalizao a partir da classe Locale.
Calendar c = Calendar.getInstance();
c.setTime(d);
DateFormat df = DateFormat.getDateInstance(DateFormat.SHORT);
System.out.println( df.format(c.getTime()) );
Para obtermos uma String da data utilizamos o mtodo format que retorna uma
String no formato especificado no mtodo getDateInstance(). A sada do exemplo acima
ser algo como 03/04/14. A classe DateForma nos fornece vrios tipos de formato para
data como:
149
Dateformat.SHORT // 03/04/14
Dateformat.MEDIUM // 03/04/2014
Dateformat.LONG //3 de Abril de 2014
Dateformat.FULL //Quarta-feira, 3 de Abril de 2014
Embora para muitos casos estes formatos sero suficientes algumas vezes
necessitamos de uma formato vem personalizado. Isso pode ser feio atravs de um
subclasse de DateFormat a SimpleDateFormat..
Date hoje = new Date();
SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy HH:mm:ss");
System.out.println( sdf.format(hoje));
O construtor de SimpleDateFormat recebe uma String que representa o formato da
data. Os smbolos utilizados para cada campo da data pode ser visto na tabela abaixo
abaixo:
Smbolo
Significado
Apresentao
Exemplo
era designator
(Text)
AD
Year
(Number)
2014
Month in year
(Text & Number)
April & 04
Day in month
(Number)
14
Hour in am/pm (1 ~ 12)
(Number)
12
Hour in day (0 ~ 23 )
(Number)
Minute in hour
(Number)
30
Second in minute
(Number)
55
milisecond
(Number)
978
Day in week
(Text)
Tuesday
Day in year
(Number)
189
Day in week in month
(Number)
2(2nd Wed in July)
Week in year
(Number)
27
Week in month
(Number)
150
Am/pm marker
(Text)
PM
Hour in day (1 ~ 24)
(Number)
24
Hour in am/pm (0 ~ 11)
(Number)
Time zone
(Text)
Pacif Standard Time
Como vimos o dia da semana pode ser escrito por extenso, que lngua ele ser
utilizada? Normalmente o ingls, mas se quisermos que seja na lngua de um local
diferente?
Para isso utilizaremos a internacionalizao com a classe Locate que recebe em
seu construtor a lngua e o pas que queremos utilizar:
Locale brasil = new Locale("pt","br");//portugues do brasil
Locale japao = new Locale("ja");// japao
O objeto locale de Locale pode ser utilizado tanto com a classe DateFormat quanto
com a classe SimpleDateFormat.
Date hoje = new Date();
SimpleDateFormat sdf = new SimpleDateFormat("E dd ",new Locale("pt","br"));
System.out.println( sdf.format(hoje));
DateFormat df = DateFormat.getDateInstance(DateFormat.FULL,new Locale("pt","br"));
System.out.println( df.format(hoje));
Para finalizar como covertermos uma String em um objeto Date
SimpleDateFormat df = new SimpleDateFormat("DD/MM/yyyy");
try {
d = df.parse("25/03/2010");
} catch (ParseException ex) {
ex.printStackTrace();
151
}
System.out.println( df.format(d));
O mtdo parse da classe DateFormat e recebe uma string e convertepara um objeto Date
26. Uma Introduo API Swing

Aps apresentarmos os conceitos estruturais principais de linguagem, a idia de
orientao a objeto e as classes que mais utilizaremos como String e Numbers,
passaremos agora a focar uma programao mais voltada a prticas possveis,
demonstrando classes com funes mais avanadas e importantes, alm de
abandonarmos um pouco o visual de console e partirmos para a programao visual de
Java.
26.1. JoptionPane
Para introduzir esta nova fase, iniciaremos descrevendo um pouco sobre
JOptionPane do pacote visual Swing. A classe JOptionPane nos proporciona uma srie de
mtodos estticos que ao serem invocados criam caixas de dilogos simples e objetivas.
Para
usar
JOptionPane
javax.swing.JoptionPane primeiro.
temos
sempre
que
importar
pacote
152
26.2. Caixas de Dilogo Input Text

As caixas de dilogo de entrada de texto ou Input Text Dialog servem para fazer
uma requisio de algum dado ao usurio de forma bem simples e direta. O que
digitado pelo usurio retornado pelo mtodo em forma de string.
Existem mais de 10 mtodos sobrecarregados para invocar uma caixa de dilogo
Input Text, mas, a princpio, usaremos a mais simples. O mtodo showInputText recebe
um argumento que a string contendo a informao desejada, o que na maioria das
vezes uma pergunta ou pedido. O exemplo abaixo demonstra um programa pedindo
para que digite seu nome.
public class CaixasDeDialogo {
JOptionPane.showInputDialog("Qual o seu nome?");
}
}
Ser apresentada uma janela a seguir.
153
26.3. Caixas de Dilogo Confirm

Outra caixa de dilogo simples e objetiva do JOptionPane a caixa de dilogo de
confirmao ou Confirm Dialog.
A Confirm Dialog (caixa de confirmao) consiste de uma caixa contendo uma
mensagem, um cone e trs botes: sim, no e cancelar.
Apesar deste ser o aspecto padro, esta caixa, como qualquer outra de
JOptionPane, pode ser facilmente configurada (assunto que ser tratado com mais
detalhes nas prximas pginas).
No mtodo padro chamado showConfirmDialog usamos dois argumentos:
1. O primeiro a dependncia ou frame pai, ou seja, de qual janela esta confirmao est
sendo gerada. Como nossos exemplos iniciais no possuem nenhuma dependncia,
ento, sempre usaremos null neste argumento.
2. O segundo argumento a mensagem que desejamos mostrar ao usurio. O
mtodo showConfirmDialog sempre retorna uma constante que a resposta clicada pelo
usurio, que so:
Valor
Nome da Constante
Equivale
YES_OPTION
ao clicar no boto Yes (sim)
NO_OPTION
ao clicar no boto No (no)
CANCEL_OPTION
ao clicar no boto Cancel (cancelar)
Melhorando o exemplo anterior ficaria assim.

154

String nome = null;
nome = JOptionPane.showInputDialog("Qual o seu nome?");
JOptionPane.showConfirmDialog(null, "O seu nome " + nome + "?");
}
}
A caixa de confirmao pareceria da seguinte forma:
26.4. Caixa de Dilogo de Mensagem
A caixa de dilogo de mensagem uma caixa que serve apenas para emitir uma
mensagem. Esta caixa tambm muito configurvel e verstil, pois serve para muitas
situaes distintas como uma mensagem de erro, um alerta, ou simplesmente uma
informao.
O mtodo showMessageDialog responsvel em trazer a caixa de mensagem, o
qual pode ter muitos argumentos, porm, vamos nos ater ao mais simples. Assim como o
mtodo showConfirmDialog, usaremos null como valor de nosso primeiro argumento,
pois, por enquanto, no h dependncia de outras janelas em nosso programa.
O segundo argumento a mensagem que desejamos emitir. Para finalizar nosso
exemplo, incluiremos as caixas de mensagem de acordo com as respostas.
155
String nome = null;
int resposta;
resposta = JOptionPane.showConfirmDialog(null, "O seu nome " + nome +
"?");
if (resposta == JOptionPane.YES_OPTION) {
// verifica se o usurio clicou no boto YES
JOptionPane.showMessageDialog(null, "Seu nome " + nome);
} else {
JOptionPane.showMessageDialog(null, "Seu nome no " + nome);
}
}
}
Abaixo est um exemplo de como ir ficar a caixa de mensagem caso clique no boto
YES.
156
26.5. Input Dialogs

Caixas de Entrada de Dados
Como foi introduzido anteriormente, em Java, podemos usufruir de classes e
objetos do pacote Swing, o qual facilita a criao de interface grfica sem a necessidade
de ficar horas programando.
Neste artigo, nos aprofundaremos no uso de JOptionPane, comeando a
personalizar algumas caixas de dilogo mais simples.
Caixas de dilogo de entrada de dados so importantes para obter informaes ou
requisitar algo do usurio. No objeto JOptionPane, h o mtodo showInputDialog() que
responsvel em criar uma caixa de dilogo requisitando uma entrada de dado. Este
mtodo sobrecarregado de vrias maneiras.
A forma mais simples de seus argumentos :
1. A mensagem que deve ser exibida para o usurio.
Com apenas este argumento possvel criar uma caixa de dilogo com o ttulo
Input, um cone de interrogao, uma caixa de texto, uma mensagem e dois botes. Igual
a figura abaixo:
Porm,
como
alterarmos
aparncia
dessa
completamente. Outra forma utilizar dois argumentos, sendo:
caixa,
customizando-a
157
1. A mensagem que deve ser exibida ao usurio.

2. O valor inicial da caixa de texto.
O valor inicial da caixa de texto a string que deve aparecer dentro do campo onde
digitamos nossa entrada. Assim que aparece a caixa, seu campo est preenchido com um
valor inicial j selecionado.
Ex.: O cdigo JOptionPane.showInputDialog("Qual o seu nome?", "Digite seu nome
aqui.")
geraria a seguinte caixa:
Uma das formas mais completas desse mtodo inclui alterar, inclusive, o ttulo da
caixa. Assim, usa-se 4 argumentos:
1. De qual frame a caixa de dilogo dependente, ou seja, qual a janela principal
que chamou a caixa Input Dialog. Caso a caixa de dilogo no dependa de nenhum frame
ou janela principal, basta utilizarmos o valor null para este argumento.
3. O ttulo da caixa de texto.
4. Que tipo de mensagem . O tipo de mensagem define qual o cone ser
utilizado, podendo ser utilizados os nmeros inteiros representados pelas constantes:
158
PLAIN_MESSAGE (valor: -1): Mensagem limpa, sem nenhum cone.

ERROR_MESSAGE (valor: 0): Mensagem de erro.
INFORMATION_MESSAGE (valor: 1): Mensagem informativa.
WARNING_MESSAGE (valor: 2): Mensagem de alerta.
QUESTION_MESSAGE (valor: 3): Mensagem de requisio ou pergunta. Esta a
opo padro do mtodo showInputDialog().
Ex.: O cdigo JOptionPane.showInputDialog(null, "Qual o seu Nome?", "Pergunta",
JOptionPane.PLAIN_MESSAGE)
geraria a seguinte caixa:
26.5.1. Obter valor de showInputDialog

O mtodo showInputDialog pode retornar dois valores: ou uma string ou null. Se o
boto OK for clicado a string contida na caixa de texto ser retornada, se o boto Cancel
for clicado o valor null ser retornado. Sabendo disso, podemos usar uma varivel string
para obter o valor e tratarmos da forma que quisermos. Vejamos o exemplo abaixo:
public class CaixasDeInput {
159

String nome = null;
while (nome == null || nome.equals("")) {
if (nome == null || nome.equals("")) {
JoptionPane.showMessageDialog(null, "Voc no respondeu a pergunta.");
}
}
JOptionPane.showMessageDialog(null, "Seu nome " + nome);
}
}
26.5.2. Input Dialog com lista de opes
Outra forma de caixa de dilogo de entrada de dados a Input Dialog com lista de
opes. o mesmo mtodo showInputDialog, mas com mais argumentos, sendo um
deles uma lista de objetos. Esta lista de objetos far com que a caixa de dilogo venha
com um combo box ao invs de um campo de texto.
Para criar um Input Dialog com um combo box devemos usar os seguintes
argumentos na respectiva ordem:
1. De qual frame a caixa de dilogo dependente, ou seja, qual a janela principal
que chamou a caixa Input Dialog. Caso a caixa de dilogo no dependa de nenhum frame
ou janela principal, basta utilizarmos o valor null para este argumento.
3. O ttulo da caixa de texto.
4. Que tipo de mensagem . O tipo de mensagem define qual o cone ser
utilizado, podendo ser utilizados os nmeros inteiros representados pelas constantes da
160
mesma forma como foi mostrada anteriormente.

5. O quinto argumento representado pelo objeto Icon, que um cone que
podemos criar a partir de um jpg, gif, png, etc.
6. O segredo do combo box est neste argumento. Aqui vir um array (vetor) de
objetos que sero nossos valores pr-definidos.
7. O ltimo argumento serve apenas para indicar qual elemento do array (vetor)
deve vir selecionado no incio. Caso no desejarmos que um tem seja selecionado no
incio basta utilizarmos null.
O array (vetor) de objetos deve ser genrico, portanto, utilizamos a classe Object
para criar este array. O mtodo showInputDialog com combo box se diferencia do
showInputDialog com caixa de texto pelo seguinte fato: o que retornado dessa vez no
ser uma string, mas um objeto.
Isso faz sentido se percebermos que agora estamos escolhendo um item dentro de
uma lista de objetos. Portanto, o que ser retornado ser um objeto dessa lista, no uma
string como acontecia com o Input Dialog com caixa de texto.
Ento, se quisermos utilizar o objeto genrico como algum outro tipo de dado,
devemos antes fazer uma induo de tipo ou typecasting.
Vejamos o exemplo abaixo:
public class CaixaComComboBox {
Object[] opcoes = { "sim", "no" };
Object resposta;
do {
resposta = JoptionPane.showInputDialog(null,
"Deseja finalizar o programa?",
161
"Finalizao",
JoptionPane.PLAIN_MESSAGE,
null, opcoes, "no");
} while (resposta == null || resposta.equals("no"));
}
}
No exemplo acima, criamos uma lista com dois objetos: "sim" e "no". E j
definimos "no" como opo pr-selecionada. Removemos qualquer cone com as opes
PLAIN_MESSAGE e cone null.
Criamos um lao (loop) com while que sempre ir repetir a mesma caixa enquanto
o boto Cancel ou a opo "no" forem selecionados. Abaixo est um exemplo mais
funcional, divertido e simples de fazer e entender.
Trata-se de um jogo de adivinhar onde um nmero escolhido e temos que
adivinhar qual nmero foi sorteado. No exemplo, sero usados elementos j estudados no
site como a classe Math e Integer.
public class JogoDeAdivinhar {
// define um nmero qualquer entre 0 e 10
int rndNr = (int) Math.ceil(Math.random() * 10);
// lista de opes para o combo box da caixa de dilogo
Object[] opcoes = { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9","10" };
// string onde ser retornado o resultado
String resposta;
while (true) {
// loop para evitar que o jogo feche depois da primeira resposta
resposta = (String) JOptionPane.showInputDialog(null,
"Em que nmero estou pensando?",
"Jogo de Advinhar",
JoptionPane.QUESTION_MESSAGE,
null, opcoes, null);
162
if (resposta == null) {
/*
* se clicar no boto Cancel, mostrar uma mensagem de Game Over
* e sair do loop para finalizar o programa
*/
JOptionPane.showMessageDialog(null,
"Game Over!\nVoc desistiu do jogo!");
break;
}
if (Integer.valueOf(resposta) > rndNr) {
/*
* Interpreta string como inteiro e compara com o nmero sorteado
* para ver se maior
*/
"Errado!\nO nmero que eu pensei menor.");
} else if (Integer.valueOf(resposta) < rndNr) {
/*
* Interpreta string como inteiro e compara com o nmero sorteado
* para ver se maior
*/
"Errado!\nO nmero que eu pensei maior.");
} else {
/*
* se no for nem maior e nem menor, ento igual.
* Finaliza o jogo saindo do loop
*/
"Parabns\nVoc adivinhou!\n"
+ "Eu realmente pensei no nmero " + rndNr);
break;
}
}
}
}

Apostila Introducao A Linguagem Java

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Apostila Introducao A Linguagem Java

Uploaded by

Copyright:

Available Formats

Introduo Linguagem de Programao JAVA

Introduo Linguagem de Programao JAVA

Introduo Linguagem de Programao Java

O Contedo desta apostila foi elaborada atravs de

Introduo Linguagem de Programao JAVA

Introduo Linguagem de Programao JAVA

3.16. Operadores e Processos........................................................................................................31

Introduo Linguagem de Programao JAVA

11. Instanciando Objetos....................................................................................................................76

Introduo Linguagem de Programao JAVA

26.8.3. Potncias e razes........................................................................................................130

Introduo Linguagem de Programao JAVA

Introduo Linguagem de Programao JAVA

O *7 tinha a habilidade de controlar diversos dispositivos e aplicaes. James

Introduo Linguagem de Programao JAVA

computao. Em 2003 Java atingiu a marca de 4 milhes de desenvolvedores em todo

1.4. Principais Caractersticas da Linguagem Java

Introduo Linguagem de Programao JAVA

Sintaxe similar a Linguagem C/C++.

1.5. Mquina Virtual Java

tempo esta foi uma afirmao verdadeira.

Porm novos avanos tm tornado o compilador dinmico (a

casos, mais eficiente que o compilador esttico.

compilao especulativa, que aproveita o tempo ocioso do

Introduo Linguagem de Programao JAVA

Introduo Linguagem de Programao JAVA

Introduo Linguagem de Programao JAVA

JOGL (A low level API for 3D graphics programming, using OpenGL)

1.8. Ambientes de desenvolvimento

Introduo Linguagem de Programao JAVA

JBuilder um ambiente desenvolvido pela empresa Borland;

Introduo Linguagem de Programao JAVA

essa certificao pode trazer so:

1.12. O que necessrio para programar em JAVA

Introduo Linguagem de Programao JAVA

Para comear a programar ser necessrio fazer o download do JDK (Java

Eclipse uma IDE de cdigo aberto desenvolvido inicialmente

JBuilder uma IDE para desenvolvimento de aplicaes mais

JEdit um Ambiente de Desenvolvimento Integrado criado pela

IDE desenvolvido pela Oracle. Cobre todo processo de produo

Introduo Linguagem de Programao JAVA

O compilador que faz parte da prpria gama de produtos da Sun

Ento, mos obra, instale um compilador e comece seu projeto.

2. Desenvolvendo o Primeiro Programa em Java

Introduo Linguagem de Programao JAVA

qual /* inicia o comentrio e */ termina.

2.1. public class MeuPrimeiroPrograma

2.2. public static void main

Introduo Linguagem de Programao JAVA

2.3. (String[ ] args)

2.4. Inicio e Fim { }

2.6. ("Bem vindo ao mundo Java!")

Introduo Linguagem de Programao JAVA

Bem, isso o necessrio para comearmos a programar em Java. Logicamente,

3. Regras e convenes de nomenclatura

Introduo Linguagem de Programao JAVA

3.1. Nome de Classes

3.2. Nome de Pacotes

Introduo Linguagem de Programao JAVA

3.3. Criando Pacotes

Introduo Linguagem de Programao JAVA

3.4. Definindo Pacotes

3.5. Importando Pacotes