Tópicos Especiais de Programação Orientada A Objetos

Tpicos Especiais de
Programao Orientada a
Objetos
Autores: Prof. Jos Cassiano Grassi Gunji
Prof. Salatiel Luz Marinho
Prof. Luciano Soares de Souza
Professores conteudistas: Jos Cassiano Grassi Gunji / Salatiel Luz Marinho /
Luciano Soares de Souza
Jos Cassiano Grassi Gunji Luciano Soares de Souza
mestre em Tecnologia da Informao Aplicada pelo Mestre em Engenharia de Produo pela Universidade
Centro Estadual de Educao Tecnolgica Paula Souza e Paulista (UNIP) e bacharel em Cincia da Computao pela
bacharel em Sistemas de Informao pela Universidade mesma universidade.
Presbiteriana Mackenzie.
coordenador do Curso Superior de Tecnologia em
Atua como docente em cursos de graduao em Anlise e Desenvolvimento de Sistemas da UNIP, nas
Tecnologia da Informao, lecionando em disciplinas como modalidades presencial e EaD, leciona no curso as disciplinas
Programao Orientada a Objetos em Diversas Linguagens, Engenharia de Software, Projeto de Interface com o Usurio,
Anlise de Sistemas, Lgica de Programao entre outras. Princpios de Sistemas de Informao entre outras, e orienta
o Projeto Integrado Multidisciplinar PIM.
Salatiel Luz Marinho
Na Universidade Paulista tambm atua como Gerente
Psgraduado em Gesto de Projetos pelo Instituto de Integrao de Sistemas. Possui mais de 20 anos de
Brasileiro de Tecnologia Avanada (IBTA) e formado em experincia com Tecnologia da Informao, atuando nas
Engenharia da Computao pela Universidade Paulista reas de desenvolvimento de sistemas, engenharia de
(UNIP), trabalha h mais de dez anos no desenvolvimento de software, interao humanocomputador e automao
aplicaes desktop e web, tendo prestado servios a instituies industrial. Como professor e coordenador possui mais de
financeiras, de varejo e de seguros e a instituies acadmicas. oito anos de experincia.
Leciona h mais de oito anos as disciplinas de

programao orientada a objetos na UNIP.
Dados Internacionais de Catalogao na Publicao (CIP)
G975t Gunji, Jos Cassiano Grassi.
Tpicos especiais de programao orientada a objetos. / Jos

Cassiano Grassi Gunji, Salatiel Luz Marinho, Luciano Soares de Souza.
So Paulo: Editora Sol, 2015.
128 p., il.
Nota: este volume est publicado nos Cadernos de Estudos e

Pesquisas da UNIP, Srie Didtica, ano XXI, n. 2-167/15, ISSN 1517-9230.
11. Interfaces grficas. 2. Linguagem JAVA. 3. Programao

ANDROID. I. Marinho, Salatiel Luz. II. Souza, Luciano Soares de. II.Ttulo.
CDU 681.3.062
Todos os direitos reservados. Nenhuma parte desta obra pode ser reproduzida ou transmitida por qualquer forma e/ou
quaisquer meios (eletrnico, incluindo fotocpia e gravao) ou arquivada em qualquer sistema ou banco de dados sem
permisso escrita da Universidade Paulista.
Prof. Dr. Joo Carlos Di Genio
Reitor
Prof. Fbio Romeu de Carvalho

Vice-Reitor de Planejamento, Administrao e Finanas
Profa. Melnia Dalla Torre

Vice-Reitora de Unidades Universitrias
Prof. Dr. Yugo Okida

Vice-Reitor de Ps-Graduao e Pesquisa
Profa. Dra. Marlia Ancona-Lopez

Vice-Reitora de Graduao
Unip Interativa EaD
Profa. Elisabete Brihy

Prof. Marcelo Souza
Prof. Dr. Luiz Felipe Scabar
Prof. Ivan Daliberto Frugoli
Material Didtico EaD
Comisso editorial:
Dra. Anglica L. Carlini (UNIP)
Dra. Divane Alves da Silva (UNIP)
Dr. Ivan Dias da Motta (CESUMAR)
Dra. Ktia Mosorov Alonso (UFMT)
Dra. Valria de Carvalho (UNIP)
Apoio:
Profa. Cludia Regina Baptista EaD
Profa. Betisa Malaman Comisso de Qualificao e Avaliao de Cursos
Projeto grfico:
Prof. Alexandre Ponzetto
Reviso:
Marcilia Brito
Rose Castilho
Virgnia Bilatto
Sumrio
Tpicos Especiais de Programao
Orientada a Objetos
APRESENTAO.......................................................................................................................................................9
INTRODUO............................................................................................................................................................9
Unidade I
1 INTRODUO AO JAVA.................................................................................................................................. 11
1.1 Um breve histrico............................................................................................................................... 11
1.2 Arquitetura de um programa em Java......................................................................................... 12
1.3 Caractersticas da linguagem Java................................................................................................. 14
1.3.1 Simplicidade............................................................................................................................................... 14
1.3.2 Orientao a objetos.............................................................................................................................. 14
1.3.3 Multithread................................................................................................................................................ 14
1.3.4 Robustez...................................................................................................................................................... 14
1.3.5 Segurana................................................................................................................................................... 15
1.4 O que necessrio para se programar em Java....................................................................... 15
1.4.1 Instalando o JDK Java SE...................................................................................................................... 17
1.4.2 Instalando o Eclipse................................................................................................................................ 18
2 A LINGUAGEM JAVA....................................................................................................................................... 18
2.1 Entrada e sada de dados usando JOptionPane........................................................................ 25
2.2 Recomendaes de estilo................................................................................................................... 29
2.3 Tipos primitivos...................................................................................................................................... 30
2.4 Converso de tipos............................................................................................................................... 31
2.5 Classes wrapper (invlucro).............................................................................................................. 34
2.6 Introduo a classes e objetos......................................................................................................... 37
2.7 Instrues de controle......................................................................................................................... 40
2.8 Arrays......................................................................................................................................................... 47
2.9 Colees.................................................................................................................................................... 49
2.10 Tratamento de excees................................................................................................................... 50
Unidade II
3 PROGRAMAO ORIENTADA A OBJETOS............................................................................................... 56
3.1 Sobrecarga............................................................................................................................................... 56
3.2 Herana..................................................................................................................................................... 58
3.3 Sobrescrita................................................................................................................................................ 59
3.4 Polimorfismo........................................................................................................................................... 60
3.5 Modificadores de acesso.................................................................................................................... 62
3.6 Escopo........................................................................................................................................................ 63
3.7 Classes abstratas e interfaces........................................................................................................... 65
4 INTERFACES GRFICAS.................................................................................................................................. 70
Unidade III
5 INTRODUO AO ANDROID......................................................................................................................... 79
5.1 Fundamentos e paradigmas de programao para dispositivos mveis........................ 79
5.1.1 Dispositivos mveis................................................................................................................................. 80
5.1.2 Desafios tcnicos para dispositivos mveis.................................................................................. 80
5.1.3 Usabilidade e os dispositivos mveis............................................................................................... 80
5.1.4 Aplicaes mveis................................................................................................................................... 81
5.2 Android...................................................................................................................................................... 82
5.3 Open Handset Alliance........................................................................................................................ 83
5.4 Verses do Android............................................................................................................................... 84
5.5 Arquitetura do Android....................................................................................................................... 85
5.5.1 Linux Kernel................................................................................................................................................ 86
5.5.2 Libraries e Android Runtime................................................................................................................ 87
5.5.3 Application Framework......................................................................................................................... 88
5.5.4 Applications............................................................................................................................................... 89
6 CONCEITOS FUNDAMENTAIS....................................................................................................................... 89
6.1 Construindo o ambiente de desenvolvimento.......................................................................... 89
6.2 Instalando o Android Development Kit (Android SDK).......................................................... 89
6.3 Instalando o Android Development Tools (ADT)....................................................................... 90
Unidade IV
7 PROGRAMAO ANDROID.......................................................................................................................... 94
7.1 Criando um projeto do Android...................................................................................................... 94
7.2 Executar o projeto................................................................................................................................. 95
7.3 O arquivo AndroidManifest.xml...................................................................................................... 98
7.4 Efetuando debug no aplicativo.....................................................................................................100
7.5 Activities.................................................................................................................................................100
7.6 Views........................................................................................................................................................101
7.7 Mtodo setContentView()................................................................................................................101
7.8 Criar uma Activity...............................................................................................................................101
8 INTERFACES GRFICAS................................................................................................................................104
8.1 TextView..................................................................................................................................................106
8.2 EditText....................................................................................................................................................107
8.3 CheckBox................................................................................................................................................108
8.4 RadioButton..........................................................................................................................................110
8.5 ImageView..............................................................................................................................................110
8.6 Button......................................................................................................................................................111
8.7 DatePicker..............................................................................................................................................112
8.8 TimePicker..............................................................................................................................................113
8.9 Layouts....................................................................................................................................................114
8.9.1 Linear layout............................................................................................................................................114
8.9.2 Table layout..............................................................................................................................................115
8.10 Intent.....................................................................................................................................................116
8.11 Broadcast Receivers..........................................................................................................................117
8.12 Services.................................................................................................................................................117
8.13 Persistncia de dados......................................................................................................................119
APRESENTAO
Este livro tem como finalidade apresentar um roteiro de estudos com exemplos prticos, visando
preparar o aluno para desenvolver programas de computador utilizando a tecnologia Java.
Todo o contedo desta obra foi desenvolvido de maneira a permitir que o aluno construa seu
conhecimento a respeito da tecnologia Java de maneira gradativa. Por isso, para se entender as
ltimas partes do livro, o aluno deve ter passado por todas as partes anteriores, de modo a acumular
conhecimento suficiente para compreender os assuntos desenvolvidos.
No necessrio conhecimento anterior de Java para acompanhar essa obra. Entretanto, assumese
que o aluno j esteja familiarizado com os conceitos de Lgica de Programao, assim como de Anlise
de Sistemas Orientados a Objetos.
Inicialmente, veremos os conceitos relacionados tecnologia de programao Java e como essa

tecnologia se situa com relao s demais tecnologias em uso atualmente. Um pouco da histria do
desenvolvimento do Java tambm ser apresentada.
Abordaremos de maneira prtica a programao usando a linguagem Java. Faremos breves revises
sobre os conceitos da Lgica de Programao e Orientao a Objetos aplicadas ao Java.
Tambm sero apresentados os recursos do Java para o desenvolvimento de interfaces grficas com
o usurio.
Em seguida, sero apresentados os conceitos relacionados computao mvel e ao ambiente de

programao para dispositivos mveis que utilizam o sistema operacional Android.
Bons estudos!
INTRODUO
O conhecimento tecnolgico dos homens propiciou a criao de diversos mecanismos capazes de

realizar tarefas. H sculos existem aparelhos mecnicos capazes de realizar tarefas dos mais diversos
nveis de complexidade. Por exemplo, existiram teares capazes de tecer padres complexos em tecidos
de maneira automtica, mquinas capazes de realizar clculos matemticos e at mesmo codificar e
decodificar mensagens de rdio. A tecnologia desses mecanismos podia ser mecnica, eltrica e, mais
recentemente, eletrnica. Algo que estes dispositivos tinham em comum era algum mtodo pelo qual
eles poderiam ser programados.
Com o desenvolvimento da tecnologia e com o surgimento dos computadores digitais, foram

desenvolvidas linguagens de programao que poderiam ser interpretadas diretamente por esses
computadores: as linguagens de mquina. Entretanto, linguagens de mquina so de difcil entendimento
para pessoas e, por isso, logo comearam a ser desenvolvidas linguagens de alto nvel.
9
Uma linguagem de alto nvel um cdigo com o qual se pode expressar algoritmos usando um
vocabulrio e uma sintaxe semelhante ao vocabulrio e sintaxe da linguagem humana (quase sempre
em ingls). Esse cdigo escrito em linguagem de alto nvel pode ser, ento, traduzido (compilado) para
a linguagem de mquina do computador em que ele ser executado.
nesse contexto que surge a linguagem de programao Java. Seus desenvolvedores estipularam
uma meta arrojada: criar uma linguagem de programao multiplataforma. Isso significa que um cdigo
de computador escrito em Java, depois de compilado, poderia ser executado por qualquer computador,
executando qualquer sistema operacional que oferecesse suporte ao Java, sem a necessidade de
recompilar o cdigofonte. Como o Java realiza esta tarefa o que veremos neste livrotexto. Tambm
veremos como desenvolver aplicativos usando Java, tanto para computadores desktop quanto para
dispositivos mveis que executem o sistema operacional Android.
10
TPICOS ESPECIAIS DE PROGRAMAO ORIENTADA A OBJETOS
Unidade I
1 INTRODUO AO JAVA
Os computadores modernos, independentemente da arquitetura ou fabricante, apenas conseguem

executar programas escritos em sua prpria linguagem de mquina. Uma linguagem de mquina uma
sequncia de nmeros escritos na base 16, tambm conhecida como nmeros hexadecimais. Um trecho
de um programa em linguagem de mquina apresenta a aparncia da figura a seguir.
CD 20 FF 9F 00 9A F0 FE1D F0 4F 03 F0 07 8A 03
F0 07 17 03 F0 07 DF 0701 01 01 00 02 FF FF FF
FF FF FF FF FF FF FF FFFF FF FF FF BD 0D 4C 01
D0 0C 14 00 18 00 3D 0EFF FF FF FF 00 00 00 00
05 00 00 00 00 00 00 0000 00 00 00 00 00 00 00
CD 21 CB 00 00 00 00 0000 00 00 00 00 20 20 20
20 20 20 20 20 20 20 2000 00 00 00 00 20 20 20
20 20 20 20 20 20 20 2000 00 00 00 00 00 00 00
00 0D 76 2E 65 78 65 0D44 4F 57 53 5C 73 79 73
74 65 6D 33 32 5C 64 6F73 78 0D 0D 64 61 20 72
65 64 65 20 28 63 61 7272 65 67 61 72 20 61 6E
74 65 73 20 64 6F 20 646F 73 78 2E 65 78 65 29
Figura 1 Exemplo de um cdigo de computador em hexadecimal
Por razes bvias, muito difcil para um programador escrever um programa usando linguagem
de mquina. Para resolver este problema, logo comearam a ser desenvolvidas diversas linguagens de
computador de alto nvel, ou seja, linguagens que permitem que se escreva algoritmos usando palavras
com um vocabulrio e uma sintaxe semelhante ao vocabulrio e sintaxe da linguagem humana, sendo
que quase todas usam a lngua inglesa.
Muitas linguagens nunca atingiram grande aceitao. Outras chegaram a ser usadas com frequncia,
mas acabaram caindo em desuso. Hoje em dia h um punhado de linguagens que permanecem bastante
populares. Alguns exemplos so o COBOL, o C++ e o C# (DEITEL; DEITEL, 2005; 2010). As linguagens de
sucesso sempre apresentam algo que as diferencia das demais, trazendo alguma vantagem com relao
s outras. O Java um desses casos de sucesso. Vejamos a seguir como se deu o desenvolvimento do Java.
1.1 Um breve histrico
A histria da criao do Java descrita por diversos autores, como Horstmann e Cornell (2010),
Deitel e Deitel (2005; 2010), Jorge (2004), entre outros.
11
Unidade I
A Sun Microsystems, em 1991, financiou um projeto de pesquisa corporativa interna com o codinome
Green, que resultou no desenvolvimento de uma linguagem baseada em C++ que seu criador, James
Gosling, chamou de Oak. Descobriuse mais tarde que j havia uma linguagem de programao com
este nome. Uma equipe da Sun, em uma visita a uma cafeteria local, que servia caf cuja origem era da
ilha de Java na Indonsia, sugeriu esse nome e ele acabou pegando.
O projeto passou por dificuldades e quase foi cancelado. Mas em 1993 a World Wide Web explodiu
em popularidade e a equipe da Sun viu um grande potencial para utilizar o Java para adicionar contedo
dinmico, como interatividade e animaes, s pginas da Web, o que deu nova vida ao projeto.
O Java foi anunciado formalmente em 1995, ganhando muito interesse da comunidade do World
Wide Web. Atualmente, o Java popular no desenvolvimento de software para diversos aplicativos,
como aplicativos corporativos de grande porte, aplicativos governamentais, no aprimoramento da
funcionalidade de servidores Web, assim como aplicativos para o consumo popular em microcomputadores
pessoais e dispositivos mveis.
Saiba mais
Est disponvel (em ingls) uma linha do tempo detalhada do

desenvolvimento do Java desde sua concepo at o momento atual:
<http://oracle.com.edgesuite.net/timeline/java/>.
1.2 Arquitetura de um programa em Java
Um dos aspectos mais marcantes do Java e que esteve presente desde sua concepo o fato
de essa linguagem ser multiplataforma. Plataforma o conjunto formado por um computador e o
sistema operacional instalado nesse computador. Podemos, ento, ter as seguintes plataformas:
Computador padro PCIntel executando Windows.
Computador padro PCIntel executando Linux.
Computador padro iMac executando Mac OS.
Computador padro workstation executando Solaris.
Dizer que o Java multiplataforma significa dizer que um programa feito em Java e compilado em
uma determinada plataforma poder ser executado nessa plataforma e tambm em todas as demais
plataformas que do suporte ao Java.
12
Observao
Diversas linguagens, como o C++, por exemplo, esto disponveis para

diversas plataformas. Entretanto, um cdigo escrito em C++ que seja
compilado em uma determinada plataforma s poder ser executado nesta
mesma plataforma. Para que o cdigo seja executado em outra plataforma,
ele dever ser compilado novamente, mas, dessa vez, na plataforma em que
se deseja executar o cdigo.
Como possvel que um programa compilado em Java em uma determinada plataforma possa ser
executado em outras plataformas?
Lembrete
Um computador s consegue executar programas que estejam escritos

em linguagem de mquina. Quando um programa escrito em uma
linguagem de alto nvel, o cdigo deste programa deve ser compilado
(traduzido) para a linguagem de mquina da plataforma que ir executar
o programa.
O Java realiza esta faanha porque ele no compilado diretamente para a linguagem de mquina
de uma plataforma especfica. Em vez disso, ele compilado para uma linguagem de mquina de
um computador fictcio, uma mquina virtual. Para que o programa possa ser, ento, executado, um
computador deve utilizar um emulador desse computador fictcio, que interpreta o cdigo compilado
Java. Em outras palavras: um programa em Java semicompilado, o que significa que o cdigofonte
compilado para uma linguagem intermediria, conhecida como bytecode. O bytecode um cdigo de
computador escrito em linguagem de mquina da Mquina Virtual Java (Java Virtual Machine JVM).
A Mquina Virtual Java, ento, interpreta o bytecode e executa o programa.
Cdigofonte Compilador Bytecode Mquina Programa em

Java Virtual Java execuo
Figura 2 Processo de compilao e execuo de um programa em Java
Com esta estrutura, um programa compilado em Java pode ser executado diretamente em qualquer
sistema que possua uma Mquina Virtual Java.
13
Unidade I
1.3 Caractersticas da linguagem Java
Mendes (2009) sumariza algumas das principais caractersticas do Java, caractersticas estas que
justificam a grande penetrao da tecnologia no mercado. Resumidamente temos:
1.3.1 Simplicidade
A linguagem Java considerada simples porque permite que o programador crie sistemas para
diferentes plataformas sem se preocupar com a arquitetura do hardware particular de cada uma delas.
O Java tambm no tenta reinventar a roda, criando uma nova sintaxe. Ele utiliza a sintaxe j bem
estabelecida da linguagem C. Alm disso, o Java no implementa alguns aspectos menos utilizados da
orientao a objetos, como a herana mltipla, a sobrecarga de operadores, os ponteiros e as operaes
aritmticas sobre os ponteiros.
1.3.2 Orientao a objetos
O paradigma orientado a objetos de anlise de sistemas (e de programao) traz uma nova maneira
de se pensar o desenvolvimento de sistemas. Essa nova maneira de se criar programas utiliza os conceitos
de herana, polimorfismo e encapsulamento. Tais conceitos incentivam boas prticas de programao,
como o reuso de cdigo e a padronizao, o que torna sistemas orientados a objetos mais fceis de
serem desenvolvidos, reutilizados, e faz com que apresentem manuteno mais rpida e barata.
1.3.3 Multithread
O Java uma linguagem que permite o multiprocessamento (multithreading). Isso significa

que partes de um mesmo programa podem ser executadas simultaneamente. Essa tcnica permite
o total aproveitamento de sistemas dotados de mltiplos processadores. Devese ressaltar que o
multiprocessamento traz benefcios tambm para programas executados em sistemas com apenas um
ncleo de processamento.
1.3.4 Robustez
A linguagem Java e sua arquitetura de compilao para um cdigo intermedirio (bytecode) otimizado
garantem que uma grande quantidade de erros comuns em outras linguagens no ocorra em Java, por
exemplo, cdigo no alcanvel e vazamentos de memria. Esse segundo tipo de erro, muito comum
em programas feitos em C++, ocorre quando o programador reserva um espao de memria de trabalho
para seu programa e esquece de liberlo aps seu uso. Com o tempo, estes espaos no liberados vo
se acumulando, tornando o sistema cada vez menos estvel, at que ele no possa mais ser utilizado.
Em Java, este tipo de erro extremamente improvvel, pois um mecanismo automatizado chamado de
garbage collector (coletor de lixo) garante que espaos de memria reservados pelo programa e que
no esto mais em uso sejam automaticamente liberados.
14
1.3.5 Segurana
A linguagem Java est preparada para ser utilizada em aplicaes corporativas de grande porte, com
arquitetura distribuda, situao em que a segurana de extrema importncia.
Saiba mais
Vrios livros que abordam a programao em Java apresentam a

histria do desenvolvimento da linguagem, assim como suas principais
caractersticas, dos quais destacamos:
MENDES, D. R. Programao Java com nfase em orientao a objetos.

So Paulo: Novatec, 2009.
1.4 O que necessrio para se programar em Java
O Java disponibilizado por seu atual desenvolvedor, a Oracle, em diversas distribuies. Algumas delas so:
Java Standard Edition (Java SE).
Java Enterprise Edition (Java EE).
Java Micro Edition (Java ME).
Java Card.
Java TV.
A mais importante distribuio a Java SE (Java Edio Padro). nessa distribuio que esto as
bibliotecas bsicas do Java e as principais ferramentas de desenvolvimento, como o compilador Java.
As demais distribuies so complementos ao Java SE que disponibilizam outras capacidades

linguagem. Por exemplo, o Java EE (Java Edio Corporativa) inclui bibliotecas e servidores capazes de
permitir a criao e operao de sistemas corporativos distribudos, o uso de persistncia automatizada
e a criao de pginas dinmicas de internet entre outras funcionalidades. O Java ME (Java Edio Micro)
oferece a base para a programao de dispositivos mveis, como celulares, PDAs, receptores de TV, TVs
inteligentes etc. No caso de dispositivos como TVs, DVDs e BluRays, h uma distribuio especfica, o
Java TV, que uma especializao do Java ME para estas aplicaes particulares.
Tendo o SDK Java SE (tambm conhecido como JDK Java Development Kit) instalado, j possvel
escrever programas usando algum editor de arquivos de texto e usando o compilador Java por meio de
linha de comando.
15
Unidade I
Saiba mais
Voc pode obter uma viso geral a respeito do Java, assim como
adquirilo, na pgina de seu desenvolvedor:
<http://www.oracle.com/technetwork/java/javase/overview/index.html>.
perfeitamente possvel criar sistemas complexos utilizando apenas editores de arquivos texto e o
compilador por linha de comando. Entretanto, essa no a nossa proposta.
Apesar do SDK Java SE ser suficiente para se programar em Java, a maioria dos estudantes e
programadores admitem que o uso de um Ambiente Integrado de Desenvolvimento (IDE Integrated
Development Environment) torna o trabalho do desenvolvedor mais fcil. Um IDE um sistema que
rene em um nico pacote diversas ferramentas como:
Editor de cdigofonte.
Gerenciador de arquivos.
Corretor de sintaxe.
Ferramenta de automao de compilao.
Ferramenta de automao de depurao.
Assim, mesmo sendo opcional, vamos adotar uma IDE para desenvolver os exemplos deste livrotexto.
Existem diversas IDEs disponveis, tanto de cdigo aberto quanto de cdigo proprietrio. Vrias delas podem
ser utilizadas, mas, para no gastarmos tempo discutindo as diferenas entre elas, vamos utilizar o Eclipse.
Observao
O Eclipse um IDE de cdigo aberto de grande popularidade. Outro

IDE bastante conhecido o NetBeans, mantido principalmente pela Oracle,
mesmo desenvolvedor do Java. H algumas diferenas entre ambos, mas
no possvel dizer se um melhor do que o outro. O que pode ser dito
que ambos so equivalentes, ou seja, tudo o que feito com um pode ser
feito com o outro.
Todos os cdigosfonte inseridos neste livrotexto podem ser executados

tanto na IDE Eclipse como na NetBeans.
16
Saiba mais
O Eclipse pode ser obtido da pgina de seu desenvolvedor:
<http://www.eclipse.org>.
O NetBeans pode ser obtido da pgina:
<https://netbeans.org>.
1.4.1 Instalando o JDK Java SE
V at o site de download do Java <http://www.oracle.com/technetwork/java/javase/downloads/index.

html>. Clique no link Java Platform (JDK). Marque sua aceitao do contrato de licena e escolha o JDK
apropriado para a plataforma que voc deseja utilizar para desenvolver os seus programas. O download do
arquivo de instalao do JDK deve iniciar. Inicie o arquivo de instalao e siga as instrues na tela.
Figura 3 Assistente de instalao do SDK Java SE
Lembrete
Para se desenvolver em qualquer tecnologia Java, a nica distribuio

obrigatria o Java SE. Este kit de desenvolvimento (SDK Software
Development Kit) a nica distribuio que contm o compilador Java.
Qualquer outra distribuio um acessrio que deve ser instalado junto ao
SDK Java SE.
17
Unidade I
1.4.2 Instalando o Eclipse
V at o site de download do Eclipse <http://www.eclipse.org/downloads/>. Selecione o download

para Eclipse IDE for Java Developers na verso correta para seu sistema operacional. Escolha um
site espelho para realizar o download (se estiver disponvel). Quando o download estiver completo,
descompacte o contedo do arquivo em alguma pasta fcil de lembrar. O Eclipse no possui arquivo de
instalao. Voc deve inicilo diretamente do local onde foi extrado.
Figura 4 O Eclipse deve ser iniciado a partir do local onde ele foi extrado
2 A LINGUAGEM JAVA
Vamos criar nosso primeiro programa, o famoso Ol mundo! Comece iniciando o Eclipse. Caso nunca
o tenha iniciado antes, ele deve apresentar uma pgina de boasvindas semelhante seguinte figura:
Figura 5 Seleo do workspace (pasta de trabalho)
18
Esta janela pede para que voc indique qual a pasta que deseja utilizar para guardar os seus
projetos Java. Utilize o local padro ou indique o local que deseja utilizar. Se marcar a check box, o
Eclipse no ir mais fazer esta pergunta ao inicilo.
A seguir, o Eclipse inicia. Novamente, caso seja a primeira vez que o esteja executando, ele deve
apresentar uma tela de boasvindas como na figura a seguir.
Figura 6 Pgina de boasvindas do Eclipse
Clique no cone Workbench para exibir a rea de trabalho.
Figura 7 rea de trabalho do Eclipse
19
Unidade I
Vamos criar um projeto. Clique no menu File New Java Project. O seguinte assistente surge:
Figura 8 Assistente de criao de projeto
Na caixa de texto Project name digite o nome do seu projeto, Ola mundo. Certifiquese de que na
rea JRE voc esteja usando alguma mquina virtual Java SE. Se por algum motivo a JRE padro em seu
computador no for um Java SE, selecione o primeiro boto de rdio e escolha uma verso J2SE ou Java
SE (qualquer verso dessas deve ser suficiente).
Observao
Em qualquer linguagem de programao, sempre recomendado no

utilizar caracteres acentuados ou especiais. Ainda possvel (mesmo que
incomum) que haja problemas tanto na compilao quanto na execuo de
cdigos que utilizem tais smbolos. A nica exceo quando escrevemos
algum texto em um String, por exemplo. Se desejamos escrever a mensagem
Ol mundo! na tela, podemos usar acentos e caracteres especiais.
20
Figura 9 Seleo de uma mquina virtual especfica
As demais opes no precisam ser modificadas. Voc j pode clicar no boto Finish. Nesse momento,
o Eclipse cria uma pasta chamada Ola mundo no local que voc indicou como pasta de trabalho.
Dentro dela sero armazenados seus cdigosfonte, classes compiladas, arquivos de configurao, entre
outros. Note que no Package Explorer (Explorador de Pacotes) agora h o seu projeto Ola mundo.
Clique no sinal esquerda do projeto para expandir sua estrutura interna.
21
Unidade I
Figura 10 Projeto com sua estrutura expandida
Agora vamos criar o arquivo onde ser escrito o cdigofonte do programa. Note que dentro do
projeto Ola mundo h uma pasta chamada src. Ela uma abreviao de source (fonte) e nela que
iremos colocar todos os cdigosfonte de um projeto. Com o boto direito do mouse, clique na pasta src
e selecione new package. Package (pacote) um conceito da orientao a objetos que permite que
o desenvolvedor agrupe suas classes em pacotes.
Figura 11 Criao do pacote
22
Na caixa para definir o nome do pacote, digite primeiroPrograma. Note que, em Java, nomes devem
ser compostos de apenas uma palavra. Clique em Finish.
Em linguagens que derivam do C, como o C++, C# e Java, os nomes de classes, variveis, mtodos,
atributos e demais elementos devem ter como nome um termo composto de uma nica palavra.
Recomendase que os nomes sejam sempre mnemnicos, ou seja, o prprio nome deve indicar
qual a natureza ou finalidade do elemento que ele batiza. Por exemplo, uma varivel no mnemnica
chamada xpto12 no d nenhuma indicao ao programador de sua finalidade. J, se ela for chamada
de contadorDeIteraes, sua finalidade se torna evidente.
Quando se utiliza mais de uma palavra como nome, recomendase que a primeira letra de cada palavra,
a partir da segunda palavra, seja escrita em maiscula. Esta notao conhecida como camel case.
Dentro do pacote primeiroPrograma vamos criar a classe OlaMundo. Clique com o boto direito
no pacote e selecione new Class.
Figura 12 Criao da classe OlaMundo
23
Unidade I
Na caixa para definir o nome da classe, digite o nome OlaMundo. Clique em Finish. Neste momento,
o Eclipse cria o arquivo OlaMundo.java e o exibe no editor. J se pode notar um pouco de cdigo escrito
no arquivo, a declarao do pacote e da classe. A seguir, basta escrever o cdigo do mtodo principal
main() como demonstrado a seguir:
Figura 13 Cdigo do programa OlaMundo
A seguir, para compilar e executar seu programa, clique no boto indicado pela primeira seta (ou
selecione o menu run run). O Eclipse ir executar o compilador Java sobre seu cdigo e executar o
programa compilado. A sada do console exibida na aba destacada pela segunda seta.
Observao
Caso a janela para o seu cdigo esteja pequena demais, voc pode dar um
duplo clique na aba da janela, o que faz com que ela seja maximizada. Para
voltar visualizao anterior, basta dar um duplo clique na aba novamente.
As abas tambm podem ser fechadas definitivamente, clicando no

smbolo X. Caso voc tenha fechado acidentalmente uma aba e no saiba
como fazer para que ela seja reapresentada, voc pode pedir ao Eclipse para
restaurar a configurao padro das janelas. Para tanto, chame o menu
Window Perspective Reset Perspective... e responda Yes quando lhe for
perguntado se quer realmente as janelas retornem configurao padro.
24
2.1 Entrada e sada de dados usando JOptionPane
No exemplo anterior, utilizamos um mtodo para criar uma sada de texto no console. Tambm
possvel receber dados do usurio pelo console. No entanto, deixaremos de lado esta forma de interao
homemmquina e priorizaremos, neste material, o uso de interfaces grficas.
Saiba mais
A Interao HomemMquina (IHC) uma disciplina extensa que trata de

diversos aspectos da interao entre pessoas e equipamentos tecnolgicos.
Para aprofundar seus conhecimentos a respeito desse assunto, leia:
ROGERS, Y.; SHARP, H.; PREECE, J. Design de interao: alm da interao

humanocomputador. 3. ed. Porto Alegre: Bookman, 2013.
BENYON, D. Interao humanocomputador. 2. ed. So Paulo: Pearson

Prentice Hall, 2011.
O Java nos oferece uma ferramenta pronta para criar caixas de dilogo que so um tipo especial
de janela em ambiente grfico. Elas servem para apresentar informaes e tambm para receber dados
do usurio. Essas funcionalidades esto disponveis na classe JOptionPane que est definida no pacote
javax.swing, como ilustrado na figura a seguir:
Figura 14 A classe JOptionPane dentro do pacote javax.swing
Na figura anterior, a classe JOptionPane representada em um diagrama de classes, tendo seus

atributos omitidos e apenas dois de seus mtodos representados. A classe est definida no pacote swing,
que por sua vez est definido no pacote javax.
25
Unidade I
Saiba mais
O uso do console como mecanismo de interao abordado

extensivamente pela maioria dos livros sobre Java. Alguns deles so:
HORSTMANN, C. S.; CORNELL, G. Core Java. 8. ed. So Paulo: Pearson

Prentice Hall, 2010.
JORGE, M. Java: passo a passo Lite. So Paulo: Pearson Education do

Brasil, 2004.
Observao
A UML (Unified Modeling Language Linguagem Unificada de

Modelagem) define diversos diagramas teis para a documentao,
modelagem, anlise e projeto de sistemas orientados a objetos. O diagrama
de classes, um dos mais importantes da UML, representa as classes de um
sistema em um retngulo dividido em trs partes. Na primeira, anotado
o nome da classe, na segunda, seus atributos e na terceira seus mtodos.
O mtodo showMessageDialog() permite a exibio de uma caixa de dilogo onde uma informao
exibida para o usurio. A sobrecarga mais simples desse mtodo :
Figura 15 Declarao do mtodo showMessageDialog()
Este mtodo requer dois parmetros: o primeiro, chamado pai, recebe um objeto que representa o
elemento grfico pai da caixa de mensagem. Esse elemento grfico costuma ser uma janela do aplicativo.
Entretanto, ainda no sabemos como criar qualquer elemento grfico, por isso, vamos utilizar a palavra
reservada null para indicar que a caixa de dilogo no ir possuir qualquer componente grfico como
pai. Isso tambm far com que a caixa de dilogo seja apresentada centralizada na tela. A palavra
reservada null indica um objeto que no foi instanciado, um objeto nulo. O segundo parmetro a
mensagem que ser apresentada dentro da caixa de dilogo.
Assim, em um programa, poderamos utilizar o mtodo showMessageDialog() da seguinte forma e

obter o resultado exibido a seguir:
26
Figura 16 Exemplo de uso do mtodo showMessageDialog()
O mtodo showInputDialog() permite criar uma caixa de dilogo que apresenta uma pergunta e
exibe um espao para que o usurio digite sua resposta. Quando o mtodo encerrado, ele retorna um
String contendo o texto digitado pelo usurio. A declarao de sua sobrecarga mais simples :
Figura 17 Declarao do mtodo showInputDialog()
Note que o mtodo showInputDialog() no requer a indicao de um componente pai. Entretanto,

se voc desejar, pode indicar um, mesmo que seja null. O trecho de cdigo a seguir mostra como podemos
usar esse mtodo para receber um texto do usurio. O texto digitado pelo usurio armazenado na
varivel resposta:
Figura 18 Exemplo de uso do mtodo showInputDialog()
No exemplo a seguir, mostraremos um programa inteiro que utiliza a classe JOptionPane para
realizar entrada e sada de dados usando as caixas de dilogo. Note que, para se utilizar esta classe,
necessrio importar a classe para que o programa possa utilizla. Isto feito com a palavra reservada
import, que deve ser inserida logo abaixo da palavra package.
27
Unidade I
Figura 19 Um programa que realiza entrada e sada de dados por meio de caixas de dilogo
Assumindose que, ao executar o programa demonstrado anteriormente, o usurio digite o nome

Maria, ele ir obter as seguintes mensagens:
Figura 20 Sada gerada pelo programa OlaMundoGrafico
Observao
O programa apresentado na figura 19 deve ser criado em um pacote

chamado unidadeUm. recomendado tambm que ele seja criado em um
novo projeto. A razo para isso que cada projeto deve ter apenas um
mtodo main(). Quando um projeto apresenta mais de um mtodo main(),
pode ser necessrio indicar ao Eclipse qual o mtodo main() ativo no
projeto. A maneira de se fazer isso varia dependendo da verso do Eclipse.
28
2.2 Recomendaes de estilo
Podemos dar nomes a diversos elementos de nossos programas, como variveis, atributos, mtodos,
parmetros etc.
Lembrete
Em Java e em linguagens orientadas a objeto, em geral, recomendase

o uso de nomes mnemnicos, ou seja, nomes que j indicam qual a
finalidade do elemento que ele batiza. Por exemplo, pode ser difcil saber
qual a finalidade de uma varivel chamada xpto12. Por outro lado, se
a mesma varivel receber o nome contadorDeIteracoes, sua finalidade
tornase bastante clara.
Para que se criem nomes mnemnicos, muitas vezes, desejamos usar mais de uma palavra. Mas um
nome deve ser uma nica palavra, sem espaos. A recomendao, neste caso, escrever todas as palavras
juntas, sem espao. Para se marcar a separao entre as palavras, a partir da segunda palavra, a primeira
letra deve ser grafada com letra maiscula. Esta notao conhecida como camel case. Exemplo:
contadorDeIteracoes.
respostaDoUsuario.
mediaFinal.
O Java recomenda que a primeira letra do nome seja maiscula caso o nome seja de uma classe ou
de uma interface. Exemplos:
OlaMundo.
ProgramaPrincipal.
String.
Observao
No confunda interface com interface grfica. A interface grfica

um recurso de entrada e sada de dados utilizando elementos grficos e
dispositivos de interao humana, como mouse e teclado. J a interface
um conceito de orientao a objetos que ser abordado mais adiante.
Uma interface pode ser entendida, resumidamente, como uma classe
sem atributos e que apenas declara as assinaturas dos mtodos, sem
implementar qualquer um deles.
29
Unidade I
A exceo ao camel case est na declarao de nomes de constantes. Constantes so atributos

cujo valor no pode ser alterado. O Java recomenda que constantes sejam escritas com todas as letras
maisculas, separando as palavras pelo smbolo do sublinhado. Exemplos:
NOTA_MINIMA.
TAMANHO_PADRAO.
PI.
CONSTANTE_GRAVITACIONAL.
2.3 Tipos primitivos
Tipos so a natureza dos dados que podem ser armazenados em uma varivel, um atributo, que
podem ser transferidos por um parmetro ou retorno de mtodo. Tipo primitivo o tipo de dado que
est definido na prpria linguagem Java. Por isso, esses tipos tm um excelente desempenho tanto em
economia de memria quanto em desempenho de processamento. Estes tipos so:
Quadro 1 Tipos primitivos em Java
Tipo Tamanho em bits Natureza Valores

Depende da JVM de
boolean cada plataforma Booleanos true ou false
char 16 Caractere alfanumrico \u0000 a \uffff (0 a 65535)

byte 8 128 a 127
short 16 32.768 a 32.767
Nmero inteiro
int 32 2.147.483.648 a 2.147.483.647
long 64 9223372036854775808 a 9223372036854775807
Intervalo negativo:
3,4028234663852886E+38 a 1,40129846432481707e45
float 32
Intervalo positivo:
Nmero em ponto 1,40129846432481707e45 a 3,4028234663852886E+38
flutuante Intervalo negativo:
1,7976931348623157E+308 a 4,94065645841246544e324
double 64
Intervalo positivo:
4,94065645841246544e324 a 1,7976931348623157E+308
Adaptado de: Deitel (2005).
Na figura a seguir, criamos algumas variveis e atribumos a elas valores definidos por literais, ou
seja, valores definidos no prprio cdigofonte:
30
Figura 21 Exemplos de declarao de variveis de tipos primitivos
Quando se define um literal numrico inteiro, ele tratado como sendo um inteiro. J quando se
define um literal numrico com um ponto decimal, ele tratado como um double. Para se definir um
literal caractere, ele deve ser circundado por aspas simples. Um literal booleano s pode assumir os
valores representados pelas palavras reservadas true ou false.
Quando se deseja definir um literal inteiro maior do que a capacidade de representao do int,
devese indicar que o literal um long, adicionandose o sufixo L ou l. Analogamente, ao se representar
um literal como um float, devese adicionar o sufixo F ou f:
Figura 22 Literais de tipo long e float
2.4 Converso de tipos
Quando se trabalha com mais de um tipo primitivo, podemos atribuir o valor armazenado em uma
varivel de tipo de menor capacidade em uma varivel de maior capacidade. De certa forma, podemos
entender que um tipo menor cabe dentro de um tipo maior.
byte short int long float double
Figura 23 Relao de capacidade entre tipos primitivos numricos
Desta forma, o seguinte mtodo, se executado, ir gerar a mensagem representada na figura 25.
31
Unidade I
Figura 24 Atribuies de variveis a tipos de capacidade crescentes
Na linha 10 declarado o mtodo atribuicoesSemCast(), o qual realiza o exemplo. Na linha 11

declarada a varivel b do tipo byte com o valor 8. Da linha 12 at a linha 16, o valor da varivel b
transferido sucessivamente para variveis de maior capacidade. Na linha 18 declarada uma varivel do
tipo String chamada valores. A esta varivel atribudo o retorno do mtodo format() da classe String.
O mtodo format() recebe pelo menos dois parmetros.
O primeiro um String de formatao. Este String composto de caracteres que so simplesmente

retornados, como b = e parmetros de formatao que so compostos de um sinal % e uma letra.
Esta letra indica se o parmetro ser substitudo por um nmero decimal (d) ou um nmero de ponto
flutuante (f). A seguir, o mtodo format() recebe os valores que sero inseridos nos parmetros do String
de formatao. As sequncias \n indicam que ser inserido no String uma quebra de linha. Por fim,
para que o cdigo no fique demasiadamente largo, podese quebrar uma linha no meio do String.
Para tanto, ele deve ser encerrado na primeira linha fechando as aspas e, na linha seguinte, deve ser
concatenado com o segundo String usando o operador +.
Observao
A sada formatada utilizada no exemplo anterior uma ferramenta

poderosa que foi criada originalmente na linguagem C e est disponvel no
Java nos mtodos String.format() e System.out.printf().
32
Figura 25 Sada do mtodo atribuicoesSemCast()
J para se fazer as atribuies na direo oposta, necessrio realizar um cast, ou converso de

tipo. Um cast representado pelo tipo de destino entre parnteses antes do valor a ser convertido. O
programa apresentado na figura 24 foi alterado para realizar atribuies de variveis de maior capacidade
a variveis de menor capacidade.
Figura 26 Atribuies de variveis de maior capacidade a variveis de menor capacidade
Na figura anterior est representado o mesmo programa Atribuicoes. Repare que na linha 11 h um
sinal + e a prxima linha a 24. Este sinal indica que a implementao do mtodo atribuicoesSemCast()
foi ocultada. Este recurso est disponvel no Eclipse (e em praticamente qualquer IDE moderna). Para
se exibir novamente o cdigo oculto, basta clicar no sinal +. Para se ocultar um trecho de cdigo,
clicase no sinal . A outra modificao est no mtodo main(), que agora chama tambm o mtodo
atribuicoesComCast().
33
Unidade I
Na linha 26 declarada uma varivel double com um valor em ponto flutuante. Nas linhas 27 a 31,
este valor convertido sucessivamente em tipos cada vez de menor capacidade. O resultado pode ser
visto na figura a seguir.
Figura 27 - Sada do mtodo atribuicoesComCast()
Note como os valores, ao serem convertidos para tipos de menor capacidade, foram perdendo
preciso, como se estivessem sendo corrompidos. Isto ocorre porque o cast no faz arredondamento,
ele faz truncamento em binrio. Isso significa que, quando um nmero convertido para um tipo de
capacidade menor em bits, apenas os bits menos significativos so mantidos. Os bits excedentes do
nmero so desprezados, o que causa a perda de informao.
Observao
A partir de agora, os exemplos apresentados neste livrotexto no

sero mais programas inteiros. Para poupar espao, os exemplos sero
apresentados como mtodos que podem simplesmente ser inseridos em
um programa qualquer que voc j tenha criado. Basta chamar o mtodo a
partir do seu mtodo main().
2.5 Classes wrapper (invlucro)
Cada tipo primitivo possui uma classe wrapper associada. Uma classe wrapper pode ser utilizada para
instanciar um objeto que armazena um valor do tipo primitivo associado a ela. Alm disso, estas classes
apresentam diversos mtodos para fazer a converso de e para diversos tipos. As classes wrapper so:
Quadro 2 Tipos primitivos e suas classes wrapper associadas
Tipo primitivo Classe wrapper

boolean Boolean
char Character
byte Byte
34
short Short
int Integer
long Long
float Float
double Double
Essas classes podem ser utilizadas para se instanciar objetos com um valor do tipo primitivo associado
a elas:
Figura 28 Instanciao de objetos de classes wrapper
A partir do Java 5 (Java verso 1.5), o valor de uma varivel de tipo primitivo pode ser atribudo
diretamente a um objeto de sua classe wrapper associada e viceversa. Este recurso chamado de
autoboxing:
Figura 29 Exemplo de autoboxing
As classes wrapper oferecem mtodos parse que so teis para se converter um String em um valor
de tipo primitivo associado. Cada classe wrapper possui um mtodo parse:
Figura 30 Exemplos de converso de String para tipos primitivos
As classes wrapper numricas (todas exceto boolean e character) possuem mtodos value para
converter o valor armazenado no objeto para outros tipos primitivos numricos. Dessa vez, a converso
feita com arredondamento, no mais com truncamento, como o que ocorre quando se utiliza um
cast. O exemplo a seguir utiliza os mtodos value para converter de um objeto Integer para diversos
outros tipos, mas o mesmo pode ser feito com qualquer outro wrapper numrico.
35
Unidade I
Figura 31 Exemplo de uso de um objeto wrapper para se converter um inteiro para diversos outros tipos
Repare que na primeira linha foi usado um construtor da classe Integer que recebe um String e no
um int. Todas as classes wrapper possuem um construtor que recebe um String. Este construtor faz a
converso apropriada (usando um mtodo parse adequado) antes de terminar a instanciao do objeto.
Saiba mais
Como em qualquer recurso do Java, possvel aprender bastante

estudando a documentao da linguagem.
Para saber do que mais so capazes as classes wrapper, consulte:
<https://docs.oracle.com/javase/tutorial/java/data/index.html>.
Veja o programa a seguir que utiliza uma classe wrapper para receber dois nmeros do usurio e, a
seguir, realizar um clculo matemtico:
Figura 32 Um programa que recebe nmeros do usurio e realiza um clculo matemtico com eles
36
Observe a seguir as sadas do programa da figura anterior:
Figura 33
2.6 Introduo a classes e objetos
Uma das diferenas mais bvias entre uma linguagem estruturada e uma linguagem orientada a
objetos so justamente as classes e objetos. Podese entender, de maneira bastante simplificada, que
uma classe um trecho de cdigo de computador que modela algum conceito til para o sistema que se
est desenvolvendo. Este conceito pode ser algo tangvel, como um cliente, um funcionrio, um produto,
uma venda, mas tambm pode ser um conceito mais abstrato, como um conjunto de ferramentas de
clculo ou um conjunto de funcionalidades de acesso a banco de dados.
Quando se faz a anlise de um sistema, devese modelar classes que encapsulem, isolem, coloquem
uma cpsula em torno deste conceito. Para tanto, preciso ter em mente as seguintes regras para um
bom projeto de classe:
Uma classe deve modelar apenas um conceito.
Uma classe no deve modelar qualquer aspecto de outro conceito.
No deve haver em nenhuma outra parte do sistema qualquer aspecto do conceito modelado pela classe.
37
Unidade I
Saiba mais
As tarefas relacionadas criao da estrutura de classes de um sistema

podem ser estudadas nos seguintes livros:
MEDEIROS, E. S. de. Desenvolvendo software com UML 2.0: definitivo.

So Paulo: Pearson Makron Books, 2004.
PAGEJONES, M. Fundamentos do desenho orientado a objeto com

UML. So Paulo: Makron Books, 2001.
Uma classe modela um determinado conceito reunindo, em um nico elemento, os dados

que definem esse conceito e os comportamentos que esse conceito pode apresentar. Uma boa
maneira de se representar classes usando o Diagrama de Classes da UML (Linguagem Unificada de
Modelagem em ingls). Neste diagrama, uma classe representada com um retngulo dividido em
trs partes. Na primeira parte registrado o nome da classe. Na segunda, os atributos da classe,
que armazenam os dados da classe. Na terceira parte, os mtodos da classe, que implementam
os comportamentos da classe.
Figura 34 Diagrama de classes da classe Pessoa
A figura registra uma classe em UML. Esta classe tem o nome Pessoa e possui dois atributos: nome
e telefone. O primeiro atributo armazena dados do tipo String, enquanto que o segundo armazena
dados do tipo int. A classe tambm apresenta o mtodo apresente(), que ser usado para exibir as
informaes armazenadas nos atributos. Este mtodo no recebe parmetros, pois no h nenhum
parmetro representado entre os parnteses. Ele tambm no devolve nenhum valor, pois seu tipo de
retorno void. Esta classe pode ser codificada em Java da seguinte maneira:
38
Figura 35 A classe Pessoa codificada em Java
Nas linhas 7 e 8 esto declarados os atributos nome e telefone. Eles so declarados como se
fossem variveis, mas so atributos por no estarem dentro de qualquer mtodo. Suas declaraes so
precedidas pela palavra reservada public, representada pelo sinal + no diagrama UML da figura 34. Esta
palavra reservada indica que esses atributos podem ser acessados por qualquer parte do sistema que
tenha acesso classe Pessoa. Na linha 10 declarado o mtodo apresente(), que imprime em uma caixa
de dilogo os dados armazenados nos atributos.
Observao
Os modificadores de acesso sero abordados mais adiante neste

livrotexto.
Uma classe uma definio de um conceito, como o simples cadastro de uma pessoa apresentado
no exemplo mencionado anteriormente. No entanto, um programa no pode utilizar esta definio
diretamente, ele precisa instanciar esta classe em um objeto. Imagine que uma classe seja uma receita
de bolo. Com esta receita, podese preparar vrios bolos e todos acabaro sendo mais ou menos parecidos.
Da mesma forma, uma classe usada para se instanciar vrios objetos. o objeto que realmente possui
os dados e os comportamentos modelados. O programa a seguir instancia um objeto da classe Pessoa,
atribui valores aos seus atributos e chama o mtodo apresente(). O resultado de sua execuo tambm
apresentado:
39
Unidade I
Figura 36 Programa TestaPessoa e o resultado de sua execuo
Na linha 7 criada uma varivel chamada p, cujo tipo Pessoa. Nesta varivel armazenado um
objeto da classe Pessoa. O objeto instanciado com o uso da palavra reservada new seguida do nome
da classe. Na verdade, o termo Pessoa() que segue a palavra new no o nome da classe, mas um
mtodo construtor. Mtodos construtores sero apresentados logo a seguir.
Nas linhas 9 e 10 os atributos nome e telefone de p tm seus valores atribudos. Note que o objeto
p tm seus prprios atributos nome e telefone. Caso um outro objeto fosse instanciado, ele poderia ter
valores diferentes em seus atributos nome e telefone.
Na linha 12 chamado o mtodo apresente() de p, que faz ser exibida a caixa de mensagem com as
informaes armazenadas no objeto p.
2.7 Instrues de controle
Note que, da maneira que a classe Pessoa no item anterior foi escrita, qualquer valor pode ser
atribudo aos atributos da classe, mesmo que eles sejam invlidos. H uma maneira de se evitar que isso
acontea: ns podemos encapsular os atributos, ou seja, tornalos privados, e oferecer acesso a eles por
mtodos acessores (getters, em ingls), que fazem a validao dos dados de forma que apenas dados
vlidos sejam armazenados. A seguir, modificamos a classe Pessoa para que s possam ser armazenados
telefones com pelo menos oito dgitos. Vamos tambm encapsular o atributo nome, mesmo que
nenhuma validao seja feita:
40
Figura 37 A classe Pessoa com atributos encapsulados
Nas linhas 7 e 8, os atributos nome e telefone foram alterados para privados, o que significa que
agora eles s podem ser acessados de dentro da prpria classe Pessoa. Para permitir que eles tenham seus
valores lidos, foram criados os mtodos getters, nas linhas 10 e 18. Estes mtodos, quando executados,
retornam o valor armazenado no atributo correspondente.
Na linha 14 criado o mtodo setNome(), que recebe como parmetro um nome e o atribui ao
atributo nome. Como tanto o parmetro quanto o atributo possuem o mesmo nome, o programa
no teria como saber qual o atributo e qual o parmetro. Para resolver este problema, utilizase a
referncia this na linha 15. Desta forma, podese ler a linha 15 como sendo o nome deste objeto recebe
o valor de nome. Assim, this.nome o atributo do objeto enquanto que nome o parmetro.
J no mtodo setTelefone() na linha 22, s feita a atribuio se o valor do parmetro telefone tiver
ao menos oito dgitos. Esta verificao feita com o desvio condicional if. Sua sintaxe completa :
41
Unidade I
Figura 38 Sintaxe do desvio condicional if
A condio pode ser qualquer expresso que tenha como valor final um booleano. Isso significa que
a condio pode ser uma simples varivel booleana ou uma expresso booleana, que o resultado de
alguma operao lgica. As operaes lgicas so:
Quadro 3 Operadores lgicos
== Igual a
!= Diferente de
< Menor que
> Maior que
<= Menor ou igual a
>= Maior ou igual a
! No (inverte o resultado de uma expresso booleana)
Quando se deseja realizar vrios testes, podese encadear outro if dentro do conjunto de instrues
da clusula else. Mas tambm podese utilizar a estrutura switchcase, que tem a sintaxe a seguir:
Figura 39 Sintaxe da estrutura switchcase
42
A estrutura switchcase usa como clusula de teste uma varivel que pode ser dos tipos primitivos
char, int, short ou byte. Cada clusula case define um conjunto de instrues que ser executado caso
seu valor corresponda ao valor da varivel de teste. A clusula default, que opcional, executada se
nenhuma outra clusula case foi executada.
Saiba mais
A sintaxe completa das estruturas if, ifelse e switchcase pode ser

encontrada na bibliografia e tambm nos documentos de apoio do Java,
disponveis na internet:
ORACLE. The ifthen and ifthenelse statements. The Java Tutorials.

2015b. Disponvel em: <https://docs.oracle.com/javase/tutorial/java/
nutsandbolts/if.html>. Acesso em: 15 out. 2015.
ORACLE. The switch statement. The Java Tutorials. 2015d. Disponvel

em: <https://docs.oracle.com/javase/tutorial/java/nutsandbolts/switch.
html>. Acesso em: 15 out. 2015.
A classe Pessoa ainda no teve um mtodo construtor definido explicitamente. Mtodo construtor
um mtodo que executado sempre que um objeto instanciado. Esse mtodo deve possuir exatamente
o mesmo nome da classe e no deve apresentar nenhum tipo de retorno, nem mesmo void. Quando no
criamos um construtor em uma classe, o prprio compilador cria um para ns, o construtor padro.
O mtodo construtor padro um construtor sem parmetros e que no executa nenhuma ao em
sua implementao. Quando escrevemos Pessoa p = new Pessoa();, o termo Pessoa(), na verdade, o
construtor padro da classe. Ns podemos criar os nossos prprios construtores. Uma vez que a classe
tenha um construtor qualquer, o compilador no ir criar o construtor padro. Caso queiramos um
construtor sem parmetros, devemos declarlo explicitamente, como do exemplo a seguir:
43
Unidade I
Figura 40 A classe Pessoa com mtodos construtores
Na linha 28 declarado o mtodo construtor sem parmetros. Note que o mtodo deve ter
exatamente o mesmo nome da classe e no deve apresentar nenhum tipo de retorno. Na linha 32
criado um segundo mtodo construtor, desta vez ele recebe como parmetros o nome e o telefone da
pessoa. Em sua implementao, ele faz a atribuio dos valores utilizando a validao de dados por meio
dos mtodos acessores que j foram criados na classe.
A classe TestaPessoa pode ser modificada da seguinte maneira para refletir as mudanas feitas na
classe Pessoa:
44
Figura 41 Programa TestePessoa corrigido
Na linha 7, instanciado o objeto p1 utilizando o construtor sem parmetros. Nas linhas 8 e 9,

os valores dos atributos agora precisam ser definidos utilizando os mtodos acessores. J no mais
possvel acessar os atributos diretamente, pois eles foram definidos como privados.
Na linha 12, um outro objeto, p2, instanciado, desta vez utilizando o construtor que recebe como
parmetros os valores do nome e do telefone. Durante a instanciao, os valores so armazenados nos
atributos e o objeto j est pronto para exibir suas informaes.
Agora, digamos que queiramos que o programa leia e exiba os dados de dez pessoas. Ns poderamos
simplesmente repetir a lgica do programa anterior dez vezes, mas esta no a melhor escolha.
Observao
O computador existe para realizar o trabalho rduo para ns. Sempre

que nos pegamos pensando algo como vou ter que fazer a mesma coisa de
45
Unidade I
novo, muito provavelmente h algo errado em nosso algoritmo. Sempre h

alguma maneira de fazer como que o programa realize a tarefa repetitiva
para ns.
A seguir, vamos modificar o programa TestePessoa para repetir dez vezes a rotina de receber e exibir
os dados de dez pessoas:
Figura 42 O programa que recebe e exibe os dados de dez pessoas
O mtodo recebePessoa() entre as linhas 7 e 19 recebe do usurio os dados de uma pessoa, instancia
um objeto da classe Pessoa com estes dados e o retorna.
O mtodo main() entre as linhas 21 e 30 utiliza o mtodo recebePessoa() para receber os dados de
dez pessoas. Na linha 25 iniciado um lao de repetio for para repetir dez vezes a rotina definida nas
linhas 26 e 27. O lao for tem trs parmetros: o primeiro uma definio de uma varivel contadora;
o segundo a condio que, se verdadeira, permitir que o lao seja repetido mais uma vez; o terceiro
a lgica de incremento (ou decremento) da varivel contadora.
46
O Java ainda define os laos while e dowhile, que possuem a seguinte sintaxe:
Figura 43 Sintaxe dos laos while e dowhile
O lao while inicia testando a condio de parada. Se ela for verdadeira, ele ir executar o conjunto
de instrues de repetio. Em algum momento durante a execuo, a condio de parada deve ser
alterada para falsa, de modo a fazer com que o lao encerre.
O lao dowhile inicia executando uma vez o conjunto de instrues de repetio. A seguir ele
verifica a condio de parada. Se ela estiver verdadeira, o loop reinicia. Novamente, em algum momento
a condio de parada deve ser alterada para falsa para que o lao termine.
Saiba mais
Consulte a documentao do Java para conhecer mais detalhes dos

laos for, while e dowhile:
ORACLE. The for statement. The Java Tutorials. 2015c. Disponvel em

<https://docs.oracle.com/javase/tutorial/java/nutsandbolts/for.html>.
Acesso em: 15 out. 2015.
ORACLE. The while and dowhile statements. The Java Tutorials. 2015e.
Disponvel em: <https://docs.oracle.com/javase/tutorial/java/nutsandbolts/
while.html>. Acesso em: 15 out. 2015.
2.8 Arrays
O programa do exemplo anterior conseguia ler e exibir os dados de dez pessoas, mas no era capaz
de armazenlos. Para tanto, deveramos ter criado dez variveis. Entretanto, criando dez variveis, seria
muito difcil continuar utilizando o lao for para automatizar o processo. Para resolver este problema,
podemos utilizar um array (vetor). Um array um conjunto de variveis de mesmo tipo. Vejamos como
o programa pode ser modificado para utilizar um array de Pessoa:
47
Unidade I
Figura 44 Programa que recebe e armazena Pessoa em um array
Na linha 22 declarada a varivel p, que desta vez um array de objetos da classe Pessoa. Isso
indicado pelo smbolo []. Um array deve ser instanciado como se fosse um objeto, o que feito na linha
23 com o operador new, seguido do tipo de dado de cada elemento do vetor (Pessoa) e da quantidade
de elementos do vetor ([10]).
Na linha 25 declarada a varivel contadora que ser usada nos dois laos for a seguir.
Na linha 27 iniciado o lao de leitura das dez pessoas. Na linha 28, cada pessoa lida pelo mtodo
recebePessoa() e armazenada no elemento de ordem i do vetor p (p[i]). Note que os ndices de vetores
em Java iniciam com o valor 0.
Na linha 31 iniciado o lao de apresentao das dez pessoas. Cada elemento do vetor p um objeto
da classe Pessoa e, por isso, possui o mtodo apresente(). Assim, na linha 32, cada elemento do vetor tem
o seu mtodo apresente() chamado.
48
Saiba mais
Consulte a documentao do Java sobre a declarao e uso de arrays:
ORACLE. Arrays. The Java Tutorials. 2015a. Disponvel em: <https://docs.oracle.

com/javase/tutorial/java/nutsandbolts/arrays.html>. Acesso em: 15 out. 2015.
2.9 Colees
O uso de arrays foi til para armazenar uma quantidade definida de objetos da classe Pessoa.
Entretanto, para utilizar arrays, devese saber de antemo quantos elementos sero necessrios para
se criar o vetor. Quando no se sabe quantos elementos sero necessrios, podemos utilizar estruturas
dinmicas de armazenamento de dados. O Java nos oferece um conjunto de estruturas deste tipo, as
colees. Uma coleo um conjunto de variveis semelhante a um array, mas que pode ter o seu
tamanho modificado conforme a necessidade.
Vamos modificar o programa TestaPessoa para receber uma quantidade indefinida de pessoas. Este
programa ir armazenar objetos da classe Pessoa enquanto o usurio desejar:
Figura 45 Um programa que recebe uma quantidade indefinida de pessoas
49
Unidade I
Na linha 24 declarada a estrutura dinmica de armazenamento de dados pessoas, que um ArrayList

que ir armazenar elementos da classe Pessoa. Na mesma linha, a estrutura pessoas instanciada. Por
enquanto, a estrutura j existe, mas ainda no possui nenhum elemento dentro dela.
Nas linhas 27 a 32 feita a leitura de uma quantidade no conhecida de pessoas. Na linha 27

declarada a varivel que ir conter a resposta do usurio quando lhe for perguntado se ele deseja
continuar cadastrando pessoas. Sua resposta ser na forma de um nmero inteiro, como ser visto
adiante. Na linha 28 iniciado o lao dowhile, o que significa que o lao ser executado ao menos uma
vez. Na linha 29, o mtodo recebePessoa() executado para ler os dados de uma pessoa. Ele devolve
um objeto da classe Pessoa, que , ento, passado como parmetro para o mtodo add() do ArrayList
pessoas. Esse mtodo adiciona seu parmetro como um novo elemento do vetor dinmico pessoas. Na
linha 30 usado o mtodo showConfirmDialog da classe JOptionPane. Esse mtodo exibe uma caixa de
dilogo onde o usurio pode dar sua resposta por meio de botes. A verso do mtodo utilizada pede
quatro parmetros: o primeiro a janela pai (continuamos usando nenhuma); o segundo a pergunta
que ser exibida para o usurio; o terceiro o ttulo da caixa de dilogo; o quarto define quais so os
botes exibidos. As opes so YES_NO_CANCEL_OPTION e YES_NO_OPTION. Na linha 32, a resposta do
usurio verificada. Para que no tenhamos que decorar qual o valor de cada resposta, utilizamos uma
das constantes disponveis para a resposta: YESOPTION, NO_OPTION ou CANCEL_OPTION.
Nas linhas 35 a 37 um novo lao feito, desta vez para exibir os dados de todas as pessoas cadastradas.
A linha 35 utiliza uma forma alternativa do lao for. Esta forma recebe dois parmetros separados por dois
pontos (em vez de ponto e vrgula): o primeiro uma definio de cada elemento da estrutura definida
pelo segundo parmetro. Essa linha pode ser lida como para cada Pessoa p em pessoas. O segundo
parmetro pode ser uma coleo ou um vetor. Esse lao, ento, ir percorrer todos os elementos dentro de
pessoas, ir chamar cada um de p e ir executar a linha 36, em que chamado o mtodo apresenta() de p.
Saiba mais
Consulte a documentao disponvel para colees:
<https://docs.oracle.com/javase/tutorial/collections/index.html>.
Veja tambm a classe JOptionPane:
CLASS JOptionPane. Oracle.com, 2014. Disponvel em: <https://docs.oracle.

com/javase/7/docs/api/javax/swing/JOptionPane.html>. Acesso em: 19 out. 2015.
2.10 Tratamento de excees
Se voc esteve testando os programas discutidos at aqui, deve ter encontrando algumas situaes
em que o programa parou abruptamente devido a alguma situao inesperada. Por exemplo, em qualquer
um dos programas que cadastra o telefone de uma pessoa, se o usurio digitar uma letra (ou nada) no
50
lugar de um nmero inteiro quando lhe pedido para digitar o nmero de um telefone, o programa
encerrado informando uma mensagem de erro. Experimente fazer isso agora e observe a mensagem de
erro que apresentada na janela do Console. Na primeira linha da mensagem de erro dito que ocorreu
uma exceo do tipo NumberFormatException (em ingls). Isso indica que foi tentada a converso para
inteiro de um String que no representava um nmero inteiro.
Ns podemos modificar o programa para que ele perceba esta exceo e pea ao usurio para
inserir novamente o nmero de telefone at que um nmero vlido seja inserido. Isso feito com o
tratamento de excees, que composto de blocos trycatch ou trycatchfinally.
No bloco try implementado o cdigo que pode provocar uma exceo. No bloco catch implementado
o cdigo que ser executado caso uma exceo ocorra. No bloco opcional finally implementado o cdigo
que deve ser executado tendo ocorrido uma exceo ou no. Ele til para fechar recursos que estavam
sendo usados no bloco try, como arquivos, conexes com bancos de dados, conexes de rede etc.
Vamos modificar o mtodo recebePessoa() da classe TestaPessoa para que ele se recupere de uma
entrada de dados errada no nmero do telefone.
Figura 46 Programa que trata excees
51
Unidade I
O trecho que recebe o nmero de telefone de uma pessoa agora est entre as linhas 19 e 29. Na
linha 19 definida uma varivel booleana que verdadeira quando o usurio precisa inserir um nmero
de telefone vlido. Na linha 20 iniciado o lao que ser repetido quando o usurio insere caracteres
invlidos para um nmero de telefone. Na linha 21 iniciado o bloco try, que o trecho de cdigo
que pode causar uma exceo. A exceo de formatao numrica pode ocorrer na linha 22, quando
o mtodo parseInt() tenta converter um String invlido para um nmero inteiro. Se a converso for
bemsucedida, a linha 24 executada e armazena o valor false na varivel repete. Caso uma exceo
de formatao numrica tenha sido lanada no bloco try, ela ser capturada pelo bloco catch na linha
25. Na linha 26 exibida uma mensagem informativa ao usurio e a varivel repete no ter seu
valor alterado. Na linha 29 o lao dowhile decide se ele deve reiterar ou no, dependendo do valor
armazenado pela varivel repete. Ela contm o valor true se ocorreu uma exceo, false caso contrrio.
As principais excees so:
ArithmeticException: erro aritmtico, como uma diviso por zero.
ArrayIndexOutOfBoundsException: foi acessado um ndice de vetor fora do seu limite.
NullPointerException: foi acessado um objeto que ainda no foi instanciado.
NumberFormatException: foi tentada a converso de um String em um formato numrico invlido.
Tambm possvel fazer o tratamento de mais de uma exceo em um mesmo bloco try:
Figura 47 Tratamento de mais de uma exceo
52
Nas linhas 16 e 18 feita a converso da entrada de dados do usurio para int, o que pode causar
uma exceo NumberFormatException, que tratada pela clusula catch da linha 23.
Na linha 20 feita a diviso de dois nmeros inteiros, o que pode causar uma exceo
ArithmeticException, a qual tratada pela clusula catch da linha 26.
Saiba mais
Consulte a documentao sobre as excees em Java:
<https://docs.oracle.com/javase/tutorial/essential/exceptions/index.html>.
Resumo
A tecnologia Java foi desenvolvida para ser uma tecnologia de

desenvolvimento de software multiplataforma, ou seja, seu cdigo
compilado pode ser executado diretamente em qualquer plataforma que
esteja equipada com uma Mquina Virtual Java (JVM, sigla em ingls). Isso
possvel porque o cdigofonte Java compilado para um bytecode. A
partir da, esse bytecode interpretado pela mquina virtual na plataforma
de execuo.
O Java teve sua popularidade favorecida pelo surgimento da World Wide

Web, que viu na tecnologia uma maneira de incorporar interatividade e
multimdia s pginas web. Atualmente o Java utilizado em praticamente
qualquer situao em que se utiliza programao, como aplicativos desktop,
corporativos distribudos, para dispositivos mveis, para eletrodomsticos,
automveis, entre outros.
Para se desenvolver em qualquer tecnologia Java, o mnimo necessrio

instalar o Kit de Desenvolvimento Java SE (Java SE SDK ou, simplesmente,
JDK). possvel programar utilizando um simples editor de arquivos de
texto e compilar usando o JDK. No entanto, so bastante populares as
Plataformas de Desenvolvimento Integradas (IDEs). Com elas, possvel
realizar a maioria das atividades relacionadas ao desenvolvimento de
software, como escrever cdigo, compilar, depurar e implantar o sistema.
Podese realizar a entrada e sada de dados de uma maneira simples

utilizando a classe JOptionPane, a qual disponibiliza mtodos para a
exibio de caixas de dilogo. O mtodo showMessageDialog() exibe uma
mensagem; o mtodo showInputDialog() recebe dados do usurio e o
53
Unidade I
mtodo showConfirmDialog() permite que o usurio responda a perguntas

cujas respostas podem ser simplesmente sim, no e cancela.
Todos os elementos que podem ser nomeados (variveis, atributos,

mtodos, parmetros, classes, pacotes etc.) devem ter nomes escritos sem
espaos. Caso o programador escolha um nome composto por mais de uma
palavra, elas devem ser escritas juntas, com a primeira letra de cada palavra
a partir da segunda palavra em letra maiscula. A primeira letra da primeira
palavra deve ser maiscula caso o nome seja de uma classe (ou interface,
algo que ser visto a seguir). Essa notao conhecida como camel case.
Os tipos primitivos so os tipos de dados que a linguagem pode manipular

diretamente. Dados armazenados em uma varivel de tipo primitivo podem
ser armazenados em outra varivel de tipo primitivo de maior capacidade.
J a atribuio na direo da varivel de maior capacidade para a de
menor capacidade deve ser feita utilizandose alguma forma de converso,
como a converso direta, ou cast. Cada tipo primitivo possui uma classe
wrapper associada, que pode instanciar objetos que armazenam um valor
do tipo primitivo associado a ela, alm de oferecer diversos mtodos para
converso de tipos. As classes wrapper devem ser utilizadas apenas para a
converso de tipos. J para uso normal no aplicativo, recomendado o uso
dos tipos primitivos, que so muito mais eficientes em uso de memria e
no desempenho de processamento.
Classes so a estrutura bsica de um programa orientado a objetos.

Elas so compostas basicamente de atributos e mtodos. Uma classe deve
modelar algum conceito presente no sistema. Desta forma, os atributos da
classe modelam os dados desse conceito enquanto os mtodos da classe
modelam os comportamentos desse conceito.
Algoritmos podem ser construdos utilizandose instrues de controle.

As instrues de controle do Java so inspiradas nas instrues de controle
do C e seguem a sua sintaxe bsica. As instrues so o if, switchcase, for,
while e dowhile.
Conjuntos maiores de dados podem ser armazenados em estruturas

homogneas de dados, tambm conhecidas como vetores, ou ainda
arrays. Caso seja desejada uma estrutura de armazenamento dinmica,
ou seja, que possa mudar de tamanho durante a execuo do programa,
podese utilizar as estruturas disponveis no framework Collections,
como a classe ArrayList. Um objeto desta classe comportase como um
array que pode mudar de tamanho conforme muda a quantidade de
elementos armazenados por ele.
54
Durante a execuo de qualquer programa, podem ocorrer situaes

de exceo, que podem (devem) ser tratadas pelo programa, de modo que
este no seja interrompido. O uso de tratamento de excees pelo uso dos
blocos trycatch e trycatchfinally tornam o sistema mais tolerante a
falhas. Assim, o programa pode se recuperar de alguma situao inesperada
e cumprir suas tarefas corretamente.
55
Unidade II
Unidade II
3 PROGRAMAO ORIENTADA A OBJETOS
At este ponto ns conhecemos a tecnologia Java e vimos, de maneira superficial, que esta tecnologia
orientada a objetos. Agora, vamos abordar mais detalhadamente como o Java implementa os recursos
que tornam o paradigma orientado a objetos o principal paradigma de desenvolvimento de sistemas.
O aspecto mais importante da orientao a objetos o polimorfismo. O termo polimorfismo originase

do grego e significa muitas formas (poli = muitas; morphos = formas). As principais manifestaes desse
recurso so a sobrecarga, a sobrescrita e o polimorfismo de objetos.
3.1 Sobrecarga
A sobrecarga de mtodos j foi vista rapidamente anteriormente, quando abordamos os mtodos

construtores de uma classe. Naquela ocasio, apenas dissemos que uma classe pode apresentar mais de
um mtodo construtor, desde que estes tenham uma lista de parmetros diferentes.
A sobrecarga pode ser feita com qualquer mtodo, ou seja, podemos criar quantos mtodos quisermos
em uma classe com o mesmo nome, desde que eles tenham uma lista de parmetros que seja diferente
em quantidade, em tipo ou em quantidade e tipo.
Quando sobrecarregamos um mtodo, estamos dizendo que todos os mtodos sobrecarregados

realizam a mesma tarefa, mas de maneiras diferentes. Considere a seguinte classe:
Figura 48 Sobrecarga de mtodos
56
Note que a classe demonstrada na figura define quatro verses do mtodo soma(), cada uma com
uma lista de parmetros diferentes. A primeira sobrecarga recebe dois int; a segunda trs int; a terceira
dois double e a quarta trs float. Note que os nomes dos parmetros no fazem a menor diferena,
apenas os seus tipos. Se, na classe em questo, for criada uma nova sobrecarga, como mostrado a seguir,
o cdigo apresenta erros e no pode ser compilado.
Figura 49 Exemplo de uma sobrecarga invlida
O prprio editor de cdigo indica que h um erro na declarao dos mtodos nas linhas 5 e 21.
Ao se flutuar o mouse por cima do erro (flutuar significa mover o cursor sobre o erro e no clicar), o
editor indica que o mtodo soma(int, int) est duplicado, mesmo que os nomes dos parmetros sejam
diferentes.
Observao
Ao se flutuar o mouse sobre um erro no cdigo, pode ser apresentada

uma soluo automtica para o erro. Cuidado! Apenas execute a soluo
automtica se voc entende o que ela est fazendo. Caso no saiba o que
o editor est fazendo, a situao pode at piorar! Isso ocorre porque a
soluo automtica realiza alguma mudana no cdigo para que ele possa
ser compilado, mas a mudana pode no ser a que voc espera. Neste caso,
encontrar o erro aps a soluo automtica pode ser ainda mais difcil, pois
voc j no ter mais uma indicao visual do erro.
57
Unidade II
3.2 Herana
Um dos recursos mais importantes da orientao a objetos a herana. Ela um mecanismo que
permite que uma classe herde os atributos e mtodos de outra classe. No jargo de programao,
chamamos a classe que herda de classe filha, enquanto que chamamos a classe da qual a filha herda
de classe pai. Outros nomes para classe pai so superclasse e classe geral. A classe filha tambm pode
ser chamada de subclasse e classe especializada.
Considere a classe Pessoa vista anteriormente. Ela til para armazenar os dados de uma pessoa
genrica. Agora considere que desejamos armazenar os dados de um aluno. Muitos dos elementos da
classe Aluno sero os mesmos da classe Pessoa.
Lembrete
Sempre que passar pela sua cabea a sensao de que algo que voc
est programando igual a algo que j programou, tenha certeza de que h
uma maneira melhor de realizar a mesma tarefa. Em orientao a objetos,
sempre que um programador repete um cdigo, ele est errando! No se
repete cdigo em orientao a objetos!
Ao se criar a classe Aluno, podese aproveitar o que j foi feito na classe Pessoa, herdando da classe
Pessoa. A partir da, a classe Aluno j possui todos os atributos e mtodos da classe Pessoa. Ela s precisa
declarar atributos e mtodos que so especficos de um aluno.
Figura 50 Classe Aluno, que especializa a classe Pessoa
Na linha 3, a classe Aluno declarada com a palavra reservada extends, que indica que a classe herda
da classe Pessoa. A partir daqui, a classe j possui todos os atributos e mtodos da classe Pessoa. Note
que s foram declarados os atributos e mtodos que pertencem apenas a um aluno.
58
Na linha 12, o mtodo setRa() agora faz consistncia do seu parmetro, para ter certeza de que ele no
um String vazio. Entretanto, no se pode escrever a comparao ra != , pois os operadores lgicos no
funcionam como se espera quando os operandos so objetos, apenas quando eles so de tipos primitivos.
Quando a comparao feita com objetos, como o caso de Strings, utilize o mtodo equals(), que retorna
verdadeiro se o objeto que executa o mtodo tem o mesmo contedo que o objeto no parmetro do
mtodo. Na linha 15, caso o parmetro recebido pelo mtodo no seja vlido, o mtodo ir lanar uma
exceo do tipo IllegalArgumentException com a mensagem de erro RA invlido. Desta forma, o mtodo
que tentou atribuir o RA invlido pode tratar a exceo e tentar obter um valor vlido para o RA.
Observao
uma boa prtica de programao lanar uma exceo quando alguma

rotina de validao de dados no for bemsucedida. Modifique a classe
Pessoa para que ela se comporte dessa maneira.
A partir de agora, podese instanciar um objeto da classe Aluno, atribuir valores ao seu nome,
telefone e RA e executar o mtodo apresente().
3.3 Sobrescrita
Note que o mtodo apresente() apenas informa o nome e o telefone do aluno. Desta forma, ele deve
ser modificado. Ns podemos sobrescrever, ou seja, modificar o mtodo na classe filha para que ele se
comporte da maneira desejada. Esta mais uma modalidade de polimorfismo.
Figura 51 Exemplo de sobrescrita
59
Unidade II
O mtodo apresente() na linha 21 possui exatamente a mesma assinatura do mtodo herdado da

superclasse, ou seja, ele possui o mesmo nome, os mesmos parmetros e o mesmo tipo de retorno.
Isso caracteriza uma sobrescrita do mtodo. Note tambm que na linha 23 no podemos mais acessar
diretamente os atributos nome e telefone, pois ambos so privados na classe Pessoa. Por isso, fazemos
o acesso por meio de seus mtodos acessores.
Nas linhas 27 a 30 definido o construtor da classe que recebe trs parmetros, o nome, o telefone e
o RA. Na linha 28 poderamos ter feito a atribuio dos valores do nome e telefone diretamente usando
os mtodos acessores dos atributos. Mas a classe Pessoa j realiza esta tarefa em um de seus construtores.
Ns podemos invocar diretamente tal construtor de dentro de nosso construtor, na primeira linha,
usando a palavra reservada super, que referencia a superclasse. Esta referncia funciona de maneira
anloga referncia this, mas enquanto this referencia o prprio objeto, super referencia a superclasse.
O programa a seguir ilustra a instanciao e uso de um objeto da classe Aluno:
Figura 52 Instanciando a classe Aluno
3.4 Polimorfismo
O polimorfismo de classes o aspecto mais importante da orientao a objetos. Com este recurso,
quando bem utilizado, podemos criar solues simples e eficientes para problemas que teriam solues
grandes, trabalhosas e ineficientes se fosse utilizado apenas o paradigma estruturado de programao.
O polimorfismo de classes um recurso que permite que um objeto de uma classe seja tratado como
se fosse de outra classe. Para que isso seja possvel, ambas as classes devem estar na mesma estrutura
hierrquica e, alm disso, uma delas deve ser um ancestral da outra.
Considere o seguinte exemplo: uma loja de rua permite a entrada de qualquer pessoa por sua porta
principal. A loja no faz distino se a pessoa que entra um aluno, um professor, um funcionrio, um
motorista ou qualquer outra especializao de pessoa. Por outro lado, uma escola possui catracas que
s permitem a entrada de alunos. Outros tipos de pessoas no tm a sua entrada permitida. Em termos
60
de orientao a objetos, a catraca da escola pode ser considerada como um mtodo que recebe apenas
objetos da classe Aluno como parmetro. J a entrada da loja um mtodo que recebe como parmetro
objetos da classe Pessoa. Como Aluno uma subclasse de Pessoa, uma especializao, um tipo de
Pessoa, o Aluno tambm pode ser enviado como parmetro para a loja por polimorfismo.
Figura 53 Exemplo de polimorfismo de classes
Nas linhas 7 a 10 definido o mtodo catracaDaEscola(), que recebe como parmetro um objeto da
classe Aluno.
Nas linhas de 12 a 15 definido o mtodo entradaDaLoja(), que recebe como parmetros um objeto
da classe Pessoa. Por polimorfismo, como Aluno um tipo de Pessoa, ele tambm pode ser passado
como parmetro para esse mtodo.
61
Unidade II
Nas linhas de 17 a 25 feito o cdigo de teste. Nas linhas 18 e 19 so instanciados objetos das classes
Aluno e Pessoa, respectivamente. Na linha 21, o aluno passado para o mtodo catracaDaEscola(). Na
linha 22, a pessoa passada para o mtodo entradaDaLoja(). J na linha 24 que ocorre o polimorfismo:
o aluno passado para o mtodo entradaDaLoja(). Mesmo que esse mtodo receba como parmetro um
objeto da classe Pessoa, ele aceita o objeto aluno, pois ele um tipo de Pessoa. Repare que na terceira
sada do programa, o aluno Joaquim tratado como uma pessoa, no como um aluno.
Saiba mais
Os aspectos de orientao a objetos e polimorfismo so tratados de

forma mais detalhada tanto pela bibliografia de Java quanto pela bibliografia
de anlise orientada a objetos:
SINTES, T. Aprenda programao orientada a objetos em 21 dias. So

Paulo: Pearson Education do Brasil, 2002.
3.5 Modificadores de acesso
Agora que j abordamos os principais aspectos da orientao a objetos, podemos dar mais ateno
aos modificadores de acesso.
Lembrete
Utilizamos os modificadores de acesso private e public para encapsular

atributos, ou seja, protegemos os atributos tornandoos inacessveis,
permitindo o acesso a eles por mtodos acessores pblicos que fazem a
consistncia de dados.
A orientao a objetos define quatro modificadores de acesso para os membros (atributos e mtodos)
da classe, os quais so adotados pela linguagem Java. Eles so:
public (pblico): qualquer classe que tenha acesso classe onde o membro est declarado ter
acesso ao membro;
protected (protegido): apenas a prpria classe e suas subclasses tm acesso ao membro. Em

Java, o modificador protected tambm permite acesso ao membro por classes do mesmo pacote,
mesmo que no sejam subclasses;
padro (ou pacote): membros definidos sem nenhuma palavra reservada so de acesso padro ou
pacote, ou seja, a prpria classe e qualquer classe do mesmo pacote tm acesso ao membro;
private (privado): apenas a prpria classe onde o membro declarado tem acesso a ele.
62
uma boa prtica de programao definir todos os membros inicialmente com o modificador mais
restritivo (privado). Conforme a necessidade de acesso ao membro vai surgindo, o modificador de acesso
deve ser alterado gradativamente na direo do modificador pblico.
Figura 54 Exemplo de modificadores de acesso
3.6 Escopo
Os membros de uma classe normalmente pertencem aos seus objetos. Por exemplo, o atributo nome
da classe Pessoa pertence aos objetos da classe Pessoa. Cada um dos objetos pode ter um valor diferente
para o atributo nome. Da mesma maneira, o mtodo apresente() s pode ser chamado de um objeto. Isto
chamado de escopo de objeto.
Um membro pode, por outro lado, pertencer classe, no aos seus objetos, caracterizando o escopo
de classe. O escopo de classe definido pela palavra reservada static. Um mtodo de classe pode
ser chamado diretamente da sua classe, no sendo necessrio instanciar nenhum objeto da classe.
Os mtodos showMessageDialog(), showInputDialog() e showConfirmDialog() puderam ser chamados
diretamente da classe JOptionPane, sem a necessidade de instanciar um objeto da classe para executar
estes mtodos.
63
Unidade II
Da mesma forma o mtodo main() tambm de classe, porque, para executar um programa, a
mquina virtual no ir instanciar qualquer objeto, ela ir simplesmente executar o mtodo da classe
onde ele foi declarado.
Um atributo de escopo de classe ter o mesmo valor para a classe e para todos os seus objetos. Se o
seu valor for modificado em qualquer um deles, o valor ser modificado em todos.
Observao
Um mtodo de escopo de objeto executado em um objeto. Por isso,

ele ter acesso a qualquer mtodo e qualquer atributo da classe, sejam eles
de qualquer um dos dois escopos.
Por outro lado, um mtodo de escopo de classe, quando executado, no

tem acesso a qualquer objeto, pois ele s conhece a sua classe. Por isso,
ele no consegue acessar membros que sejam de escopo de objeto, ele s
pode acessar membros de classe como ele prprio.
O exemplo a seguir utiliza um atributo de classe para contar quantas vezes ele foi instanciado.
Figura 55 Exemplo de classe que conta as suas instncias
Na linha 5 declarado o atributo contador de escopo de classe, com o valor inicial 0.
Nas linhas 7 a 9 definido o construtor da classe. O construtor executado toda vez que um objeto
da classe instanciado, e quando isso acontece, o atributo contador incrementado.
Nas linhas 11 a 13 definido um mtodo acessor para o atributo contador.
64
Figura 56 Programa que testa a classe Contador
Nas linhas 9 a 11 a classe Contador instanciada 100 vezes. Nas linhas seguintes ela instanciada
mais duas vezes. O contedo do atributo contador apresentado nas linhas 15 a 17.
3.7 Classes abstratas e interfaces
Considere que estamos desenvolvendo um programa de desenho por computador. Esse programa
usa figuras geomtricas como o retngulo, o tringulo e o crculo. Uma de suas funcionalidades
calcular a rea de todas as figuras no desenho.
Para aproveitar o polimorfismo, vamos criar uma estrutura hierrquica de classes para modelar as
figuras geomtricas do sistema. Assim, as classes Retangulo, Triangulo e Circulo sero todas subclasses
da classe FiguraGeometrica. A classe FiguraGeometrica ir definir o mtodo calculaArea() que ser
sobrescrito por todas as subclasses. As sobrescritas do mtodo, ento, iro realizar o clculo correto da
rea de cada figura. Para que o cdigo no fique muito extenso, no vamos encapsular os atributos.
65
Unidade II
Figura 57 A superclasse FiguraGeometrica
Nas linhas 6 a 8 definido o mtodo calculaArea(), o qual existe apenas para permitir o polimorfismo.
Como no possvel calcular a rea de uma figura geomtrica genrica, o mtodo retorna um valor
negativo para indicar que ele no deve ser usado.
O mesmo ocorre com o mtodo getNome() entre as linhas 7 e 9, que ir retornar o nome da figura
geomtrica.
66
Figura 58 As subclasses Retangulo, Triangulo e Circulo
67
Unidade II
As trs subclasses sobrescrevem o mtodo calculaArea() entre as linhas 7 e 9, cada uma com a
equao apropriada. Note que na classe Circulo, o clculo feito com a ajuda da classe Math, que define
uma constante com o valor de (Pi) e o mtodo pow(), o qual realiza a potncia de raio elevado a 2.
O mtodo getNome() entre as linhas 11 e 13 retorna o nome da figura geomtrica apropriada.
As subclasses tambm definem seus construtores, que j fazem a atribuio de valores aos seus
atributos.
A seguir, o programa de teste:
Figura 59 Programa de teste das reas das figuras geomtricas
68
Entre as linhas 7 e 11, o mtodo formataFigura() recebe como parmetro um objeto da classe
FiguraGeometrica e de qualquer uma de suas especializaes. Na linha 9 feita a formatao de um
String com o nome da figura e sua rea.
No mtodo main(), entre as linhas 13 e 27, feita a rotina de teste. Na linha 14 declarado e
instanciado um vetor de trs posies de FiguraGeometrica. Nas linhas 16 a 18, cada uma das posies
recebe um objeto de uma de cada das classes de figuras geomtricas especializadas. Neste ponto j
ocorre polimorfismo. Entre as linhas 22 e 24 feito um lao for aprimorado para percorrer o vetor
e obter a sua representao em texto. Cada representao anexada varivel mensagem, com o
caractere de escape \n, que representa uma quebra de linha. Na linha 26 exibida a caixa de dilogo.
O programa realiza a sua tarefa, mas no muito bem. O problema est na classe FiguraGeometrica,
que define mtodos que no pode implementar e, por isso, faz uma implementao propositalmente
errada. A orientao a objetos oferece uma alternativa: ns podemos declarar mtodos abstratos, ou
seja, mtodos sem implementao. Quando se criam mtodos abstratos em uma classe, esta classe
tambm deve ser abstrata. Assim, podemos modificar a classe FiguraGeometrica da seguinte forma e o
restante do programa pode permanecer inalterado.
Figura 60 Classe abstrata
Nas linhas 5 e 7, as declaraes dos mtodos so agora de mtodos abstratos. Por isso, eles agora
no possuem implementao e so terminados com ponto e vrgula. A classe agora tambm deve ser
abstrata.
Uma classe abstrata pode definir mtodos e atributos concretos (no abstratos). No entanto, por
conter mtodos sem implementao, uma classe abstrata no pode ser instanciada. Ela s pode ser
usada com polimorfismo, como foi feito nesse exemplo. Alm disso, as classes que herdam de uma classe
abstrata devem implementar todos os seus mtodos abstratos se quiserem ser classes concretas, caso
contrrio, elas tambm sero abstratas. Isto til para garantir que as subclasses implementaram todos
os mtodos que deveriam ser sobrescritos, caso eles fossem concretos, como na primeira verso desse
exemplo.
Considere agora uma classe abstrata que s declara mtodos abstratos (como no exemplo anterior).
Uma classe desse tipo pode ser melhor modelada como uma interface. Uma interface uma classe
abstrata que s define mtodos abstratos. Uma classe que realize uma interface (no se usa o termo
herdar de uma interface) deve implementar todos os seus mtodos. Assim, poderamos ter:
69
Unidade II
Figura 61 A interface FiguraGeometrica
Na linha 3 estamos declarando uma interface, no mais uma classe.
Como no se pode herdar de uma interface, apenas realizla, as classes Retangulo, Triangulo e
Circulo devem ser alteradas, trocando a palavra reservada extends por implements:
Figura 62 A classe Retangulo, que realiza uma interface
4 INTERFACES GRFICAS
H duas maneiras de se criar interfaces grficas usando Java. A primeira escrevendo o cdigo ns
mesmos. A segunda usando um editor de interfaces grficas. A abordagem manual costuma dar ao
programador muito mais controle sobre a interface que ele est criando. Tambm costuma gerar um
cdigo mais enxuto e eficiente. J a abordagem com auxlio de um editor de interfaces costuma permitir
um processo mais rpido de criao da interface.
Existem vrios plugins que do a funcionalidade de edio de interface grfica ao Eclipse. A partir
da verso Mars do Eclipse (a mais recente na data de elaborao deste livrotexto), j est includo o
Window Builder, que tambm pode ser instalado em verses mais antigas.
Observao
Outras IDEs tambm apresentam ferramentas para a criao de interfaces

grficas, como o NetBeans, que sempre contou com tal funcionalidade.
70
Para criar uma interface grfica, vamos usar o Window Builder. Clique com o boto direito em um
pacote, selecione New... e ento Other.
Figura 63 Seleo do assistente de criao de janelas
Expanda o grupo WindowBuilder, Swing Designer e escolha JFrame. Clique em Next. D o nome
TelaPessoa sua classe e clique em Finish.
Neste ponto apresentado o editor de cdigo com a classe TelaPessoa, mas dessa vez h duas abas
novas, Source e Design.
71
Unidade II
Figura 64 Editor de interfaces grficas do WindowBuilder no modo cdigo
Selecione a aba Design e maximize a janela de edio dando um duplo clique na aba TelaPessoa. A
sua IDE deve se parecer com a figura a seguir:
Figura 65 Editor de interfaces grficas do WindowBuilder no modo desenho
Clique na rea da janela para fazer com que suas propriedades sejam exibidas. A seguir, modifique
seu gerenciador de layout para absolute layout.
72
Figura 66 Mudando o gerenciador de layout
Saiba mais
O uso de gerenciadores de layout bastante recomendado para tornar

suas interfaces grficas mais profissionais e mais amigveis para o usurio.
Voc pode conhecer mais sobre eles na bibliografia de Java:
DEITEL, H. M.; DEITEL, P. J. Java: como programar. 8. ed. So Paulo:

Pearson Prentice Hall, 2010.
Na palheta de componentes, selecione JLabel e coloqueo na janela. Selecione a propriedade text e

digite o texto Nome:. Tecle enter para confirmar.
73
Unidade II
Figura 67 Inserindo um rtulo na janela
Selecione agora um JTextField e posicioneo na janela. Modifique seu tamanho para que fique
semelhante ao da figura a seguir. Mude tambm seu nome para textFieldNome.
Figura 68 Inserindo um JTextField
74
Insira agora um JLabel com o texto Telefone: e um JTextField chamado textFieldTelefone como
mostra a prxima figura:
Figura 69 Inserindo os componentes para o telefone
Agora insira um JButton. Mude seu nome para btnApresenta e seu texto para Apresente.
Figura 70 Inserindo um JButton
75
Unidade II
Agora vamos associar uma ao ao boto btnApresente. D um duplo clique no boto. O editor ir
criar o cdigo associado ao de clique e o levar ao cdigo, como mostra a figura a seguir:
Figura 71 O cdigo de criao do JButton
Este o cdigo que cria e configura o boto btnApresente. Entre as linhas 65 e 68 criada uma
instncia de uma classe annima que realiza a interface ActionListener. Esta interface define o mtodo
actionPerformed(), que o mtodo executado quando o boto for clicado. nesse mtodo que vamos
criar a nossa ao, como mostrado na figura a seguir:
Figura 72 O cdigo que executado quando o boto pressionado
Na linha 68 chamado o mtodo showMessageDialog(), desta vez com a janela representada pelo
objeto instanciado da classe TelaPessoa (TelaPessoa.this). Quando a caixa de mensagem for exibida,
ela ser centralizada na janela do aplicativo. Alm disso, o usurio no ser capaz de retornar janela
sem que tenha fechado antes a caixa de dilogo. A seguir a mensagem formatada, buscando as
informaes digitadas pelo usurio nos objetos textFieldNome e textiFieldTelefone. O texto recuperado
com o mtodo getText().
76
Figura 73 A sada gerada pelo programa com interface grfica
Resumo
Iniciamos esta unidade discutindo os aspectos mais importantes do

paradigma de programao orientada a objetos. O primeiro a sobrecarga
de mtodos. Com ela, criamos mais de um mtodo com o mesmo nome,
mas com uma lista de parmetros diferente. A sobrecarga significa que
uma mesma ao pode ser realizada de maneiras diferentes.
Em seguida discutimos o recurso da herana, com a qual podemos criar

novas classes reaproveitando classes existentes. As classes filhas herdam os
atributos e mtodos da classe pai.
Quando uma classe filha precisa modificar um mtodo herdado de uma

classe pai, ela pode sobrescrever tal mtodo, criando um mtodo em sua
prpria classe com a mesma assinatura do mtodo da superclasse, mas com
a nova implementao.
Com o polimorfismo podemos tratar um objeto de uma classe como se

fosse de outra classe, desde que a segunda seja um ancestral da primeira.
Os modificadores de acesso controlam como os membros de uma classe

so acessveis de fora dela. Recomendase que os membros de uma classe
sejam sempre declarados com os modificadores mais restritivos possveis.
77
Unidade II
O escopo define se um membro pertence classe ou aos seus objetos.

Um membro de objeto o escopo padro e ele s existe nos objetos.
Um membro de classe pode ser acessado diretamente da classe, no
necessitando da existncia de objetos da classe.
Finalmente, vimos brevemente como usar o WindowBuilder para criar

interfaces grficas no Eclipse.
78
Unidade III
5 INTRODUO AO ANDROID
Nesta unidade, iremos nos familiarizar com alguns conceitos interessantes que envolvem programao
e estruturao do trabalho utilizando Android. Sero abordados temas como inicializao de ambiente e
desenvolvimento inicial com a linguagem Java para aplicativos Android.
5.1 Fundamentos e paradigmas de programao para dispositivos mveis
A computao mvel, termo usado para descrever as tecnologias que permitem que as pessoas
tenham acesso a servios e informaes em qualquer lugar e a qualquer hora, independentemente da
sua localizao, sem a necessidade de conexo fsica, est adquirindo maior popularidade medida que
dispositivos mveis se tornam disponveis e oferecem facilidades de uso.
A computao mvel caracterizada por trs principais propriedades: mobilidade, portabilidade e

conectividade.
Portabilidade: a portabilidade definida como a capacidade de ser facilmente transportvel.

Se, por um lado, o dispositivo mvel deve ser pequeno e leve (incluindo acessrios) para ser
porttil, por outro, essa portabilidade tem como consequncia certas limitaes, como capacidade
de memria, armazenamento, poder de processamento e tamanho da tela. A portabilidade est
relacionada com as limitaes do dispositivo mveis. Ou seja, quanto maior a portabilidade,
maiores sero as limitaes de recursos do dispositivo mvel e, consequentemente, maior ser
sua mobilidade.
Mobilidade: quando em movimento, o dispositivo mvel pode alterar sua localizao e seu
ponto de conexo com a rede. Na computao mvel, mobilidade se refere ao uso de dispositivos
mveis portteis funcionalmente poderosos que ofeream a capacidade de realizar facilmente um
conjunto de funes de aplicao, sendo tambm capazes de se conectar, obter dados e forneclos
a outros usurios e sistemas.
Conectividade: a funo primria de um dispositivo mvel conectar as pessoas e/ou sistemas

e transmitir e receber informaes. Os dispositivos mveis podem operar de trs formas: a) sempre
conectados a uma rede; b) podem estar conectados de forma intermitente a uma rede; c) podem operar
inteiramente sem conexo a uma rede.
79
Unidade III
Observao
A preocupao com itens como portabilidade, mobilidade e

conectividade uma premissa importante para a composio de um
projeto de desenvolvimento de aplicativos mveis. Garantir a eficincia
desses itens ter certeza da execuo satisfatria do projeto.
5.1.1 Dispositivos mveis
Com o crescente avano tecnolgico na produo de dispositivos computacionais mveis, bem

como da computao mvel, empresas comeam a incentivar o trabalho em casa (home office) e esses
dispositivos comeam a fazer parte da infraestrutura de TI das organizaes.
Atualmente existe uma variedade de dispositivos mveis que oferecem uma gama enorme de
servios aos seus usurios, sendo atualmente os mais conhecidos o smartphone, o tablet e o notebook.
5.1.2 Desafios tcnicos para dispositivos mveis
A mobilidade e os crescentes avanos computacionais introduzem vrios desafios. A habilidade

para ser porttil traz vrias limitaes aos dispositivos mveis. Estas limitaes incluem baixo poder de
processamento, capacidade de bateria, tamanho de tela e quantidade de memria.
Segurana e opes de conectividade sem fio so fatores que tambm devem ser levados em
considerao no desenvolvimento de aplicaes mveis. No entanto, a entrada de dados um fator
problemtico na interao dos usurios com os dispositivos mveis.
Os dispositivos mveis possuem telas e, muitas vezes, teclados, pequenos e limitados. Dos diferentes
mtodos para entrada de dados (de texto) em dispositivos mveis, todos requerem aprendizagem e
alguns deles tm uma curva maior de aprendizagem que outros.
Desse modo, as opes de entrada de dados, que no so apropriadas para entradas rpidas e extensas,
devem ser levadas em considerao para o desenvolvimento de uma aplicao para dispositivos mveis.
5.1.3 Usabilidade e os dispositivos mveis
A usabilidade um dos fatores mais importantes no desenvolvimento de aplicaes mveis. A

interface de usurio de um dispositivo mvel o meio de comunicao entre o usurio e os elementos
funcionais do dispositivo e aplicaes. Os dispositivos mveis ganham cada vez mais funcionalidades.
No entanto, a usabilidade dos dispositivos mveis no fica restrita interface com o usurio. Segundo
Souza, Costa e Spinola (2006), as caractersticas do usurio, do ambiente e dos dispositivos mveis so
fatores que influenciam a interao e devem ser considerados tanto no processo de projeto de interface
quanto na avaliao de usabilidade.
80
Saiba mais
Souza, Costa e Spinola (2006) apresentam algumas das melhores

prticas para projetar aplicaes mveis com usabilidade. Para maior
aprofundamento, leia:
SOUZA, L. S.; COSTA, I.; SPINOLA, M. M. Projetos de interface com o

usurio de software de dispositivos mveis: requisitos de usabilidade
e fatores impactantes. In: SIMPSIO DE ENGENHARIA DE PRODUO
(SIMPEP), n. 13., 2006, Bauru. Anais Bauru: Unesp, 2006. Disponvel em:
<http://www.simpep.feb.unesp.br/anais/anais_13/artigos/851.pdf>. Acesso
em: 13 out. 2015.
5.1.4 Aplicaes mveis
Embora o desenvolvimento de software para dispositivos mveis apresente desafios diferentes das
tpicas aplicaes convencionais, as caractersticas dos projetos de TI tradicionais, como presses por
prazos cada vez menores e a contnua busca na reduo de custos, esto mantidas.
Ao definirmos os requisitos de um projeto de software para dispositivos mveis, muito importante

levar em considerao a variedade de hardware (processadores, memrias, tamanho da tela etc.) e de
software (sistemas operacionais e seus recursos) encontrados em dispositivos mveis.
Segundo Souza, Costa e Spinola (2006), as aplicaes para dispositivos mveis tambm precisam passar
por um processo de desenvolvimento de software, que incluem especificao, projeto, implementao e
validao de software, atendendo aos atributos essenciais dos produtos de software, como a facilidade
de manuteno, a confiana, a eficincia e a facilidade de uso.
Camada desktop
Camada servio Camada negcio
Camada desktop
Figura 74 Arquitetura de plataforma mvel
81
Unidade III
Observao
O modelo de desenvolvimento em camadas est presente no

desenvolvimento de aplicativos mveis para garantir uma boa distribuio
do cdigo, bem como o desenvolvimento segregado, aplicandose
metodologias geis para o desenvolvimento.
5.2 Android
Atualmente o Android vem ganhando fora no cenrio tecnolgico, muito devido ao elevado
crescimento da distribuio mundial dos smartphones e tablets. O Android uma plataforma que
foi construda baseada no Linux, concentrado em dispositivos mveis, desenvolvido pela Google em
parceria com algumas empresas da Open Handset Alliance (OHA). No incio do desenvolvimento do
projeto, o Android era um projeto da Android Inc., uma empresa que tinha como principal vertente o
desenvolvimento de softwares embarcados e que, em meados do ano de 2005, foi adquirida pela Google,
com a inteno de ingressar no mercado de desenvolvimento de aplicativos para telefonia mvel.
Saiba mais
Para um estudo mais aprofundado sobre Linux, recomendamos o

seguinte artigo:
PISA, P. A evoluo do Linux. TechTudo, 23 maio 2012. Disponvel em:

<http://www.techtudo.com.br/artigos/noticia/2012/05/aevolucaodo
linux.html>. Acesso em: 19 out. 2015.
A Google ento trabalhou na continuidade na plataforma Android com o intuito de disponibilizar

no mercado de telefonia mvel uma plataforma padro para dispositivos mveis, ou seja, de maneira
independente do fabricante de hardware. Atualmente muitas empresas, como HTC, Samsung e Motorola,
assim como outras encapsuladas no mercado de telefonia mvel, comercializam diversos modelos de
tablets e smartphones com a plataforma Android. Dessa forma, proporciona a possibilidade para que
diversos usurios possam definir a escolha de um hardware mais barato, por exemplo, ou at mesmo
levar em considerao a escolha de um smartphone com uma cmera melhor, com resoluo mais alta
ou at mesmo priorizar a capacidade de processamento. Todos os recursos levantados at esse momento
colocam como premissa vantagens de se obter um smartphone com a plataforma Android, visto que
usurios finais podem escolher um dispositivo que atenda melhor a suas necessidades.
A utilizao da linguagem Java para o desenvolvimento de aplicativos foi um dos pontos que
tornaram o Android um dos lderes no mercado de dispositivos mveis. Pensar na utilizao do Java
para desenvolvimento foi uma das maiores ideias da Google, considerando que atualmente uma das
82
linguagens mais utilizadas no mundo, sendo muito madura e robusta, colocando tambm em pauta a
linguagem orientada a objetos, um fator de extrema importncia.
Para desenvolver aplicativos para o Android, programadores Java necessitam buscar o aprendizado
em caractersticas particulares da plataforma (conhecer as APIs disponveis, o ciclo de vida das aplicaes
etc.), absorvendo todo seu conhecimento da linguagem, sem ter a preocupao de aprender novas
sintaxes ou novos paradigmas de programao, exercendo a aplicao de lgica de programao para o
estudo da linguagem Java.
Outro ponto de destaque da Google para o trabalho com a plataforma Android foi de lanla de
maneira gratuita. Isto foi um grande atrativo para os fabricantes, que voltaram os olhos para o Android
e viram uma enorme vantagem em embarclo em seus dispositivos mveis. Alm de reduzir o custo de
manter um Sistema Operacional para seus dispositivos, os fabricantes poderiam adquirir uma vantagem
da padronizao da plataforma, permitindo que um usurio final pudesse comprar dispositivos de
diferentes fabricantes sem ter grandes dificuldades no seu uso, uma vez que j estar familiarizado com
a plataforma.
Vale ressaltar mais um ponto importante na aquisio da plataforma Android pela Google: a
concepo de trabalho com o cdigofonte aberto, sendo este aspecto colocado como carrochefe,
um dos itens mais relevantes na plataforma Android. Disponibilizar em sua plataforma o cdigofonte
aberto fez com que fabricantes pudessem embarclo em smartphones, tablets, smart TVs, aparelhos
multimdia, controleremoto, dispositivos de leitura de livros digitais etc. O cdigofonte aberto traz
tambm como benefcio a possibilidade do fabricante customizar o Android, deixandoo ainda mais
atraente para seus usurios finais.
Por fim, a plataforma Android tornase flexvel com sua grande facilidade de personalizao,
possibilitando que aplicaes nativas sejam alteradas por aplicaes segmentadas de terceiros que
possam atrair ainda mais os olhos de usurios mais exigentes. Ainda pode ser possvel, por exemplo,
modificar uma aplicao nativa de realizao de chamadas, a aplicao de contatos, a aplicao de
mensagens SMS, e assim por diante.
5.3 Open Handset Alliance
A Open Handset Alliance (OHA) uma aliana formada em 2007 que agrega diversas empresas que
tm como misso definir padres abertos para telefonia mvel. Algumas das empresas que compem
essa aliana so:
LG;
Samsung;
HTC;
Motorola;
83
Unidade III
Google;
Intel.
Em meados de 2007, atuando no mesmo ano de sua formao, a OHA fez um pronunciamento
sobre a sua plataforma open source Android, baseada no sistema operacional Linux. Desde ento, vrios
fabricantes iniciaram a comercializao de dispositivos com o Android, como a HTC, que, por sua vez,
acabando lanando o seu primeiro celular com Android, o TMobile G1 (tambm conhecido no cenrio
de telefonia mvel como HTC Dream).
5.4 Verses do Android
O Android, por definio, tem uma estrutura de versionamento com base em dois pilares:
Plataform Version: que conhecido comercialmente como a verso da plataforma Android.

Geralmente esse nome visualizado nos dispositivos moveis para o usurio final.
API Level: nmero inteiro, iniciado com 1 (um) e efetuado um autoincremento a cada verso
disponibilizada do Android. Identificao utilizada somente para fins de desenvolvimento de
aplicativos Android.
Quadro 4 Estrutura de versionamento do Android
Plataform Version API Level

Android 4.1 16
Android 4.0.3 15
Android 4.0 14
Android 3.2 13
Android 3.1 12
Android 3.0 11
Android 2.3.3 10
Android 2.3.1 9
Android 2.2 8
Android 2.1 7
Android 2.0.1 6
Android 2.0 5
Android 1.6 4
Android 1.5 3
Android 1.1 2
Android 1.0 1
84
Saiba mais
A verso mais atualizada, lanada no momento da concepo deste

livrotexto, a verso Android 6.0 Marshmallow. Para realizar um
estudo dessa verso, acesse:
RINALDI, C. Android 6.0 Marshmallow: review e todas as funes.

AndroidPIT, 7 out. 2015. Disponvel em: <http://www.androidpit.com.br/
androidmdispositivosdatalancamentofuncoes>. Acesso em: 14 out. 2015.
A API Level pode ser utilizada apenas por desenvolvedores de aplicativos para Android. Fabricantes
que embarcam o Android em seu hardware devem agregar de maneira completa essa API.
Os desenvolvedores da equipe Android zelam sempre pela dinmica e pelo entendimento da

importncia de manter compatveis verses anteriores para cada nova verso, ou seja, criar possibilidades
para que um aplicativo desenvolvido na API Level 10, por exemplo, seja compilado na API Level 16.
Mesmo com toda essa preocupao, nem sempre isso se torna possvel, visto que em algumas das novas
verses pode acontecer de uma funcionalidade alocada no aplicativo legado deixe de existir. Porm,
sempre que isso acontecer, a Google deixa tudo estritamente documentado para que o desenvolvedor
sempre fique atualizado de novas verses.
5.5 Arquitetura do Android
Aplicaes Android precisam de uma arquitetura que possibilite o trabalho de processamento

de informaes, bem como a segregao de bibliotecas, drivers e informaes que agregam o seu
funcionamento pleno.
Manter uma arquitetura distribuda e slida garante a eficincia no processo de alocao de

informaes, bem como garantir informaes primordiais, como garantia de chaves de segurana,
alocao de espao para a base de dados, definio de drivers que podero ser utilizados na aplicao e
a distribuio de funcionalidades na camada de aplicaes.
Quadro 5 Arquitetura do Android
Linux Kernel
Driver de visualizao Driver de cmera Carto de memria Driver de compilao
Driver para teclado Driver para rede sem fio Driver de udio Gerenciador de memria
Bibliotecas Libraries
Gerenciador Surface Media Framework SQLite
OpenGL ES FreeType WebKit
SGL SSL Libc
85
Unidade III
Android Runtime
Biblioteca de Cdigos Nativos
DVM
Framework de aplicaes
Gerenciador de atividades Gerenciador Windows Chave de conexo Sistema de visualizao de soluo
Gerenciador de dados de Gerenciador de recursos do Gerenciador de localizao do
Gerenciador de pacotes telefone telefone telefone (GPS)
Gerenciador de notificaes do
telefone
Camada de aplicaes
Home Agenda Aplicativos Navegador
5.5.1 Linux Kernel
Efetuando um estudo particionado da arquitetura Android, o primeiro nvel apresentado o Linux kernel:
Quadro 6 Primeiro nvel que compe a Arquitetura do Android, denominada Linux Kernel
Linux Kernel
Driver de visualizao Driver de cmera Carto de memria Driver de compilao
Driver para teclado Driver para rede sem fio Driver de udio Gerenciador de memria
O Android roda em uma verso alterada do kernel 2.6 do Linux, customizada para obter melhor
desempenho em dispositivos de baixo recurso, provendo assim melhores performances da bateria, na
troca de arquivos pela rede etc. Isso ratifica ainda mais o fato de que o Android roda em Linux.
Sendo assim, justamente esse nvel o responsvel pela inicializao do sistema, gerenciamento da
memria do dispositivo, gerenciamento dos processos do dispositivo, gerenciamento das threads em
execuo e gerenciamento da energia. Basicamente, todos os drivers responsveis pela comunicao
com os recursos de hardware do dispositivo encontramse neste nvel, como mdulos do kernel do Linux.
Como o Android roda em Linux, ele acaba se beneficiando de vrios recursos desse Sistema
Operacional, como:
Suporte multitarefa: possibilita ao Android realizar diversas tarefas ao mesmo tempo. Esse
trabalho permite a execuo de linhas de cdigo de maneira simultnea, proporcionando a
execuo em paralelo de atividades solicitadas.
Suporte multiusurio: permite ao Android proporcionar ao usurio um fluxo de trabalho

acentuado para cada aplicao instalada, garantindo maior segurana e privacidade dos dados dos
aplicativos, o que impossibilita que um aplicativo instalado danifique os dados de outro ou acesse
sua base de dados e seus respectivos arquivos. Esse conceito de trabalho garante a excelncia na
execuo de aplicativos em dispositivos mveis.
86
O kernel do Android pode ser definido como monoltico, ou seja, ele efetua o incremento das
principais funes do sistema operacional em um bloco grande e nico de cdigos, executados, assim,
em um mesmo espao de endereamento para obter melhor performance e diminuir a complexidade do
sistema, bem como a alocao de informaes para o ncleo do Linux.
5.5.2 Libraries e Android Runtime
A aplicao da camada de bibliotecas garante o encapsulamento de informaes nas aplicaes

mveis, bem como garante que itens como acesso ao banco de dados e chaves de segurana possam ser
acessadas de maneira satisfatria.
O Android Runtime garante a excelncia na execuo de itens como a biblioteca de cdigos nativos e a
DVM, que proporcionam ao desenvolvedor o trabalho eficaz e a execuo do cdigo para compilao Android.
Quadro 7 Segundo nvel que compe a arquitetura do Android,

segregada por Libraries e pelo Android Runtime
Bibliotecas Libraries
Gerenciador Surface Media Framework SQLite
OpenGL ES FreeType WebKit
SGL SSL Libc
Android Runtime
Biblioteca de Cdigos Nativos
DVM
5.5.2.1Libraries
As Libraries podem ser definidas com bibliotecas nativas do Android, que so basicamente bibliotecas
escritas em linguagem C e C++ e que rodam diretamente dentro do Linux. O acesso a essas bibliotecas
pode ser efetuado pela camada superior, a Application Framework, que abstrai todo o acesso a essas
bibliotecas quando se desenvolvido um aplicativo para o Android, ou seja, no se efetua acesso direto
a essa camada.
Entre algumas dessas bibliotecas, encontramse:
WebKit: motor de funcionamento do browser do Android.
SQLite: biblioteca para acesso ao banco de dados utilizado pelo Android.
OpenGL | ES: biblioteca para renderizao de grficos 3D.
SSL: biblioteca que prov o uso de conexes seguras.
87
Unidade III
5.5.2.2 Android Runtime
O Android Runtime tambm pode ser dividido em um segundo nvel da prpria arquitetura Android, como:
Core Libraries
So as bibliotecas do Java e conseguem abstrair praticamente todas as bibliotecas do Java SE. Pode
possibilitar o desenvolvimento de aplicativos usando as APIs padres do Java, programando praticamente
da mesma forma, como se fosse efetuar um desenvolvimento de um aplicativo para desktop.
Dalvik Virtual Machine DVM
a mquina virtual do Android, onde todos os aplicativos sero executados. Todos os aplicativos
desenvolvidos para Android so construdos em Java e toda aplicao desenvolvida em Java necessita,
de maneira obrigatria, de uma mquina virtual para ser executada. No Android, essa mquina virtual
a Dalvik VM. Ela no pode ser considerada a mesma mquina virtual padro do Java (JVM) e foi
desenvolvida justamente para que se possa obter um melhor desempenho em dispositivos com recursos
limitados de memria e processamento.
No Android, cada aplicativo roda em sua prpria instncia da Dalvik VM e cada instncia gerenciada
pelo seu prprio processo no Linux, ou seja, os aplicativos no compartilham a mesma instncia da
Dalvik VM. Isso muito importante para que se possa garantir maior segurana, pois um aplicativo no
poder interferir na execuo de outro.
Incio da compilao Compilador em execuo Gerar arquivo Traduo para Fim do ciclo de
.java para bytecodes do Java .class bytecodes .dex compilao .java
Figura 75 Procedimento para gerao de bytecodes .dex
5.5.3 Application Framework
O terceiro nvel para visualizao da Arquitetura do Android definido por Application Framework,
ou Framework de Aplicaes.
Quadro 8 Terceiro nvel da arquitetura Android
Framework de Aplicaes
Gerenciador de atividades Gerenciador Windows Chave de conexo Sistema de visualizao de soluo
Gerenciador de dados Gerenciador de recursos Gerenciador de localizao do
Gerenciador de pacotes de telefone do telefone telefone (GPS)
Gerenciador de notificaes
do telefone
88
Definindo a Application Framework, ela compreende as APIs do Android que so utilizadas no

desenvolvimento de aplicativos para Android. Esta camada encapsula o acesso s bibliotecas escritas
em C e C++ da camada Libraries, auxiliando o trabalho dos desenvolvedores de aplicativos para Android.
5.5.4 Applications
O quarto nvel da arquitetura do Android apresentado pela camada Applications.
Quadro 9 Quarto nvel, que possibilita a visualizao da camada Applications
Camada de aplicaes
Home Agenda Aplicativos Navegador
A camada de aplicaes engloba todos os aplicativos escritos em Java para o Android. Nesta
camada se concentram tanto os aplicativos nativos do Android quanto os aplicativos concebidos pelos
desenvolvedores. No Android, aplicativos nativos e desenvolvidos por terceiros esto no mesmo nvel,
na camada Applications, o que possibilita desenvolver aplicativos que substituam os nativos, sendo
possvel, por exemplo, criar um aplicativo de contatos que subscreva o que j vem nativo no Android.
Este um recurso muito til e prov grande flexibilidade na plataforma Android.
6 CONCEITOS FUNDAMENTAIS
6.1 Construindo o ambiente de desenvolvimento
Antes de inicializar o desenvolvimento de aplicativos para o Android, necessrio efetuar a instalao

das ferramentas necessrias, como o SDK do Android e um IDE. Todas as ferramentas necessrias para o
desenvolvimento podem ser baixadas gratuitamente pela internet e possuem verso para Mac, Linux e
Windows. Para o desenvolvimento, so necessrias as seguintes ferramentas:
Java SE Development Kit (JDK).
Android Development Kit (Android SDK).
IDE Eclipse (tambm possvel utilizar outros IDEs, como a IntelliJ Idea ou NetBeans).
Android Development Tools (ADT): plugin do Eclipse para desenvolvimento de aplicativos para
o Android.
6.2 Instalando o Android Development Kit (Android SDK)
Com o Java SE Development Kit (JDK) j instalado, conforme apresentado anteriormente neste
livrotexto, necessrio instalar o Android SDK, que detm as ferramentas necessrias para o
desenvolvimento de aplicativos para o Android, assim como as bibliotecas, o debugger, o emulador etc.
89
Unidade III
Para efetuar a instalao, inicialmente ser necessrio baixlo no site do Android: <http://developer.
android.com/sdk/index.html>.
Lembrete
Para instalar o Java SE Development Kit (JDK), v at o site de download

do Java <http://www.oracle.com/technetwork/java/javase/downloads/
index.html>. Clique no link Java Platform (JDK). Marque sua aceitao do
contrato de licena e escolha o JDK apropriado para a plataforma que voc
deseja utilizar para desenvolver os seus programas. O download do arquivo
de instalao do JDK deve iniciar. Inicie o arquivo de instalao e siga as
instrues na tela.
Figura 76 Pgina oficial para efetuar o download do Android SDK
6.3 Instalando o Android Development Tools (ADT)
O Android Development Tools (ADT) um plugin que tem por finalidade integrar o Android SDK ao
Eclipse. O ADT auxilia, principalmente, no desenvolvimento de um aplicativo Android, colocando como
destaques:
O debug do projeto diretamente na IDE.
Compilao e empacotamento de um projeto para instalao em um dispositivo Android.
Efetuar criao de telas facilmente com o editor visual.
90
Para efetuar a instalao do Android Development Tools (ADT) necessrio abrir o Eclipse, acionar
o menu Help e em seguida clicar na opo Install New Software. Em seguida, acionar o boto Add e
efetuar o preenchimento dos campos conforme sequncia a seguir:
Figura 77 Instalando ADT
91
Unidade III
Lembrete
Na pgina de download, efetuar o download da verso mais atual do

Eclipse IDE for Java EE Developers especfica para o Sistema Operacional e
plataforma de desenvolvimento escolhida (32 ou 64 bits, de acordo com o
hardware de utilizao).
Resumo
Apresentamos conceitos de desenvolvimento Android, toda a

sua plataforma de arquitetura, bem como conceito fundamentais de
desenvolvimento de aplicativos mveis.
A configurao de ambiente de trabalho de extrema importncia para

o desenvolvimento de aplicativos mveis, criandose todo o ambiente e
instalao de plugins que so responsveis pela execuo e compilao
das aplicaes.
Toda a instalao provm de um kit disponibilizado pela Oracle, que

possibilita o download, bem como a orientao da instalao em diversas
IDEs de trabalho, como o Eclipse e o NetBeans, que possibilitam o trabalho
de desenvolvimento de aplicativos mveis.
A arquitetura de trabalho em Android subdivida em camadas, o que

possibilita o desenvolvimento com segurana, a distribuio eficaz do
cdigo e eficincia na execuo do cdigo.
O Android vem ganhando espao no desenvolvimento de novas

tecnologias, visto que a necessidade por novos aplicativos que atendam
demanda do mundo cresce gradativamente.
92
Desenvolver aplicaes mveis requer o conhecimento de suas verses,

bem como sua arquitetura de desenvolvimento e criao de ambiente nas
IDEs selecionadas para o desenvolvimento eficiente de uma aplicao.
93
Unidade IV
Unidade IV
7 PROGRAMAO ANDROID
7.1 Criando um projeto do Android
Para a criao de um projeto Android, devem ser executados os seguintes passos:
Abrir o Eclipse e entrar na opo File > New > Project.
Na tela Project dever acessar a opo Android > Android Application Project:
O campo Application Name delimita o nome que ser apresentado na Play Store. Iremos
preencher o campo com o valor: HelloWorld.
O campo Project Name utilizado apenas pelo Eclipse para identificao do projeto e dever
ser nico por workspace. Ser preenchido este campo com o valor: HelloWorld.
O campo Package Name delimitado pelo nome do pacote padro para o aplicativo Android.
Ser preenchido com o valor: br.com.unip.helloworld.
O campo Minimum Required SDK utilizado para especificar a verso mnima do Android
que a aplicao ir suportar. Ser selecionada a opo API 8: Android 2.2 (Froyo).
O campo Target SDK serve para documentar a verso do Android que ser utilizada para
testar/homologar o aplicativo.
O campo Compile With serve para documentar a verso da API que ser usada para compilar
o projeto. Ser selecionada a opo API 23: Android 5.1
O campo Theme serve para documentar o tema (padro de estilo/cor) para as telas do
aplicativo. Ser alocado nesse campo o valor padro.
Ao criar o projeto, dever ser criado tambm uma Activity. Para a execuo de uma Activity ser
marcada a opo Create Activity, ser tambm selecionada a opo Create Project in Workspace.
O assistente ser apresentado na prxima etapa questionando qual ser o estilo da nova Activity que
dever ser criada. Ser selecionado o item BlankActivity para desenvolver uma nova Activity padro:
94
O campo Activity Name serve para documentar o nome da Activity padro que ser gerada de
maneira automtica. Informamos o valor: HelloWorldActivity.
O campo Layout Name serve para documentar o nome do arquivo de layout da Activity. Ser
informado o valor: Activity_hello_world.
O campo Navigation Type serve para documentar o tipo de navegao da Activity. Ser
selecionada a opo: None.
Figura 80 Configurar projeto para HelloWorld
7.2 Executar o projeto
Para que o projeto HelloWorld possa ser executado, devem ser realizados os seguintes passos:
Abrir a opo Run>Run Configuration.
Na prxima ao, definir a opo Android Application e acionar o boto New Android
Configuration:
Logo a diante, na tela de configurao, o campo Name ser preenchido com o valor de
HelloWorld.
95
Unidade IV
Na aba Android, na opo Project, ser acionado o boto Browse, selecionado o projeto
HelloWorld e, na sequncia, o boto OK.
Ainda situado na aba Android, ser selecionada a opo Launch e a Activity HelloWorldActivity.
Acionando o boto Apply e, em seguida, o boto Run, o aplicativo ser inicializado.
Aps a execuo dos passos solicitados, ser criado e executado o emulador do Android, rodando
com o aplicativo HelloWorld.
Figura 81 Configurar a execuo do aplicativo HelloWorld
Descrevendo um pouco da estrutura do Android, preciso saber que ela composta pelos seguintes
componentes:
Activities.
Services.
Content Providers.
Broadcast Receivers.
96
Activities Services
Android
Broadcast Content
receivers providers
Figura 82 Cenrio de aplicativo Android
O diretrio src da estrutura do projeto onde se localizam todas as classes em Java. Neste diretrio
podem ser localizados arquivos de cdigofonte .java e todos os pacotes que o contemplam.
Na concepo do projeto foi necessria a configurao da propriedade package name, que pode ser
representada como o pacote padro das classes .java.
Observao
Trabalhar com subpacotes dentro do pacote principal pode organizar

as classes .java do projeto de tal maneira a customizar o trabalho e atuar
tambm com uma boa prtica e melhora da organizao e entendimento
do projeto.
No diretrio gen estaro concentradas todas as classes geradas de maneira automtica pelo SDK
do Android, ou seja, aqui encontramse todas as classes que o Android utilizar de maneira interna
para execuo do projeto, como a classe R.java, que determinada como classe onde esto alocadas as
constantes de acesso aos recursos de aplicativos, e a classe BuildConfig.java, que determinada como
classe que aloca configuraes do projeto.
Todo o contedo de diretrio gerado de maneira automtica e no pode, em hiptese alguma,

alterar o contedo de nenhuma classe pertencente a esses diretrios.
Observao
Neste momento, tenha em mente que este diretrio no deve ter seu
contedo alterado, ou seja, no altere o contedo de nenhuma classe deste
diretrio.
O diretrio assets utilizado para alocar recursos extras de aplicativos, como arquivos de texto,
pginas HTML, arquivos de udio etc.
O diretrio bin onde esto alocados todos os arquivos gerados no momento da construo (build)
do aplicativo, como o pacote .apk (pacote para efetuar a instalao do aplicativo no Android).
97
Unidade IV
O diretrio res onde se localizam todos os recursos da aplicao e tambm existem subdiretrios
para cada parte do recurso, como:
Diretrio drawable: onde ficam alocados recursos de imagem do aplicativo (por exemplo,
arquivos com extenso .jpg, .png etc).
Diretrio layout: onde ficam alocados arquivos XML com o layout de todas as telas do aplicativo.
Diretrio values: onde ficam alocados recursos do aplicativo executado, como String Resources
e layout de Preferncias.
7.3 O arquivo AndroidManifest.xml
O AndroidManifest.xml (main.XML) um arquivo do tipo XML em que ficam alocadas todas as

configuraes necessrias para a execuo do aplicativo Android. Ele adicionado por default na
aplicao com o nome de main.XML.
Nesse arquivo efetuada toda a configurao de componentes como os Services, as Activities, os

Broadcast Receivers e os Content Providers. Para fins de desenvolvimento e execuo da aplicao, esse
arquivo de uso obrigatrio no diretrio raiz do aplicativo. Vale ressaltar alguns itens do AndroidManifest.
xml, como:
O nome do pacote padro do projeto.
A configurao dos componentes usados no desenvolvimento do aplicativo.
A verso da API do Android que o aplicativo ir suportar no ciclo de vida.
A verso do prprio aplicativo no prprio ciclo de vida.
Vale ressaltar tambm que no arquivo AndroidManifest.xml so definidas informaes de permisses

que o aplicativo necessita executar na plataforma Android:
98
Figura 83 AndroidManifest.xml: HelloWorld
Lembrete
O arquivo AndroidManifest.XML adicionado por default na aplicao

com o nome de main.XML.
android:versionCode: esta propriedade do xml obrigatria e efetua a definio da verso que

ser utilizada no aplicativo Android. O contedo desta propriedade deve ser um nmero inteiro,
iniciado por 1 e incrementado a cada nova verso que for criada de um aplicativo.
android:versionName: esta propriedade tambm definida de maneira obrigatria e estabelece

uma verso comercial do aplicativo Android.
android:minSdkVersion e android:targetSdkVersion: delimitam a verso mnima da API

do Android suportada pela sua aplicao e a verso da API em que seu aplicativo foi testado/
homologado, respectivamente.
application: dentro desta tag ser efetuado o registro dos componentes que o aplicativo ir
utilizar, como as Activities.
99
Unidade IV
7.4 Efetuando debug no aplicativo
O ADT possibilita ao desenvolvedor realizar o debug de aplicativos Android. Debugar um aplicativo

com o ADT pode ser uma tarefa bem tranquila, visto que um dos pontos para se efetuar o debug seria
adicionar um breakpoint na linha desejada e executar o aplicativo em modo de debug, da mesma forma
como feito atualmente em um aplicativo Java para desktop.
Figura 84 Realizando debug do aplicativo HelloWorld
Lembrete
Todos os cdigosfonte inseridos neste livrotexto podem ser executados

tanto na IDE Eclipse como na NetBeans. O conceito de desenvolvimento
de aplicaes mveis pode ser inserido nas IDEs, cada uma com sua
particularidade de configurao de ambiente de execuo da aplicao
mvel.
7.5 Activities
Um aplicativo Android constitudo por componentes e, nessa relao, encontrase o Activity.

Podese definir que as classes Activities so responsveis por controlar os eventos do aplicativo.
Uma classe Activity precisa obrigatoriamente ser herdada da classe android.app.Activity encapsulada
na API do Android.
100
Figura 85 Classe HelloWorldActivity, contida no projeto HelloWorld
7.6 Views
So componentes grficos utilizados para desenvolvimento de telas dentro do aplicativo Android e esto
obrigatoriamente interligadas pelas Activities, que, por sua vez, controlam todo o seu comportamento.
TextView: componente para trabalhar com texto na tela do aplicativo.
EditText: componente de entrada de texto via aplicativo.
Button: boto que, quando acionado, direciona a um evento.
CheckBox: definio de caixa de seleo.
Gerenciador de layout: View que concentra outras Views, ou pode ser definido tambm como
um agregador de Views.
7.7 Mtodo setContentView()
As Activities concentram um mtodo chamado setContentView(), que serve para definir a View que
ser renderizada na tela do aplicativo Android. A Activity HelloWorldActivity do projeto HelloWorld, por
exemplo, faz uma chamada para este mtodo, referenciando como parmetro a View a ser demonstrada
na tela, nesse caso, o arquivo de layout Activity_hello_world.xml.
7.8 Criar uma Activity
Para que seja efetuada a criao de uma Activity, devese acessar a IDE Eclipse, clicar com o boto
direito no projeto criado e seguir a rota: New > Other. Quando a prxima janela for apresentada, efetuar
a seleo da opo Android > Android Activity.
101
Unidade IV
Figura 86 Tela inicial para criao de uma Activity
Figura 87 Criao de uma Activity
102
Aps esse passo, definir qual template ser utilizado para a tela nova de Activity.
Activity Name: ser definida como o nome da Activity.
Layout Name: definio do nome do arquivo do layout da Activity.
Title: ttulo que ser atribudo para a Activity.
Figura 88 Criao de uma Activity
Figura 89 Executando Activity no emulado Android
103
Unidade IV
Observao
Notase que o ADT efetuou a gerao automtica de uma nova Activity

e uma nova tela agregada a essa Activity, encapsulando a mensagem
HelloWorld na parte central da tela.
8 INTERFACES GRFICAS
A partir deste momento, iremos entender conceitos encapsulados na plataforma Android, de

maneira que o aplicativo possa ser implementado de forma que possa ser instalado e homologado com
validaes, persistncias e acesso ao banco de dados.
A tela de um aplicativo Android pode ser composta por um componente denominado como
View. A herana desse componente est localizada na classe android.view.View, e pode ter uma
variedade de tipos.
ImageView
TextView
View group View
EditText
Button
RelativeLayout LinearLayout GridLayout
Figura 90 Diagramao de componentes View do Android
Para a criao de um layout, ele dever ser baseado em um arquivo XML de layout do Eclipse, onde a
ao a ser executada ser o acionamento do boto direito do mouse sobre o projeto do Android e aps
essa ao dever ser direcionado at a opo New > Other, assim selecionando a opo Android>Android
XML layout File e acionar o boto Next.
104
Figura 91 Tela para efetuar inicializao da criao de um novo layout
Figura 92 Tela para efetuar inicializao da criao de um novo layout
105
Unidade IV
Na descrio do campo File, ser definido o nome do arquivo de definio de layout e na opo Root
Element ser atribudo o tipo de layout que ser utilizado.
8.1 TextView
Uma TextView , sem dvidas, a View mais utilizada na concepo de um aplicativo Android, e tem
por funcionalidade apresentar texto no display do dispositivo mvel:
Figura 93 Sintaxe de uma TextView definida em um arquivo de layout Android
Observao
O atributo android:text serve para introduzir o texto a ser apresentado

pela TextView. Atuando com trabalho de boas prticas, importante, sempre
que possvel, centralizar os textos a serem apresentados em um String
Resource, para que as mensagens sejam reaproveitadas em locais distintos
do aplicativo e para se ter um ganho no suporte internacionalizao.
Ainda atuando com o trabalho sobre o componente android:text, podese alterar algumas definies
de texto, como:
Quadro 10 Definio de estilo de textos
Estilo Implementao
Negrito Texto em negrito
Itlico Texto em Itlico
Sublinhado Texto sublinhado
106
No arquivo String Resources podem estar contidas as alteraes para negrito, itlico e sublinhado:
Figura 94 Definio dos componentes Text
8.2 EditText
Uma View EditText pode ser compreendida pela ao de efetuar carga em um campo prdeterminado
por meio de recursos como teclado e/ou dispositivo mvel.
Figura 95 Sintaxe para aplicao da View EditText
Ainda possvel trabalhar com a definio de tipo de dado que ser alocado pelo cliente em um
EditText, para isso fazemos referncia ao atributo android:inputType.
Quadro 11 Tipo de dados de entrada em um EditText
inputType Tipo de entrada de dados que so aceitos

Text Texto
Phone Nmero de Telefone
textPassword Senha alfanumrica
numberPassword Senha numrica
107
Unidade IV
Number Nmeros
Date Data
textMultiline Texto com quebra de linhas
textEmailAddress Endereo de email
Figura 96 Cdigo EditText, que trabalha somente com nmeros
Observao
A definio de tipo de dado que o cliente ir alocar em uma EditText

uma boa prtica, impossibilitando, por exemplo, que um texto possa ser
inserido em um campo que deveria receber apenas nmeros.
Para que um dado possa ser trafegado e inserido em um objeto String dentro da Activity, ser
desenvolvida a seguinte linha de cdigo:
Figura 97 Expresso para captura de informaes
8.3 CheckBox
O trabalho com a View CheckBox se resume atuao de uma caixa de seleo, que visa efetuar a
marcao ou desmarcao de informaes no aplicativo Android.
108
Figura 98 Sintaxe da View Checkbox do aplicativo Android
Dentro da Activity, podese definir se a View CheckBox est selecionada ou no por meio do cdigo
a seguir:
Figura 99 Validao da View CheckBox, com a propriedade IsChecked
Observao
As validaes de sintaxe dos componentes apresentados neste

livrotexto devero ser inseridas, por exemplo, em mtodos criados na
classe Activity do seu projeto Android (exemplo: CapturarIDActivity.java).
Public class CapturarIDActivity extends Activity {
@Override
public void OnCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanteState);
setContentView(R.layout.activity_cadastro_aluno_id);
TextView estudanteUnipInterativa = (TextView)findViewById(R.
id.estudanteUnipInterativa);
Texto.setText(Seja bem vindo Unip Interativa);
}
}
Efetuando acesso ao TextView do XML alocado no layout, definido

previamente por meio do seu ID e definido o texto correspondente.
109
Unidade IV
8.4 RadioButton
A View RadioButton tem por finalidade agregar um grupo de botes onde apenas uma linha de
informao possa ser selecionada. Para garantir o sucesso da codificao da View RadioButton, dever
ser acoplada ao desenvolvimento do cdigo uma outra View chamada de RadioGrup, nela somente um
RadioButton poder ser selecionado.
Figura 100 Sintaxe de um RadioButton, que definido no arquivo de layout
Figura 101 Sintaxe da View Radiobutton
8.5 ImageView
A View ImageView pode ser utilizada para apresentar uma imagem no aplicativo Android.
110
Figura 102 Sintaxe da View ImageView
8.6 Button
A View Button pode ser conceituada como um boto que apresentado na tela do aplicativo Android.
Funcionalidades so derivadas para o evento de cada boto alocado em tela.
Figura 103 Sintaxe da View Button
Na definio do boto, podese utilizar uma Activity, usando o mtodo setOnClickListener(). Para
que esse mtodo seja utilizado de maneira efetiva no desenvolvimento do aplicativo Android, fazse
necessria a implementao da interface android.view.View.OnclickListener, assim subscrevendo o
mtodo OnClick(), que ser executado aps o boto Sair ser acionado.
111
Unidade IV
Figura 104 Implementao inicial do boto Sair
Figura 105 Implementao final do boto Sair
8.7 DatePicker
A View DatePicker possibilita ao desenvolvedor definir qualquer parmetro de data a ser utilizado
no aplicativo Android.
Figura 106 Sintaxe da View DatePicker
Na alocao da classe Activity, fazse necessria a recuperao da View DatePicker para utilizao
no desenvolvimento do aplicativo.
112
DatePicker dataNascimento = (DatePicker) findViewById(R.Id.data_nascimento)
Com o objeto DatePicker, podese obter tambm:
Figura 107 Obtendo data com o objeto DatePicker
Observao
O mtodo getMonth() do objeto DatePicker, utilizado frequentemente

para leitura do ms selecionado pelo usurio, inicia sempre com o valor
0 (zero). Se o usurio selecionar o ms de maio, por exemplo, o mtodo
getMonth() retornar o valor 4 em vez de 5. Contudo, caso o retorno precise
ser obtido por meio do nmero real que represente o ms selecionado,
dever ser adicionada a esse valor uma unidade, apresentandose da
seguinte maneira:
int mes = dataNascimento.getMonth() + 1;
8.8 TimePicker
A View TimerPicker pode ser utilizada no desenvolvimento de aplicativos Android como um

componente capaz de proporcionar definies de horrios.
Figura 108 Sintaxe da View TimePicker
Na alocao da classe Activity, necessria a recuperao da View TimePicker para utilizao no

desenvolvimento do aplicativo.
113
Unidade IV
TimePicker dataNascimento = (TimePicker) findViewById(R.Id.horario)
Com o objeto TimePicker, podese obter tambm:
Figura 109 Obtendo data com o objeto TimePicker
8.9 Layouts
Layouts so basicamente Views que, agrupadas, trabalham a fim de garantir a facilidade na disposio
dos componentes de tela.
8.9.1 Linear layout
O LinearLayout pode ser utilizado para efetuar o alinhamento de todos os componentes alocados no
aplicativo Android de maneira horizontal e vertical, de forma que as Views possam atuar no cenrio lado
a lado ou uma em cima da outra. Para executar o cenrio de Views uma embaixo da outra, trabalhase
utilizando a propriedade android:orientation=vertical:
Figura 110 Android:orientation=vertical
Para desenvolver a visualizao de componentes de maneira horizontal, organizando na View usando

a propriedade android:orientation=horizontal:
114
Figura 111 Android:orientation=horizontal
8.9.2 Table layout
TableLayout utilizada para efetuar a ordenao de componentes em forma de tabela, toda tabela
definida por linhas e colunas, sendo suas linhas definidas como TableRow, e as colunas strechColumns,
responsvel pela alocao de todas as colunas na tabela de layout.
Figura 112 Arquivo layout utilizando TableLayout
115
Unidade IV
A propriedade android:stretchColumns atua com a finalidade de esticar uma coluna da View

TableLayout, delimitando toda a tela do aplicativo Android, recebendo por aplicao, como parmetro,
o nmero da coluna na qual ser esticada, iniciando obrigatoriamente pelo valor zero, que tem por
referncia de desenvolvimento a primeira linha.
8.10 Intent
Uma Intent tem como finalidade distribuir mensagens enviadas por um componente de um aplicativo
ao ncleo do Android, indicando a inteno de realizar uma ao, ou seja, fazer algo no sistema. Intent
possibilita a solicitao para o Android instanciar um determinado componente do aplicativo ou um
componente de um outro aplicativo instalado no dispositivo.
As Intents possibilitam que os aplicativos possam, eventualmente, comunicaremse uns com os outros,
possibilitando que um aplicativo reutilize as funcionalidades disponibilizadas por outros aplicativos:
Instncia de uma determinada Activity de um aplicativo.
Instncia de um Service para executar um servio em segundo plano.
Envio de um Broadcast para o Android.
Efetuar seleo de um determinado contato no aplicativo de contatos do Android e obter seus

dados em layout View.
Abrir o aplicativo de mapas do Android, dada uma coordenada desejada.
Executar uma pgina da Web.
Efetuar uma ligao para um nmero de telefone por meio do aplicativo do Android.
Envio de um SMS com base em um aplicativo de mensagem do Android.
A classe Intent do Android consegue definir algumas constantes com as Actions que so
nativas da plataforma:
Quadro 12 Actions nativas de aplicativo Android
Constante Tipo de Componente Ao

ACTION_CALL Activity Inicia o aplicativo de telefonia
ACTION_EDIT Activity Exibe a tela para edio de um determinado dado
ACTION_MAIN Activity Abre a Activity inicial de um aplicativo
ACTION_SYNC Activity Sincroniza os dados do dispositivo com os dados do servidor
ACTION_BATTERY_LOW Broadcast Receiver Aviso de bateria fraca
116
ACTION_HEADSET_PLUG Broadcast Receiver Aviso de headset plugado ou desplugado do dispositivo

ACTION_SCREEN_ON Broadcast Receiver Aviso de tela acesa
8.11 Broadcast Receivers
Broadcast Receivers um componente do Android que permite responder a determinadas requisies

enviadas pelo sistema. A todo instante o Android envia notificaes sobre a realizao de eventos que
acontecem no momento da execuo do aplicativo. Essas mensagens recebidas so denominadas de
BroadCast e o componente responsvel por essa funcionalidade denominado BroadCast Receivers.
Um BroadCast tambm pode ser trabalhado com o envio tanto de aplicativos nativos do Android,
como podem ser trafegados por aplicativos desenvolvidos de maneira aleatria.
O BroadCast tambm sinaliza um trabalho em conjunto com a Activity, apresentando cada instncia
efetuada na execuo do aplicativo Android.
Quadro 13 BroadCast nativos para aplicativo Android
BroadCast Descrio
ACTION_BATTERY_LOW Enviado quando a bateria do dispositivo est com a carga baixa.
ACTION_HEADSET_PLUG Enviado quando um fone de ouvido conectado ou desconectado do dispositivo.
ACTION_SCREEN_ON Enviado quando a tela do dispositivo ligada.
NEW_OUTGOING_CALL Enviado quando uma nova chamada telefnica efetuada.
BOOT_COMPLETED Enviado quando o sistema completa o boot inicial.
ACTION_POWER_CONNECTED Enviado quando o dispositivo conectado energia.
ACTION_POWER_DISCONNECTED Enviado quando o dispositivo desconectado da energia.
CAMERA_BUTTON Enviado quando o boto da cmera disparado.
8.12 Services
Services um componente nativo do Android que tem por finalidade executar diversas tarefas em
segundo plano. Efetuando um contraponto com o componente BroadCast Receivers, os Services podem,
em tempo de execuo de aplicativos, executar tarefas encapsuladas no sistema de maneira demorada,
como, por exemplo, o envio de um email.
Services tambm tem como conceito a ordenao e a priorizao de tarefas na execuo do

aplicativo, ou seja, efetua tambm a gesto de tarefas com o objetivo de garantir espao em memria
para a execuo de tarefas dentro do aplicativo Android.
Um Service pode ser inicializado por qualquer componente do Android, ou at mesmo por um
BroadCast Receiver ou uma Activity, ou ser inicializado de maneira automatizada.
117
Unidade IV
Figura 113 Exemplo de Services
O mtodo onCreate() executado apenas uma vez, quando o Service inicializado na execuo
da aplicao.
O mtodo onStartCommand() executado toda vez que o Service inicializado, por meio
do mtodo startService(), e recebe como parmetro a Intent utilizada em sua chamada de
inicializao.
O mtodo onBind() precisa ser obrigatoriamente implementado em um Service de inicializao.

Este mtodo nos permite conectar a um Service em execuo e controllo de maneira simultnea
na aplicao.
O mtodo onDestroy() executado apenas uma vez, quando o Service finalizado. Essa ao
possibilita que todo o contedo do mtodo seja destrudo em tempo de execuo.
118
Saiba mais
O conceito de ciclo de vida de uma aplicao Android de extrema

importncia para a compreenso do desenvolvimento de aplicativos moveis.
Para realizar um estudo desse conceito, acesse:
SILVA, F. M. C. da. Entendendo o ciclo de vida de uma aplicao Android.

Devmedia, Rio de Janeiro, [s.d.]. Disponvel em: <http://www.devmedia.
com.br/entendendoociclodevidadeumaaplicacaoandroid/22922>.
8.13 Persistncia de dados
O Android se utiliza do banco de dados SQLite, que um banco de dados open source embarcado,
que possibilita a manipulao de todos os dados do aplicativo Android por meio de instrues SQL que
podem ser efetuadas na base, como insert, update, delete e select.
Um dos pontos de destaque para o SQLite a preocupao com a segurana, trabalhando com
conceitos exclusivos que possibilitam somente aos usurios Android terem acesso ao banco de dados,
ou seja, h aplicao de conceitos de segurana, como validao de chave de acesso e senhas confiveis.
O Android disponibiliza tambm uma classe chamada SQLiteOpenHelper, que tem por finalidade
prover recursos para que o aplicativo Android defina e construa uma estrutura de dados. Esta classe
pode ser estendida para os seguintes mtodos:
onCreate(): mtodo responsvel por criar a estrutura do banco de dados.
onUpgrade(): mtodo responsvel por atualizar a estrutura do banco de dados, caso ela necessite
de alguma modificao.
119
Unidade IV
Figura 114 Definio de estrutura de Banco de Dados
Figura 115 Exemplo de insero de valores utilizando SQLite
Saiba mais
Para um estudo mais aprofundado sobre o banco de dados SQLite,

recomendase o acesso ao seguinte site:
CHAVES, J. Trabalhando com o banco de dados SQLite. Linha de cdigo,

Rio de Janeiro, 13 fev. 2009. Disponvel em: <http://www.linhadecodigo.
com.br/artigo/2215/trabalhandocombancodedadossqlite.aspx>.
120
Resumo
Abordamos todos os requisitos para o desenvolvimento de aplicativos para

a plataforma Android. Foram vistos, por exemplo, conceitos fundamentais,
tais como as Views, que so responsveis pela visualizao dos layouts
das aplicaes Android, bem como a concepo da classe Activity, que
proporciona ao desenvolvedor a distribuio do cdigo e a estruturao da
arquitetura para o desenvolvimento utilizando a plataforma Android.
Tambm ilustramos toda a construo de ambiente de desenvolvimento

para aplicativos Android, como Activity e Views, que podem sair de
um levantamento de requisitos ou prototipao efetuados para o
desenvolvimento do aplicativo.
O AndroidManifest.xml so arquivos do tipo XML em que ficam alocadas

todas as configuraes necessrias para a execuo do aplicativo Android.
Nesses arquivos so efetuadas todas as configuraes de componentes como
os Services, as Activities, os Broadcast Receivers e os Content Providers.
Abordamos ainda como efetuar o debug de uma aplicao Android,

identificando falhas e mitigando erros no processo de concepo do aplicativo.
Apresentamos tcnicas de desenvolvimento de layout para aplicativo

Android, bem como toda a estrutura de execuo.
Tambm estudamos: o banco de dados SQLite, que tem por finalidade

efetuar a incluso, consulta, excluso e alterao de dados para usurios
exclusivos da plataforma Android; o BroadCast Receiver, que efetua toda
a gesto de tarefas para controle de liberao de espao em tempo de
execuo do aplicativo Android; bem como os Services, que efetuam a
gesto simultnea de servios encapsulados na plataforma Android.
Vimos tambm o componente Intent, que tem como finalidade distribuir

mensagens ao ncleo do Android, indicando a inteno de um componente
de realizar uma ao, ou seja, fazer algo no sistema.
121
REFERNCIAS
Textuais
ABLESON, W. F. et al. Android em ao. 3. ed. Rio de Janeiro: Campus, 2012.
BENYON, D. Interao humanocomputador. 2. ed. So Paulo: Pearson Prentice Hall, 2011.
CHAVES, J. Trabalhando com o banco de dados SQLite. Linha de cdigo, Rio de Janeiro, 13 fev. 2009.
Disponvel em: <http://www.linhadecodigo.com.br/artigo/2215/trabalhandocombancodedados
sqlite.aspx>. Acesso em: 20 out. 2015.
CLASS JOptionPane. Oracle.com, 2014. Disponvel em: <https://docs.oracle.com/javase/7/docs/api/

javax/swing/JOptionPane.html>. Acesso em: 19 out. 2015.
DEITEL, H. M.; DEITEL, P. J. Java: como programar. 6. ed. So Paulo: Pearson Prentice Hall, 2005.
DEITEL, H. M.; DEITEL, P. J. Java: como programar. 8. ed. So Paulo: Pearson Prentice Hall, 2010.
HORSTMANN, C. S.; CORNELL, G. Core Java. 8. ed. So Paulo: Pearson Prentice Hall, 2010.
JORGE, M. Java: passo a passo Lite. So Paulo: Makron Books, 2004.
LECHETA, R. R. Google Android: aprenda a criar aplicaes para dispositivos mveis com o Android
SDK. 3. ed. So Paulo: Novatec, 2013.
MEDEIROS, E. S. de. Desenvolvendo software com UML 2.0: definitivo. So Paulo: Pearson Makron
Books, 2004.
MENDES, D. R. Programao Java com nfase em orientao a objetos. So Paulo: Novatec, 2009.
ORACLE. Arrays. The Java Tutorials. 2015a. Disponvel em: <https://docs.oracle.com/javase/tutorial/java/

nutsandbolts/arrays.html>. Acesso em: 15 out. 2015.
ORACLE. The ifthen and ifthenelse statements. The Java Tutorials. 2015b. Disponvel em: <https://
docs.oracle.com/javase/tutorial/java/nutsandbolts/if.html>. Acesso em: 15 out. 2015.
ORACLE. The for statement. The Java Tutorials. 2015c. Disponvel em <https://docs.oracle.com/javase/
tutorial/java/nutsandbolts/for.html>. Acesso em: 15 out. 2015.
ORACLE. The switch statement. The Java Tutorials. 2015d. Disponvel em: <https://docs.oracle.com/
javase/tutorial/java/nutsandbolts/switch.html>. Acesso em: 15 out. 2015.
122
ORACLE. The while and dowhile statements. The Java Tutorials. 2015e. Disponvel em: <https://docs.
oracle.com/javase/tutorial/java/nutsandbolts/while.html>. Acesso em: 15 out. 2015.
PAGEJONES, M. Fundamentos do desenho orientado a objeto com UML. So Paulo: Makron Books, 2001.
PISA, P. A evoluo do Linux. TechTudo, 23 maio 2012. Disponvel em: <http://www.techtudo.com.br/

artigos/noticia/2012/05/aevolucaodolinux.html>. Acesso em: 19 out. 2015.
RINALDI, C. Android 6.0 Marshmallow: review e todas as funes. AndroidPIT, 7 out. 2015. Disponvel
em: <http://www.androidpit.com.br/androidmdispositivosdatalancamentofuncoes>. Acesso em:
14 out. 2015.
ROGERS, Y.; SHARP, H.; PREECE, J. Design de interao: alm da interao humanocomputador. 3. ed.
Porto Alegre: Bookman, 2013.
SILVA, F. M. C. da. Entendendo o ciclo de vida de uma aplicao Android. Devmedia, Rio de Janeiro,
[s.d.]. Disponvel em: <http://www.devmedia.com.br/entendendoociclodevidadeumaaplicacao
android/22922>. Acesso em: 18 out. 2015.
SINTES, T. Aprenda programao orientada a objetos em 21 dias. So Paulo: Pearson Education do

Brasil, 2002.
SOUZA, L. S. de. Projeto de interface com o usurio. So Paulo: Sol, 2015.
SOUZA, L. S.; COSTA, I.; SPINOLA, M. M. Projetos de interface com o usurio de software de dispositivos
mveis: requisitos de usabilidade e fatores impactantes. In: SIMPSIO DE ENGENHARIA DE PRODUO
(SIMPEP), 13., 2006, Bauru. Anais Bauru: Unesp, 2006. Disponvel em: <http://www.simpep.feb.unesp.
br/anais/anais_13/artigos/851.pdf>. Acesso em: 13 out. 2015.
Sites
<http://www.androidpit.com.br>.
<http://developer.android.com/sdk/index.html>.
<https://docs.oracle.com/javase/tutorial/collections/index.html>.
<https://docs.oracle.com/javase/tutorial/essential/exceptions/index.html>.
<https://docs.oracle.com/javase/tutorial/java/data/index.html>.
<https://docs.oracle.com/javase/tutorial/java/index.html>.
<http://www.eclipse.org>.
123
<http://www.eclipse.org/downloads/>.
<https://netbeans.org>.
<http://oracle.com.edgesuite.net/timeline/java/>.
<http://www.oracle.com/technetwork/java/javase/downloads/index.html>.
<http://www.oracle.com/technetwork/java/javase/overview/index.html>.
<https://www.sqlite.org/>.
<http://staruml.io/>.
124
125
126
127
128
Informaes:
www.sepi.unip.br ou 0800 010 9000

Tópicos Especiais de Programação Orientada A Objetos

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Tópicos Especiais de Programação Orientada A Objetos

Enviado por

Direitos autorais:

Formatos disponíveis

Tpicos Especiais de

Jos Cassiano Grassi Gunji Luciano Soares de Souza

Leciona h mais de oito anos as disciplinas de

Dados Internacionais de Catalogao na Publicao (CIP)

G975t Gunji, Jos Cassiano Grassi.

Tpicos especiais de programao orientada a objetos. / Jos

128 p., il.

Nota: este volume est publicado nos Cadernos de Estudos e

11. Interfaces grficas. 2. Linguagem JAVA. 3. Programao

Prof. Fbio Romeu de Carvalho

Profa. Melnia Dalla Torre

Prof. Dr. Yugo Okida

Profa. Dra. Marlia Ancona-Lopez

Unip Interativa EaD

Profa. Elisabete Brihy

Material Didtico EaD

Inicialmente, veremos os conceitos relacionados tecnologia de programao Java e como essa

Em seguida, sero apresentados os conceitos relacionados computao mvel e ao ambiente de

O conhecimento tecnolgico dos homens propiciou a criao de diversos mecanismos capazes de

Com o desenvolvimento da tecnologia e com o surgimento dos computadores digitais, foram

Os computadores modernos, independentemente da arquitetura ou fabricante, apenas conseguem

Figura 1 Exemplo de um cdigo de computador em hexadecimal

1.1 Um breve histrico

Est disponvel (em ingls) uma linha do tempo detalhada do

1.2 Arquitetura de um programa em Java

Computador padro PCIntel executando Windows.

Computador padro PCIntel executando Linux.

Computador padro iMac executando Mac OS.

Computador padro workstation executando Solaris.

Diversas linguagens, como o C++, por exemplo, esto disponveis para

Um computador s consegue executar programas que estejam escritos

Cdigofonte Compilador Bytecode Mquina Programa em

Figura 2 Processo de compilao e execuo de um programa em Java

1.3 Caractersticas da linguagem Java

1.3.2 Orientao a objetos

O Java uma linguagem que permite o multiprocessamento (multithreading). Isso significa

Vrios livros que abordam a programao em Java apresentam a

MENDES, D. R. Programao Java com nfase em orientao a objetos.

1.4 O que necessrio para se programar em Java

Java Standard Edition (Java SE).

Java Enterprise Edition (Java EE).

Java Micro Edition (Java ME).

As demais distribuies so complementos ao Java SE que disponibilizam outras capacidades

Ferramenta de automao de compilao.

Ferramenta de automao de depurao.

O Eclipse um IDE de cdigo aberto de grande popularidade. Outro

Todos os cdigosfonte inseridos neste livrotexto podem ser executados

O Eclipse pode ser obtido da pgina de seu desenvolvedor:

O NetBeans pode ser obtido da pgina:

1.4.1 Instalando o JDK Java SE

V at o site de download do Java <http://www.oracle.com/technetwork/java/javase/downloads/index.

Figura 3 Assistente de instalao do SDK Java SE

Para se desenvolver em qualquer tecnologia Java, a nica distribuio

1.4.2 Instalando o Eclipse

V at o site de download do Eclipse <http://www.eclipse.org/downloads/>. Selecione o download

Figura 5 Seleo do workspace (pasta de trabalho)

Figura 6 Pgina de boasvindas do Eclipse

Clique no cone Workbench para exibir a rea de trabalho.

Figura 7 rea de trabalho do Eclipse

Figura 8 Assistente de criao de projeto

Em qualquer linguagem de programao, sempre recomendado no

Figura 9 Seleo de uma mquina virtual especfica

Figura 10 Projeto com sua estrutura expandida