Apostila Android

ATENO: EST EM DESENVOLVIMENTO, TEM MUITOS ERROS
Qualquer coisa manda e-mail para: wellington@aied.com.br
Sobre os Autores
Wellington Pinto de Oliveira formado em Cincia da Computao e entusiasta plataforma mvel desde 2001. Possui experincia com vrias ferramentas, como Sattelite Forms, AppForge, CodeWarrior, NS Basic e HB++, Windows Mobile com Visual Studio. Mestre em Ensino de Cincias atua na rea educacional, mesclando tecnologia e ensino. Atualmente atua como Analista na Venki Tecnologia em Software LTDA e como professor na Faculdade de Tecnologia de So Paulo (FATEC) na qual ministra disciplinas como: Sistemas Operacionais I e II, Redes de Computadores e Teleprocessamento, Interface Humano-Computador, Gerenciamento de Projetos, etc.. Possui muita experincia com aplicaes mveis pois j atuou em dezenas de projetos relacionados, publicou dezenas de artigos, lanou duas apostilas (Windows Mobile e Palm OS com HB++) e um livro sobre desenvolvimento de aplicaes com NS Basic par Palm OS. E-mail para contato: wellington@aied.com.br Wanderson Pinto de Oliveira .... TODO ..... Wallace Pinto de Oliveira ... TODO ... E-mail para contato:
Marcas Registradas
Vrias Marcas Registradas aparecem no decorrer desta obra. Mais do que simplesmente listar estes nomes informar que possui seus direitos de explorao, ou ainda imprimir os logotipos das mesmas, os autores declaram estar utilizando tais nomes apenas para fins editoriais, em benefcio exclusivo do dono da Marca Registrada, sem inteno de infringir as regras de sua utilizao.
Desenvolvendo Aplicaes com Java para Android
Dizeres Legais
Todos os direitos reservados a Wellington Pinto de Oliveira, Wanderson Pinto de Oliveira e Wallace Pinto de Oliveira. Nenhuma parte desta obra poder ser reproduzida, transmitida e gravada, por qualquer meio eletrnico, mecnico, por fotocpia e outros, sem a prvia autorizao, por escrito, dos autores.
Desenvolvendo Aplicaes Mveis com SuperWaba
Indice
SOBRE OS AUTORES ................................................................................................................................... 1! MARCAS REGISTRADAS .............................................................................................................................. 1! DIZERES LEGAIS ........................................................................................................................................... 2! 1 INTRODUO ............................................................................................................................................. 7! Objetivos Deste Captulo ................................................................................................................................. 7! Definindo a Plataforma ................................................................................................................................... 7! Plataforma Mvel ............................................................................................................................................. 8! Plataforma Android ......................................................................................................................................... 9! Requerimentos ................................................................................................................................................ 10! Como est Estruturado o Livro .................................................................................................................... 10! Convenes ..................................................................................................................................................... 10! O Cdigo do Livro.......................................................................................................................................... 11! Download ........................................................................................................................................................ 11! JDK J2SE 6.0 ................................................................................................................................................................ 11! Eclipse 3.6.2 .................................................................................................................................................................. 11! Android SDK ................................................................................................................................................................ 11! 2 INSTALANDO E CONFIGURANDO O AMBIENTE .................................................................................. 12! Objetivos Deste Captulo ............................................................................................................................... 12! Introduo....................................................................................................................................................... 12! Instalando a JDK ........................................................................................................................................... 12! Instalando o Eclipse ....................................................................................................................................... 15! Instalando a SDK do Android....................................................................................................................... 16! Configurando o Eclipse ................................................................................................................................. 20! 3 HELLO WORLD ......................................................................................................................................... 25! Objetivos Deste Captulo ............................................................................................................................... 25! Introduo....................................................................................................................................................... 25! Estrutura do Projeto ...................................................................................................................................... 27! Configurando o Emulador ............................................................................................................................ 30! Executando a Aplicao................................................................................................................................. 32!
4 DEPURANDO E DISTRIBUINDO A APLICAO .................................................................................... 35! Objetivos Deste Captulo ............................................................................................................................... 35! Introduo ...................................................................................................................................................... 35! Atualizando o Sistema ................................................................................................................................... 35! Depurando uma Aplicao pelo Device ....................................................................................................... 36! Deploy ............................................................................................................................................................. 41! 5 A LINGUAGEM .......................................................................................................................................... 44! Objetivos Deste Captulo ............................................................................................................................... 44! Introduo ...................................................................................................................................................... 44! Algoritmos ...................................................................................................................................................... 44! Variveis, Operadores e Estruturas de Controle........................................................................................ 45! Variveis ........................................................................................................................................................................ 45! Tipos de Dados Primitivos ............................................................................................................................................ 45! Declarao de variveis ................................................................................................................................................. 47! Comentrios ................................................................................................................................................................... 48! Operadores ..................................................................................................................................................................... 49! Estruturas de Controle ................................................................................................................................................... 53! Estruturas de controle de erros ...................................................................................................................................... 60! Gerando suas Prprias Excees ................................................................................................................................... 63! 5 PROGRAMAO ORIENTADA A OBJETOS .......................................................................................... 66! Objetivo Deste Apndice ............................................................................................................................... 66! Introduo ...................................................................................................................................................... 66! Especificando uma Classe ............................................................................................................................. 67! Objetos ............................................................................................................................................................ 68! Atributos ......................................................................................................................................................... 68! Coleta automtica de lixo .............................................................................................................................................. 69! Acesso aos atributos e mtodos e alteraes dos atributos ............................................................................................ 70! Mtodos ........................................................................................................................................................... 70! Sintaxe de declarao de mtodos ................................................................................................................................. 70! this ................................................................................................................................................................................. 72! Sintaxe de chamada ou acesso a mtodos ..................................................................................................................... 72! Nova verso do programa Circulo ................................................................................................................................. 72! Construtores ................................................................................................................................................... 74! Destrutores Ou finalizers .......................................................................................................................... 76! Ponteiros, Referncias e Objetos .................................................................................................................. 77! Passagem por Referncia ............................................................................................................................................... 77! Vetores e Matrizes ......................................................................................................................................................... 77! Encapsulamento ............................................................................................................................................. 78! Encapsulando Mtodos e Atributos ............................................................................................................................... 78!
4 Desenvolvendo Aplicaes com Java para Android
Quando Utilizar Encapsulamento?........................................................................................................................... 79! Herana ........................................................................................................................................................... 79! Hierarquia de Tipos ...................................................................................................................................................... 80! Uma Hierarquia Simples ............................................................................................................................................... 80! Construtores e herana .................................................................................................................................................. 81! Protected ....................................................................................................................................................................... 83! Interfaces......................................................................................................................................................... 83! Polimorfismo e Classes Abstratas ................................................................................................................. 85! Redefinio de Mtodos para uma Classe Herdeira ................................................................................... 85! 7 INTERFACE COM O USURIO ................................................................................................................ 86! Objetivo Deste Apndice ............................................................................................................................... 86! Introduo....................................................................................................................................................... 86! View ................................................................................................................................................................. 86! Activity ............................................................................................................................................................ 86! Ciclo de vida de uma Activity ...................................................................................................................................... 87! Editor de Layout ............................................................................................................................................ 90! android.widget ................................................................................................................................................ 98! TextView ...................................................................................................................................................................... 98! EditText ........................................................................................................................................................................ 98! Button............................................................................................................................................................................ 99! ToggleButton .............................................................................................................................................................. 101! RadioButton e RadioGroup ........................................................................................................................................ 103! CheckBox.................................................................................................................................................................... 105! AutoCompleteTextView ............................................................................................................................................. 107! MultiAutoCompleteTextView .................................................................................................................................... 108! Spinner ........................................................................................................................................................................ 113! Data e Hora ................................................................................................................................................................. 116! DatePicker .............................................................................................................................................................. 116! TimePicker ............................................................................................................................................................. 116! CalendarView......................................................................................................................................................... 119! Chronometer........................................................................................................................................................... 119! Imagens e Mdia.......................................................................................................................................................... 122! ImageView ............................................................................................................................................................. 122! ImageButton ........................................................................................................................................................... 128! Gallery .................................................................................................................................................................... 130! Listas e Tabelas ........................................................................................................................................................... 134! ListView ................................................................................................................................................................. 134! ExpandableListView .............................................................................................................................................. 139! APNDICE 1 HABILITANDO DEPURAO ............................................................................................. 161! Objetivo Deste Apndice ............................................................................................................................. 161! Introduo..................................................................................................................................................... 161! APNDICE 2 PERSPECTIVA NO ECLIPSE .............................................................................................. 163! Objetivo Deste Apndice ............................................................................................................................. 163!
Introduo .................................................................................................................................................... 163! APNDICE 3 SHOW VIEW IN PERSPECTIVE .......................................................................................... 164! Objetivo Deste Apndice ............................................................................................................................. 164! Introduo .................................................................................................................................................... 164!
1
1 Introduo
Objetivos Deste Captulo
Conhecer um pouco mais sobre a plataforma Android; Conhecer os requerimentos mnimos para se utilizar o Eclipse e Android; Realizar o download dos arquivos necessrios; Instalar e configurar o ambiente.
Definindo a Plataforma
Este livro est destinado a pessoas que atuam ou pretendem atuar no desenvolvimento de aplicaes mveis para o mercado coorporativo, definimos como tema a plataforma Android por vrios motivos, para entender vamos fazer um retrocesso no tempo e acompanhar os eventos dos ltimos 18 anos do contexto mobilidade. Antes de 1995 a mobilidade era resumida a agendas eletrnicas com programas fixo no hardware, porem em 1995-1996 uma diviso da U.S. Robotics retira do papel o primeiro modelo Personal Digital Assistaints tambm conhecido como PDA. Porem esta empresa passou por problemas judiciais relacionados a patentes entre 1998-2000. Tais problemas internos fez com que a empresa fosse dividia, vendida e unida vrias vezes durante os anos de 2000-2006, estas mudanas constantes fez com que seu hardware evolusse pouco se comparado com o concorrente Windows Mobile. Talvez porque antes de ser lanado ningum acreditava que seria um produto to bem aceito pela complexidade do ambiente para o pblico da poca acostumado com as agendas. S que as empresas viram neste hardware uma opo para levar sua automao para alm da fronteira dos escritrios e parques dotados de computadores, ou seja, este equipamento poderia ir para campo atuar de forma independente e trazer dados para ser computados em computadores de maior porte, as agendas no permitiam isso pois o processo de desenvolvimento e at a capacidade de introduzir novos softwares era muito limitado. Se beneficiando destes problemas internos da Palm a outra fabricante de Sistemas Operacionais chamada Microsoft comea a deslanchar suas vendas do Windows CE, isso porque apoiado em um processador mais forte e desenvolvido por vrias empresas de Hardware (o Sistema Operacional Microsoft e o hardware de terceiros) e mais recursos. Neste perodo pode ento criar uma diviso no perfil do usurio, que o pblico coorporativo e o pblico voltado ao entretenimento. Mercado Coorporativo e Automao Industrial que busca equipamentos com menos distraes a seus funcionrios, que o Sistema Operacional seja estvel e leve, e ainda que o hardware seja barato. Por causa deste pblico que a Palm OS sobrevive entre os anos de 2000-2010 afinal o hardware e Sistema Operacional era ideal para estes fins. O autor deste livro j viu por exemplo um cliente comprar 500 PDAs da marca Palm Z22 com 500 modens Pegasus III em uma nica compra, este kit custou algo em torno de 520,00 Reais (na poca). Se a mesma compra fosse feita da marca concorrente sairia no mnimo por 1300,00 Reais o Kit. Este mercado fora a estabilidade do Hardware e do Sistema Operacional a manter pouca evoluo para manter preos.
J o outro pblico, que busca entretenimento fora o mercado a subir em qualidade o que eleva os preos, a Microsoft lanou inmeras verses de seu Sistema Operacional e por no haver um foco as empresas que desenvolvem hardware para este OS mudaram constantemente de modelos, recursos, muitas apareceram com bons equipamentos e em poucos anos somem. O mercado ficou voltil e recentemente podemos ver que "a prpria cobra mordeu seu rabo" pois a Microsoft est perdendo vendas devido a essa volatilidade do mercado que ela ajudou a criar. Quando decidi escrever um novo material para equipamentos mveis fiquei em dvida entre Android e IOS da Apple, alguns fatores me fizeram decidir em adotar a plataforma Android, vamos ento descrever tais fatores: - Meu pblico coorporativo, digo pblico no s do livro em questo mas tambm clientes que desenvolvo aplicaes mveis, nunca nenhum usurio que busca entretenimento me contratou para desenvolver um novo player de msica para seu uso prprio. - Meu cliente requer equipamentos baratos, hoje temos dezenas de empresas trabalhando com hardwares equipados com o sistema operacional Android, isso abaixa os preos dos equipamentos o que bom, porem surge a dificuldade de escolher bons fornecedores, mas nada que a Internet no me ajude a decidir. - Sistema Operacional consolidado, com representantes fortes. - Um ambiente de programao gratuito, no preciso trocar o Sistema Operacional da minha mquina Host para ter que programar, ao contrrio da IOS que o leitor precisaria de ter um Mac OS no Host. Isso mostra que uma plataforma fechada e no aberta como o Android. Se for para apostar no futuro aposto na plataforma aberta.
Plataforma Mvel
natural que um grande grupo de leitores deste livro j desenvolveram aplicaes para Desktop e Web porem tiveram pouco contato com a plataforma mvel. Um desenvolvedor de aplicaes mveis deve ter em mente que sua aplicao no pode ser complexa, um estudo realizado pela Pam Inc (PALM INC. 2002) revela que em 80% do tempo os usurios de aplicaes Desktop utilizam 20% dos recursos de um aplicativo complexo. On a desktop system, users use 20% of an applications features 80% of the time. Your application should provide only that top 20% of features (Palm Inc., 2002). A recomendao desta empresa que as aplicaes mveis no precisam atingir a totalidade da abstrao de aplicaes Desktop nos equipamentos mveis, mas sim as principais aes que o usurio realmente requer. Minha experincia no assunto diz que mesmo se uma aplicao deva atingir a totalidade de aes de uma aplicao que esteja sendo portada da plataforma Deskotp para a Mobile ento eu delimito as principais aes e desenvolvo interfaces e lgicas que priorizem estas aes mais importantes, as demais devemos abstrair em menus (que esto geralmente ocultos) ou fora do foco principal das interfaces. No mesmo documento gerado pela Palm Inc. (Palm Inc., 2002) aborda que a usabilidade de aplicaes mveis diferente na questo do tempo de acesso e na regularidade do acesso. Geralmente uma aplicao mvel acessada vrias vezes ao dia porem o acesso tende a ter um perodo menor se comparado com a plataforma Desktop. No captulo dedicado a Interface com o usurio vou dedicar alguns tpicos para abordar as teorias de Interface Humano-Computador (IHC) para plataforma Mobile.
Figura 1 - Acesso dos usurios (Palm Inc., 2002) Outra questo importante que o leitor deve levar em considerao a conectividade, dispositivos mveis esto voltados a conectividade, isso porque seus recursos so limitados e seu objetivo no substituir a plataforma Dekstop, mas sim estar no local certo no momento certo ou seja, no momento da necessidade do usurio. Logo a ideia no armazenar a informao, mas sim ter acesso a esta informao que est no servidor, seja de arquivos ou de banco de dados. Tais questes de conectividade sero abordadas com nfase no captulo apropriado.
Plataforma Android
Android um Sistema Operacional que utiliza em seu ncleo a verso 2.6 do kernel do Linux. um sistema leve porem poderoso, por estar apoiado na verso 2.6 do kernel do Linux considerado estvel e est preparado para atender as necessidades modernas.
Figura 2 - Interface do Android Atualmente o Android equipa Celulares, Tablets PC, SmartPhones, etc. de grandes e pequenas empresas. A portabilidade de nossas aplicaes est centrada na portabilidade do Java. Na Figura 2 temos a interface de um equipamento (celular) emulado, j na Figura 3 temos a execuo do Android em um Notebook. A aplicao desenvolvida dever ser executada sem problemas (geralmente de interface) em ambos os equipamentos, sem a necessidade de reprogramao.
Figura 3 - Android em um Notebook

Desenvolvendo Aplicaes com Java para Android 9
Neste livro vamos desenvolver aplicaes em Java, a portabilidade do Java para a plataforma de 100%, no prximo captulo vamos instalar e configurar o Java. Se voc no conhece nada da linguagem Java no se preocupe, temos dois captulos no livro que abordaro ds do bsico da linguagem at noes avanadas de Programao Orientada a Objetos.
Requerimentos
Antes de instalar a ferramenta devemos conhecer os requisitos mnimos para se executar o Eclipse e o Android: Microsoft Windows XP ou superior; Pentium 4; 1 GB de RAM; 10 GB de HardDisk.
Como est Estruturado o Livro

Aps decidir qual tecnologia baseado na vivencia que o autor teve chegou a hora de decidir qual o foco do livro, bom foi fcil, busco instruir profissionais que atuam na rea de desenvolvimento de aplicaes que conhea no mnimo algoritmos e tenha uma viso lgica. Para isso ento decidi estruturar o livro para uma pessoa leiga em Java, no incio do livro vamos ver que temos muitas figuras, passo-a-passo processos de instalao e configurao, parece at que vamos ter umas 2000 pginas de tanta figura, mas aprendi atuando na rea educacional que o comeo da explorao de um novo conhecimento deve ser gratificante e de muito sucesso para elevar a autoestima do aprendiz. Nada mais difcil ( uma crtica mesmo) no ambiente Java do que configurar o prprio ambiente, e ainda somando a complexidade de comunicao com outro Sistema Operacional (o Android emulado), por isso detalhei muito a instalao e configurao com imagens. Aps detalhar a instalao e a configurao decidi montar um captulo clssico Hello World, este captulo em todos os livros servem para elevar a autoestima e garantir que o ambiente foi bem configurado. Nada de programao, criar um projeto e executar, simples para ter sucesso. Acredito que por ser barato, o leitor tenha um hardware equipado com Android, ento aps o Hello World adicionei um captulo importante, sobre como realizar a depurao do cdigo, a gerar um arquivo de instalao para o Android fsico (no emulado) e como instalar no Android o seu programa. Acredito que voc queira sair mostrando "Eu consegui,,, Eu consegui" para mo, pai, filho, funcionrio, esposa, cachorro (eu adoro animais, realmente fao isso), gato, para as galinhas (animais), etc.. Seja feliz que isso motiva a aprender mais e ainda a vizinhana vai achar que voc doido e no vai bater na porta para pedir acar emprestado, como se pudesse devolver algo que se come (na verdade pode mais fica difcil separar o resultado final). Como eu disse, este livro NO DEDICADO SOMENTE APROGRAMADORES JAVA, ento montei dois captulos que abordam a linguagem do bsico at as teorias de Programao Orientada a Objetos, se voc programador VB.NET, Basic (os autores deste livro j programaram em mais de 10 linguagens), Delphi, Clipper, C, C++, C#, Python/IronPython etc.. no precisa se preocupe, apenas d muita ateno a estes dois captulos. A partir dai comeo a aprofundar na teoria de Android, com interfaces grficas, conexo com SQLite, comunicao com servidores Sockets, etc..
Convenes
Utilizamos uma srie de estilos de texto e layout no livro para auxiliar a distinguir os diferentes tipos de informaes. A seguir esto exemplos dos estilos mais utilizados e uma explicao do que significam: Os marcadores aparecem recuados, a seguinte maneira: Uma pequena esfera utilizada para marcar um item;
10
Todos os caminhos e atalhos esto em negrito, exemplo: Iniciar | Programas | Assessrios | Bloco de Notas O caminho acima um exemplo de atalho para o Bloco de Notas. O cdigo fonte est limitado entre duas linhas horizontais e com as linhas numeradas.
0 1 2 3 4 5
//criando uma varivel String minha_variavel = ; //atribuindo dados a uma varivel minha_variavel = Wellington Pinto de Oliveira;
O comentrio ser feito no cdigo utilizando a nomenclatura Java // ou /* */. Quando for necessrio exibir uma sintaxe de algum mtodo ou rotina estarei adicionando um fundo cinza, conforme o exemplo abaixo:
alguma Sintaxe
O Cdigo do Livro
O cdigo do livro est disponvel para download na pgina http://ww.grupoandroid.com.br/LivroAndroid.aspx digite o cdigo AndroidSoftpalm para efetuar o download. Nesta pgina tambm possvel encontrar todos os programas e aplicativos utilizados ao longo do livro.
Download
Todos os arquivos necessrios sero adquiridos na Internet, ser necessrio realizar o download de trs arquivos bsicos, so eles:
JDK J2SE 6.0

O primeiro passo para que voc comece a desenvolver programas em Java, consiste em obter o Kit de Desenvolvimento Java, que j est na verso 1.6, atualmente conhecido com J2SE 6.0. Para conseguir o J2SE 6.0 JDK voc deve acessar o endereo: http://www.grupoandroid.com.br/LivroAndroid.aspx (conforme tpico O Cdigo do Livro).
Eclipse 3.6.2
No momento da edio deste livro, a verso disponvel a 3.6.2, mas como se trata de um desenvolvimento open source, essas verses so rapidamente alteradas. Voc pode baixar o IDE do Eclipse no endereo http://www.grupoandroid.com.br/LivroAndroid.aspx (conforme tpico O Cdigo do Livro).
Android SDK
O donwload do Android SDK no diferente, acesse a URL http://www.grupoandroid.com.br/LivroAndroid.aspx (conforme tpico O Cdigo do Livro) e faa o download do arquivo installer_r11-windows.exe.
11
2
2 Instalando e Configurando o Ambiente
Instalar os SDKs Java e Android; Instalar o Eclipse e configurar; Configurar o Emulador.
Introduo
O Android no possui um IDE prprio, ele utiliza o Eclipse para manipulao de cdigo fonte e emulao. O Eclipse uma IDE de desenvolvimento de programao, inicialmente desenvolvida pela IBM, que, segundo notcias, gastou mais de 40 Milhes de dlares no seu desenvolvimento antes de se transformar essa ferramenta Open Source para um consrcio, chamado Eclipse.org, que inicialmente incluiu a Borland, IBM, QNX Software Systems, Rational Software, Red Hat, SuSE, TogetherSoft e Webgain.
Instalando a JDK
A primeira instalao deve ser o Java JDK, encontre o arquivo obtido no download e execute o arquivo, abaixo temos uma sequncia de telas obtidas durante o processo de instalao.
Figura 4 - Instalando o JDK jdk-6u-windows-j586-p.exe Leia os termos de licena exibidos pela ferramenta, afinal no se deve aceitar nada sem ler nos dias de hoje.
12
Figura 5 - Termos de licena. Caso esteja de acordo pressione Accept e avance no processo de instalao.
Figura 6 - Opes de instalao de arquivos Faa uma analise e instale o que realmente achar importante, caso queira manter a mesma instalao do autor prossiga sem alterao pressionando Next.
Figura 7 - Processo de instalao de arquivos. Aguarde o termino do processo de instalao, isso pode demorar alguns minutos. Aps a instalao devemos verificar se a varivel de ambiente foi criada corretamente, para isso acesso o Painel de Controle do Windows em Iniciar | Painel de Controle, no painel procure pelo cone Sistema. Variveis de ambiente so sequncia de caracteres que contm uma informao importante para o sistema ou para um software, controlando o comportamento dos programas. Como exemplos de variveis de ambiente temos: PATH, CLASSPATH, USER, TEMP, JAVA_HOME, etc.
13
Figura 8 - TabPanel Sistema Pressione o boto Variveis de ambiente conforme imagem acima.
Figura 9 - Variveis de ambiente Na figura acima temos as variveis de ambiente do meu sistema operacional, veja que no existe JAVA_HOME, para criar pressiono o boto Nova. Se j tiver ignora este passo.
14
Figura 10 - Basta informar o nome e o caminho Para criar a varivel JAVA_HOME atribua este nome a varivel e adicione o caminho no valor da varivel, lembre-se que este valor muda de instalao para instalao.
Figura 11 - Variveis de ambiente Veja na figura acima que agora temos a varivel JAVA_HOME cadastrada.
Instalando o Eclipse
Para manter um padro de URL crie um novo diretrio na pasta Program Files chamado eclipse, conforme figura abaixo. Ateno: Se estiver no Windows 7 ou Windows Vista voc ter dificuldades de permisso de acesso a esta pasta.
Figura 12 - Criando a pasta eclipse O Eclipse no possui um instalador, basta descompactar o arquivo obtido no download e j podemos executar o programa, logo descompacte o eclipse dentro da pasta criada.
15
Figura 13 - Arquivos descompactados na pasta eclipse Na figura acima podemos ver os arquivos descompactados na pasta eclipse, agora s precisamos criar um cone na rea de trabalho para agilizar o dia a dia do programador (Ver figura abaixo).
Figura 14 - Criando um cone na rea de trabalho Altere o nome do cone na rea de trabalho para ter uma interface mais agradvel.
Figura 15 - cone na rea de trabalho
Instalando a SDK do Android

O prximo passo instalar o SDK do Android, efetue um duplo clique no arquivo installer_r11windows.exe, com isso a instalao ser iniciada.
16
Figura 16 - Inicio da Instalao O processo de instalao simples, porem vamos detalhar alguns pontos.
Figura 17 - Abertura do instalador Esse um ponto estranho, repare que ele est pedindo para instalar a SDK Java, mas ela j foi instalada. Macete voltar em Back e avanar, ai ele detecta !.
Figura 18 - Java SE Development Kit no detectado
17
Figura 19 - Java SE Development Kit detectado Depois deste inconveniente, s temos que prestar ateno no diretrio de instalao, esse diretrio ser til para configurar o Eclipse.
Figura 20 - Diretrio de instalao do Android Agora Next, Next at Finish como toda instalao Windows.
Figura 21 - Fimal da Instalao da SDK Aps a instalao do SDK o Android automaticamente chama a interface de atualizao da API e ferramentas, conforme podemos ver na figura abaixo.
18
Figura 22 - Atualizando lista para download Ser exibida uma lista de ferramentas e APIs que devero ser baixadas, para isso aceite e inicie a instalao destes artefatos.
Figura 23 - Lista de Artefatos Bom, isso pode demorar pois no depende s da sua conexo com a Internet, reparei em 5 instalaes que o limitador est do outro lado. Ento se no conhece muito bem Java voc j pode ir lendo sobre a linguagem neste prprio texto (no captulo dedicado a Linguagem Java).
Figura 24 - Processo de Download Aps realizar o download automaticamente e configurar os pacotes ele dever exibir a mensagem abaixo informando que os pacotes foram atualizados. Diga Yes.
19
Figura 25 - Atualizando os pacotes Dever demonstrar os arquivos atualizados, conforme figura abaixo, clique em Close.
Figura 26 - Lista de arquivos Atualizados Prximo passo configurar o Eclipse.
Configurando o Eclipse
Com o Eclipse instalado na maquina execute o arquivo .exe atravs do atalho criado.
Figura 27 - Abertura do Eclipse Quando o Eclipse executado ele solicita ao desenvolvedor que informe o Workspace, neste Workspace sero armazenados todos os projetos de forma organizada, vamos manter essa ideia para poder facilitar durante processo de suporte. Outro ponto interessante que mantemos estes projetos em servidor SVN de acordo com o desenvolvimento possvel recuperar o projeto no ponto correto do livro.
Figura 28 - Informando o local do Workspace Ao iniciar o Eclipse pela primeira vez o desenvolvedor tem que atualizar seus componentes, no nosso caso vamos apenas importar os componentes do Android, simples basta acessar Help | Install New Software....
Figura 29 - Atualizando componentes Nosso objetivo adicionar a SDK do Android no Eclipse para que possa ajudar no desenvolvimento, nesta SDK temos um conjunto de ferramentas que sero fundamentais para o progresso de nosso estudo.
Figura 30 - Adicionando o respositrio de plugin Ao clicar em Add... uma pequena janela deve ser aberta, informe o nome do Plugin e seu URL, ento vamos utilizar: Propriedade Name URL Conforme figura abaixo. Valor Android https://dl-ssl.google.com/android/eclipse/
Figura 31 - Dados da nova fonte Clique em OK para finalizar. Repare que na tela anterior aparece o Developer Tools, isso bom. Mantenha ele selecionado e clique em Next.
21
Figura 32 - Sites cadastrados no Eclipse Neste momento o eclipse deve validar os sites selecionados, conforme figura abaixo e exibir uma lista de itens que podem ser instalados.
Figura 33 - Sites ativos Deixe a opo marcada, vamos atualizar todos os objetos do Android, clique em Next e avance.
22
Figura 34 - Termos de licena dos componentes Leia os termos com ateno, se aceitar marque a opo I accept the terms in the license agreement e clique em Finish.
Figura 35 - O eclipse se conecta no site automaticamente para fazer o download Ateno, se a imagem abaixo aparecer, clique em OK e continue.
Figura 36 - Informao de Segurana Ao finalizar o download o prprio Eclipse solicitar ser reiniciado, pressione Restart Now.
Figura 37 - Mensagem de alerta Aps o Eclipse ser reiniciado ele dever apresentar as alteraes de interface, tais alteraes esto relacionadas a execuo correta do plugin que acabamos de adicionar.
23
Figura 38 - Android SDK and AVD Manager Para finalizar a configurao temos que informar ao Eclipse (plugin) qual o local a SDK Android foi instalada, para isso em Window | Preferences conforme figura abaixo.
Figura 39 - Efeito da instalao do Plugin No item Android (ver figura abaixo) informe o caminho de instalao do SDK Android (ver Figura 20) e clique no boto Apply. Aps clicar neste boto o Eclipse dever exibir uma lista de plataformas conforme a figura abaixo.
Figura 40 - Plataformas Android instaladas Pronto, clique em OK e seu Eclipse j se encontra configurado.
24
3
3 Hello World
Criar um projeto no Eclipse para Android; Configurar o Emulador; Testar o ambiente.
Introduo
O Hello World tem como objetivo demonstrar ao estudante como criar um projeto muito simples e depois como o executar, tambm ser utilizado para validar a configurao do ambiente. Se esta etapa for concluda com sucesso deve gerar no aluno uma satisfao que eleva a moral, isso faz com que o aprendizado seja mais fcil, pois um aluno motivado mais atento, por este motivo acredito que o Hello World o captulo mais importante, ele no pode ser deixado de lado pelos iniciantes. Neste captulo ainda vamos ter muitas imagens, como se fosse um grande tutorial, isso deve acabar nos prximos captulos que sero mais tericos. Para iniciar um projeto no Eclipse muito simples, pressione File | New | Other conforme imagem abaixo.
Figura 41 - Iniciando um Projeto fcil localizar o projeto Android, quando o Eclipse se conectou ao site dos desenvolvedores do Android ele automaticamente importou e instalou os plugins que facilitam o trabalho do programador. Na imagem abaixo demonstro como criar um novo projeto.
25
Figura 42 - Criando um novo projeto Clique em Next para avanar, na prxima tela defina o nome do projeto, neste caso vamos chamar de Hello World.
Figura 43 - Definindo o nome do projeto Utilize o nome HelloWorld, mantenha a configurao padro (tela acima), j nas demais opes vamos detalhar (tela inferior).
26
Figura 44 - Configurao do Projeto Application Name ser o nome utilizado pela aplicao no device e o Package Name ser o nome utilizado para empacotar as classes. Um Activity um componente do aplicativo que fornece uma tela no qual o usurio podem interagir, a fim de realizar alguma tarefa como discar o telefone, tomar um foto, envie um e-mail, ou ver um mapa. Cada Activity controla uma janela na qual pode-se desenhar sua interface com o usurio. A janela normalmente preenche a tela, mas pode ser menor do que a tela e flutuar em cima de outras janelas, vamos nos aprofundar neste assunto no captulo apropriado. Um aplicativo normalmente consiste de mltiplas Activities que so fracamente ligadas umas as outras. Normalmente, uma Activity em um aplicativo especificada como a "Activity Main", que apresentada ao usurio ao iniciar o aplicativo pela primeira vez, no exemplo acima essa Activity Main ser chamada de Gerenciador. Cada Activity pode comear outra Activity, a fim de executar vrias aes diferentes. Cada vez que uma comea a Activity anterior interrompida, mas o sistema preserva a Activity em uma pilha ("pilha de retorno"). A opo Min SDK Version informa a verso mnima do SDK que ser utilizada para depurao e execuo. Clique em Finsh para cliar o projeto.
Estrutura do Projeto
Agora vamos entender a estrutura do projeto, afinal o plugin instalado gera a partir de nossa configurao inmeros arquivos. Na figura abaixo encontramos a estrutura criada no nosso projeto HelloWorld.
27
Figura 45 - Estrutura do projeto HelloWorld Todo o cdigo Java que vamos desenvolver ser adicionado a pasta src, nesta pasta encontramos os pacotes organizados. Gerenciador.java a classe responsvel pela nossa entrada na aplicao, sua configurao feita no arquivo AndroidManifest.xml conforme figuras abaixo.
Figura 46 - Configurao do Pacote Principal Nesta configurao encontramos o pacote principal, a configurao da Activity inicial demonstrado na figura abaixo.
28
Figura 47 - Configurao da Activity Gerenciador.java Na pasta res (ver Figura 45) encontramos os Resources da aplicao, so arquivos que associados aos cdigos (da pasta srv) formam a aplicao. Vamos ao exemplo de nossa interface inicial, abaixo temos o cdigo do arquivo Gerenciador.java.
1 2 3 4 5 6 7 8 9 10 11 12 13
package br.com.softpalm.hello; import android.app.Activity; import android.os.Bundle; public class Gerenciador extends Activity { /** Called when the activity is first created. */ @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); } } Na linha 11 temos o comando setContentView() que adiciona um resource ao ContentView e exibe na tela do device, ele recebe como parmetro um nmero inteiro que utilizado para carregamento do Resource apropriado, neste caso R.layout.main. Vamos voltar a Figura 45 e localizar a classe R.java.
1 /* AUTO-GENERATED FILE. DO NOT MODIFY. 2 * 3 * This class was automatically generated by the 4 * aapt tool from the resource data it found. It 5 * should not be modified by hand. 6 */ 7 8 package br.com.softpalm.hello; 9 10 public final class R { 11 public static final class attr { 12 } 13 public static final class drawable { 14 public static final int icon=0x7f020000; 15 } 16 public static final class layout {
29
17 18 19 20 21 22 23 }
public static final int main=0x7f030000; } public static final class string { public static final int app_name=0x7f040001; public static final int hello=0x7f040000; }
O aviso claro, no modifique pois isso gerado automaticamente. Trouxe o aprendiz at este cdigo para ver que o nmero que identifica o recurso main est na linha 17. Essa declarao gerada automaticamente, voc no precisa alterar. Resta agora achar esse tal de main. Voltando a Figura 45 encontramos em res\layout\ o artefato main.xml. Ao efetuar um duplo clique neste arquivo ele dever abrir um editor, conforme figura abaixo.
Figura 48 - Editor de Layout No editor as abas 1 e 2 so responsveis pelo layout exibido no editor, 1 apresenta um layout em que o programador arras objetos e configura, j na opo 2 o programador encontra um editor de XML, ambas as visualizaes possuem a mesma funo. Em 3 temos a ToolBox, na qual encontramos os objetos de interface que usamos para montar o layout. Em 4 encontramos uma barra de visualizao, na qual podemos ver a interface em diferentes resolues, temas, etc.. Em 5 podemos ver nossa interface.
Configurando o Emulador
Antes de finalizar este captulo vamos abordar a emulao, ms antes de executar nossa aplicao precisamos fazer algumas configuraes bsicas. Inicie clicando em Window | Android SDK and AVD Manager conforme figura abaixo.
30
Figura 49 - Acessando o AVD Manager Ser exibida uma lista sem nenhum emulador configurado, bom ento pressione New... para adicionar um emulador.
Figura 50 - Lista de Emuladores (nenhum configurado) Para criar um emulador basta atribuir um nome, no meu caso vou chamar de Device_2_2 porque vou emular a verso 2.2 do Android. Selecionei a Target 2.2 para emular a verso 2.2 do Android. Informe uma memria, vou usar 512MB para ter certeza que no vai ter problemas de memria, e WQVGA400 para ter uma tela pequena.
Figura 51 - Configurao do Emulador Device_2_2 Clique em Create AVD.
31
Figura 52 - Lista de Emuladores Pronto, emulador criado.
Executando a Aplicao
Para executar nossa aplicao precisamos relacionar o nosso projeto HelloWorld com o Device_2_2. Para isso clique em Run Configurations... conforme figura abaixo.
Figura 53 - Criando uma Configurao Clique com o boto direito do mouse sobre Android Application conforme figura abaixo e selecione New.
Figura 54 - New Android Application Na aba Android (ver figura abaixo) selecione usando o boto Browser... a aplicao HelloWorld.
Figura 55 Selecionando o Projeto Agora na aba Target selecione o Device_2_2 conforme figura abaixo.
32
Figura 56 - Selecionando o Emulador Clique em Run. A aplicao dever chamar o emulador, que deve demorar um pouco para carregar (calma, hora de tomar um caf). A demora est relacionada com o carregamento do Sistema Operacional dentro do emulador, logo abrimos uma nica vez e mantemos o emulador aberto sempre.
Figura 57 - Emulador Android 2.2 Com o emulador carregado (ver figura acima) destrave arrastando o cadeado at o ponto verde. Pronto sua aplicao dever ser carregada.
33
Figura 58 - Aplicao HelloWorld executando
34
4
4 Depurando e Distribuindo a Aplicao
Depurar a aplicao no Device; Criar uma distribuio do aplicativo.
Introduo
Em muitos textos o processo de montagem de uma distribuio abordado ao trmino de captulos mais avanados, neste texto pretendo abordar no s a depurao no device mas tambm esse processo visando a motivao do aprendiz. A motivao a chave da aprendizagem, o captulo de Hello World e este captulo devem ser capazes de suprir as dvidas bsicas de como funciona uma aplicao e como elas se comporta no device.
Atualizando o Sistema
Antes de tentar se conectar pela USB precisamos baixar alguns drivers e componentes atravs de atualizaes do Eclipse, no futuro vamos utilizar os componentes para navegar na estrutura do device. No Eclipse acesse Window | Android SDK and AVD Manager conforme figura abaixo.
Figura 59 - Acessando a janela de atualizao O nosso objetivo principal atualizar as APIs para USB, veja na figura abaixo que todas as opes foram marcadas.
35
Figura 60 - Atualizando as APIs Clique em Install Selected, e aguarde.
Depurando uma Aplicao pelo Device

Durante o desenvolvimento a depurao do cdigo uma tarefa inevitvel, isso porque a complexidade computacional grande. Com o ambiente Eclipse configurado essa tarefa fcil, realizar a depurao do cdigo exige pouco esforo. Vou alterar o cdigo da classe Gerenciador.java do projeto HelloWorld para poder depurar. Segue abaixo o cdigo alterado.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
package br.com.softpalm.hello; import android.app.Activity; import android.os.Bundle; public class Gerenciador extends Activity { /** Called when the activity is first created. */ @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); String s = System.getProperty("java.io.tmpdir"); } }
Apenas adicionei uma linha (linha 13) para ter algo para verificar, vamos ver em tempo de execuo o valor atribudo a s. Para isso vamos ter que criar um ponto de parada, clique com o boto direito do mouse na barra lateral esquerda do cdigo conforme figura abaixo.
36
Figura 61 - Linha que ser adicionada o BreakPoint Repare que estou posicionando o mouse exatamente na linha anterior a atribuio, poderia ser justamente na linha porem o smbolo de Warning est atrapalhando a visibilidade do ponto que quero demonstrar. Clicando com o boto direito do mouse dever aparecer um menu suspenso conforme figura abaixo.
Figura 62 - Adicionando o BreakPoint Selecione Toggle Breakpoint. Repare que agora aparece um bolinha azul na linha que pretendemos parar.
Figura 63 - Linha com BreakPoint Agora vamos configurar nosso emulador/device para depurao, para isso clique em Debug Configurations... conforme figura abaixo.
37
Figura 64 - Acessando Debug Configurations... Nos j temos a configurao feita no captulo anterior, ento vamos s alterar. Para isso clique em Terget.
Figura 65 - Configurao j existente Nosso objetivo marcar como Manual e procurar em uma lista de devices ou emuladores a opo que queremos usar como teste.
Figura 66 - Alterando a Target A figura acima a configurao como est (baseado no captulo anterior) j a tela abaixo temos a opo Manual marcado.
Figura 67 - Configurao Manual Agora vamos iniciar o processo de depurao, clique em Run. Ser exibida uma lista conforme a imagem abaixo.
38
Figura 68 - Lista de Devices/Emuladores No meu caso no tenho nenhum device conectado no momento, somente o emulador. Se voc tiver um device com Android 2.2 conectado ento ele dever aparecer na lista. Muito simples, escolha a opo e clica em OK. Ateno: Se voc tem um equipamento conectado e ele no aparece na lista ento veja o Apndice 1 Habilitando Depurao.
Figura 69 - Eclipse iniciando a depurao Repare que o Eclipse deve mudar a sua perspectiva.
Figura 70 - Perspectiva Ateno: Se no abrir a perspectiva Debug conforme figura acima recorra ao Apndice 2 Perspectiva no Eclipse. Ao abrir o Eclipse ele vai estar em modo Debug (figura acima) e com a linha que possui o Breakpoint selecionada e com um cursor tambm em azul (setinha em cima da bolinha conforme imagem abaixo).
39
Figura 71 - Cdigo em modo debug Agora vamos pressionar duas vezes (devagar) a tecla F6 para o cursor andar duas linhas, conforme figura abaixo (repare que o cursor azul est na chave).
Figura 72 - Depurao aps 2xF6 Agora passe o cursor sobre a varivel s, veja que deve abrir uma caixa com o valor contido em s.
Figura 73 Valores da varivel Os valores das variveis tambm podem ser vistos na aba Variables conforme figura abaixo.
40
Figura 74 - Aba variables Desta forma voc pode testar linha a linha sua aplicao antes de construir a verso release (verso final).
Deploy
Ao chegar neste tpico o aprendiz ao menos j possui em suas mos o projeto HelloWorld compilando, timo pois precisamos somente deste at o momento. Nosso objetivo a montagem do arquivo .apk, este arquivo um Instalador que vamos distribuir, o usurio final pode atravs de um carto de memria executar este arquivo diretamente no device. Antes de partir para a construo do arquivo .apk temos que abordar um assunto sobre certificaes digitais, o sistema android exige que todas as aplicaes instaladas tenham certificados digitais assinados com uma chave privada, este certificado utilizado no para controlar se uma aplicao pode ou no ser instalada, mas sim para identificar o autor da aplicao e manter uma certa relao de confiana. Os pontos importantes para a compreenso sobre assinaturas digitais para Android so: 1 - Todas as aplicaes devem ser assinadas. O sistema no ir instalar uma aplicao que no est assinada; 2 - Nenhuma autoridade controla os certificados, voc pode gerar tais certificados a partir da sua mquina. No nosso caso vamos configurar o Eclipse para tal tarefa; 3 - Quando voc estiver pronto para liberar o seu aplicativo para usurios finais, voc dever assin-lo com uma chave apropriada privada. Voc no pode publicar um aplicativo que est assinado com a chave de depurao gerado pelas ferramentas do SDK. O sistema Android no ir instalar ou executar um aplicativo que no est assinado apropriadamente. Isto se aplica sempre que o sistema executado no Android, mesmo em um emulador. Por esta razo, voc deve configurar a assinatura para a sua aplicao antes de voc ser capaz de executar ou depurar-lo em um emulador ou dispositivo. As ferramentas do Android SDK ajudar voc a assinar seus aplicativos durante a depurao. Tanto o Plugin ADT para o Eclipse e o Ant oferecer ferramenta de dois modos de assinatura - debug mode e release mode. Durante o desenvolvimento e teste, voc pode compilar em modo de depurao "debug mode". Em modo de depurao, a ferramenta build usa o utilitrio keytool (includo no JDK), para criar e armazenar as chaves. Quando seu aplicativo est pronto para lanamento (release), voc deve compilar no modo de liberao (release mode), em seguida assinar o APK com sua chave privada. H duas maneiras de fazer isso: Usando Keytool e jarsigner por linha de comando no prompt; Usando o Assistente de Exportao no Eclipse (que faz tudo). Ateno: No precisa ter medo desta complexidade, no Eclipse isso mais fcil que tirar bala de criana. Conhecendo um pouco a idia ento vamos construir nosso instalador. Selecione o projeto com boto direito do mouse Android Tools | Export Signed Application Package... conforme figura abaixo.
Figura 75 - Export Signed Application Package Selecione o projeto, que no nosso caso o HelloWorld, conforme figura abaixo.
Figura 76 - Selecionando o Projeto Agora temos que selecionar uma chave existente ou criar uma, como nossa primeira exportao vamos criar uma nova chave. Preencha o formulrio conforme figura abaixo. Ateno: Para todos os campos senhas vou usar: android
Figura 77 - Gerando uma Chave Agora vamos preencher os demais dados da nossa chave, conforme figura abaixo.
42
Figura 78 - Dados de uma chave Agora falta pouco, temos que apontar para um diretrio e dar nome ao nosso instalador, conforme feito na figura abaixo.
Figura 79 - Diretrio de exportao Pronto, feito !. No Eclipse tudo mais fcil. Veja no Windows Explorer (figura abaixo) que o arquivo foi gerado.
Figura 80 - Arquivo .apk gerado com sucesso Agora voc deve pegar este arquivo .apk e adicionar a um Carto, introduza o carto no equipamento e atravs do navegador do seu equipamento encontre o arquivo, ao efetuar um clique sobre ele automaticamente ser instalado.
43
5
5 A Linguagem
Especificao da linguagem; Declarao de variveis; Como utilizar instrues de seleo if e if...else para escolher entre aes alternativas; Utilizando o switch para determinar um bloco de aes especficas; Como utilizar instrues de repetio, tais como while, for, do...while; Noo de fluxogramas.
Introduo
Antes de escrever um programa capaz de resolver um problema, essencial ter entendimento completo do problema e planejar uma abordagem simples mais eficiente que resolva tal problema. Ao escrever um programa, tambm essencial entender os tipos de blocos de construo que esto disponveis e empregar tcnicas comprovadas de construo de programa. Os conceitos apresentados aqui so importantes para o programador Android, principalmente se este programador for iniciante no mundo orientado a objetos ou Java. Neste captulo vamos introduzir a teoria Java pois a base para o desenvolvimento, tais como as instrues if, if...else, switch, while, for e do...while, etc..
Algoritmos
Qualquer problema de computao pode ser resolvido executando-se uma srie de ordem especfica. O exemplo a seguir demonstra que importante especificar corretamente a ordem em que as aes executam. Algoritmo: Algoritmo para treino da Escola jax de Futebol. Descrio: Aos sbados, o autor deste livro realiza um trabalho social que visa tirar crianas carentes da rua, ministrando treinamento fsico em uma escolinha de futebol infantil. Os trabalhos seguem o seguinte algoritmo: Inicia-se os trabalhos verificando as qualidades das chuteiras e material de trabalho; Se existe algo com problema anote; Realizar chamada; Se criana ausente, procure saber o motivo com os colegas; Conversar com algumas crianas para saber como foi a semana, na escola entre outras coisas, no mximo 10 minutos (repetio indefinida); Inicia-se um alongamento; Inicia-se uma corrida moderada no campo, enquanto no for 10 voltas no parar (repetio de 0 at
10); 60 minutos de coletivo (repetio de 0 at 60); Uma pequena parada para conversar com as crianas, sobre assuntos que as motivam. Repare que o algoritmo teoricamente pode ser qualquer texto que exprima aes e seqncia em que ocorrem as aes, imagine que se o contador na ao 5 no fosse incrementado, estaramos dando voltas no campo at hoje, tudo tem que funcionar de forma seqencial e correta. Se as aes 3 e 7 no fossem executadas no seria um servio social que visa formar um ser social, estaria apenas fazendo um jogador. Se a ao 1 no ocorrer, um belo dia no vamos ter bolas ou chuteiras para as crianas. Sempre use algoritmos de alto nvel para entender melhor o problema, muitas vezes a soluo to simples que se torna imperceptvel durante a edio do cdigo fonte.
Variveis, Operadores e Estruturas de Controle

Apresentaremos agora uma pequena discusso sobre a sintaxe da linguagem Java, abordando os tipos de dados existentes, as regras para declarao de variveis, as recomendaes gerais para nomenclatura, os operadores, sua precedncia e as estruturas de controle disponveis. Como ser notado, a sintaxe da linguagem Java muito semelhante quela usada pela linguagem C/C++.
Variveis
Na matemtica de segundo grau lidamos com variveis a todo momento, varivel um smbolo que armazena um valor no fixo, ou seja, o programador no pode prever os valores possveis. Na matemtica pouco importa se o nmero que ser atribudo 6 ou 2,4, ambos poderiam se atribudos em uma varivel X. Veja que no preciso informar o tipo de varivel, porque a matemtica uma linguagem fracamente tipada. J a linguagem Java fortemente tipada, temos que definir os tipos de objetos durante a sua criao.
Tipos de Dados Primitivos

A linguagem Java possui oito tipos bsicos de dados, denominados tipos primitivos, que podem agrupados em quatro categorias: Categoria Tipo Inteiro Tipo Ponto Flutuante Tipo Lgico Tipo Caracter Tipos de dados primitivos Como pode ser facilmente observado, os tipos primitivos do Java so os mesmos encontrados na maioria das linguagens de programao e permitem a representao adequada de valores numricos. A representao de outros tipos de dados utiliza objetos especficos assim como existem classes denominadas wrappers que encapsulam os tipos primitivos como objetos da linguagem. Tipos de Dados Inteiros Existem quatro diferentes tipos de dados inteiros byte (8 bits), short (inteiro curto - 16 bits), int (inteiro - 32 bits) e long (inteiro longo - 64 bits) cuja representao interna feita atravs de complemento de 2 e que podem armazenar valores dentro dos seguintes intervalos numricos: Tipo byte short int Valor Mnimo -128 -32.768 -2.147.483.648 Valor Mximo +127 + 32.767 +2.147.483.647 Tipo Primitivo Byte; Inteiro Curto; Inteiro; Inteiro Longo Ponto Flutuante Simples; Ponto Flutuante Duplo Boleano Caractere
45
long 8 Tipos de Dados Inteiros
9.223.372.036.854.775.80
+9.223.372.036.854.775.8 07
Por padro os valores literais so tratados como inteiros simples (int) ou seja valores de 32 bits. No existe em Java o modificador unsigned disponvel em outras linguagens assim os tipos inteiros so sempre capazes de representar tanto valores positivos como negativos. Tipo de Dados em Ponto Flutuante No Java existem duas representaes para nmeros em ponto flutuante que se diferenciam pela preciso oferecida: o tipo float permite representar valores reais com preciso simples (representao interna de 32 bits) enquanto o tipo double oferece dupla preciso (representao interna de 64 bits). Os valores m ponto flutuante do Java esto em conformidade com o padro IEEE 754: Tipo float double Tipos de Dados em Ponto Flutuante Deve ser utilizado o ponto como separador de casas decimais. Quando necessrio, expoentes podem ser escritos usando o caractere 'e' ou 'E', como nos seguintes valores: 1.44E6 (= 1.44 x 106 = 1,440,000) ou 3.4254e-2 (= 3.4254 x 10-2 = 0.034254). Tipo de Dados Caractere O tipo char permite a representao de caracteres individuais. Como o Java utiliza uma representao interna no padro UNICODE, cada caractere ocupa 16 bits (2 bytes) sem sinal, o que permite representar at 32.768 caracteres diferentes, teoricamente facilitando o trabalho de internacionalizao de aplicaes Java. Na prtica o suporte oferecido ao UNICODE ainda bastante limitado embora permita a internacionalizao do cdigo Java. Alguns caracteres so considerados especiais pois no possuem uma representao visual, sendo a maioria caracteres de controle e outros caracteres cujo uso reservado pela linguagem. Tais caracteres podem ser especificados dentro dos programas como indicado na tabela abaixo, ou seja, precedidos por uma barra invertida ('\'): Representao \n \r \b \t \f \ \ \\ \u223d \g37 \fca Representao de Caracteres Especiais O valor literal de caracteres deve estar delimitado por aspas simples (' ').
Valor Mnimo
Valor Mximo
Significado Pula linha (newline ou linefeed) Retorno de carro (carriage return) Retrocesso (backspace) Tabulao (horizontal tabulation) Nova pgina (formfeed) Apstrofe Aspas Barra Invertida Caractere UNICODE 233d Octal Hexadecimal
Tipo de Dados Lgico Em Java dispe-se do tipo lgico boolean capaz de assumir os valores false (falso) ou true (verdadeiro) que equivalem aos estados off (desligado) e on (ligado) ou no (no) e yes (sim). Deve ser destacado que no existem equivalncia entre os valores do tipo lgico e valores inteiros tal como usualmente definido na linguagem C/C++.
Declarao de variveis
Uma varivel um smbolo definido pelo programador ao qual pode ser associado um valor pertencente a um certo tipo de dados (que j estudamos). Em outras palavras, uma varivel como uma memria, capaz de armazenar um valor de um certo tipo, para a qual se d um nome que usualmente descreve seu significado ou propsito e que usamos como referncia natural (linguagem natural do ser humano). Desta forma toda varivel possui um nome, um tipo e um contedo.
Figura 81 - Varivel com Nome, tipo e contedo (Barbosa, 2010). O nome de uma varivel em Java pode ser uma seqncia de um ou mais caracteres alfabticos e numricos, iniciados por uma letra ou ainda pelos caracteres '_' (underscore) ou '$' (cifro). Os nomes no podem conter outros smbolos grficos, operadores ou espaos em branco, podendo ser arbitrariamente longos embora apenas os primeiros 32 caracteres sero utilizados para distinguir nomes de diferentes variveis. importante ressaltar que as letras minsculas so consideradas diferentes das letras maisculas, ou seja, a linguagem Java sensvel ao caixa empregado, assim temos como exemplos vlidos: a, total, x2, $mine, _especial, TOT, Maximo e ExpData. Segundo as mesmas regras temos abaixo exemplos invlidos de nomes de variveis: 1x, Total geral, numero-minimo e void. A razo destes nomes serem invlidos simples: o primeiro comea com um algarismo numrico, o segundo possui um espao em branco, o terceiro contm o operador menos mas por que o quarto nome invlido? Porque alm das regras de formao do nome em si, uma varivel no pode utilizar como nome uma palavra reservada da linguagem. As palavras reservadas so os comandos, nomes dos tipos primitivos, especificadores e modificadores pertencentes a sintaxe de uma linguagem. As palavras reservadas da linguagem Java que, portanto no podem ser utilizadas como nome de variveis ou outros elementos, so: abstract boolean break byte case catch char continue default do else else extends false finally float for implements implements import instanceof interface long native null null package private public return short super super switch synchronized Throw Throws Transient Try Try Void While
47
class
final
int
protected
this
Palavras reservadas da linguagem Java Alm destas existem outras que embora reservadas no so utilizadas pela linguagem: const, future, generic, goto, inner, operator, outer, rest, var, volatile, etc.. Algumas destas, tal como o goto, faziam parte da especificao preliminar do Oak, antes de sua formalizao como Java. Recomenda-se no utiliz-las qualquer que seja o propsito. Tambm devemos seguir uma ordem, por exemplo, no podemos dizer prato o de me, temos que dizer me de o prato, logo para que o compilador entenda temos que dizer: int meusimbolo; Chamamos isso de sintaxe, desta forma para declararmos uma varivel devemos seguir a seguinte sintaxe: Tipo nome1 [, nome2 [, nome3 [..., nomeN]]]; Ou seja, primeiro indicamos um tipo, depois declaramos uma lista contendo um ou mais nomes de variveis desejadas deste tipo, onde nesta lista os nomes so separados por vrgulas e a declarao terminada por ';' (ponto e vrgula). Exemplos:
1 2 3 4 5 6
// Uma nica varivel int i; // Declarao com muitas variveis float total, preco; // Declarando e j adicionando um valor int mascara = 5;
Cdigo 1 - Cdigo de Exemplo A declarao anterior (Linha 4) equivale as duas declaraes abaixo:
1 2
float total; float preco;

Cdigo 2 - Cdigo de Exemplo Tambm possvel definirmos uma valor inicial para uma varivel diretamente em sua declarao como indicado a seguir: Variveis podem ser declaradas em qualquer ponto de um programa Java, sendo vlidas em todo o escopo onde foram declaradas (a partir da linha em que foi criada) e nos escopos internos estes. Por escopo entende-se como bloco (conjunto de comandos da linguagem) onde ocorreu a declarao da varivel. Dica para Denominao de Variveis Em Java recomenda-se que a declarao de variveis utilize nomes iniciados com letras minsculas. Caso o nome seja composto de mais de uma palavras, as demais deveriam ser iniciadas com letras maisculas tal como nos exemplos: contador, total, sinal, posicaoAbsoluta, valorMinimoDesejado, mediaGrupo e Tarefa2. A utilizao de caracteres numricos no nome livre enquanto o uso do trao de sublinhar (underscore '_') no recomendado.
Comentrios
Comentrios so trechos de texto, usualmente explicativos, inseridos dentro do programa de forma que no sejam considerados como parte do cdigo, ou seja, so informaes deixadas juntamente com o cdigo para informao de quem programa. O Java aceita trs tipos de comentrios: de uma linha, de mltiplas linhas e de documentao. O primeiro de uma linha utiliza duas barras (//) para marcar seu incio:
48
1 2
// comentrio de uma linha // tudo aps as duas barras considerado comentrio

Cdigo 3 - Cdigo de Exemplo O segundo usa a combinao /* e */ para delimitar uma ou mais linhas de comentrios:
1 2
/* comentrio de mltiplas linhas */

Cdigo 4 - Cdigo de Exemplo O ltimo tipo semelhante ao comentrio de mltiplas linhas mas tem o propsito de documentar o programa:
1 2 3
/** comentrio de documentao que tambm * podem ter mltiplas linhas */

Cdigo 5 - Cdigo de Exemplo Geralmente o comentrio de documentao posicionado imediatamente antes do elemento a ser documentado e tem seu contedo extrado automaticamente pelo utilitrio javadoc fornecido juntamente com o JDK. Esta ferramenta gera pginas em formato html contendo os comentrio organizados da mesma forma que a documentao fornecida juntamente com o JDK. Aproveitando tal caracterstica do javadoc, usualmente se adicionam tags html aos comentrios de documentao para melhorar a forma final da documentao produzida com a incluso de imagens, tabelas, textos explicativos, links e outros recursos. Alm das tags html vrios tipos de informao administradas pelo javadoc podem ser adicionadas a estes comentrios especiais atravs de marcadores pr-definidos iniciados com "@" que permitem a criao automtica de ligaes hipertexto entre a documentao e a formatao padronizada de outros elementos, tais como nome do autor, parmetros, tipo de retorno, etc. conforme Cdigo 6.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
package br.com.softpalm; import java.io.*; /** * Classe destinada ao armazenamento de dados relacionados a arquivos ou * diretrios. * <p> * Pode ser usada para armazenar rvores de diretrios. * * @author Wellington Pinto de Oliveira * @see java.io.File */ public class FileData extends File { /** * Construtor * * @param filename * nome do arquivo */ public FileData(String filename) { super(filename); } }
Cdigo 6 - Cdigo da classe FileData v.: 1.0
Operadores
A linguagem Java oferece um conjunto bastante amplo de operadores destinados a realizao de
49
operaes aritmticas, lgicas, relacionais e de atribuio. Operadores Aritmticos Como na maioria das linguagens de programao, o Java possui vrios operadores aritmticos, conforme descritos na Tabela 1 - Operadores. Operador + * / % + ++ -Significado Adio Subtrao Multiplicao Diviso Resto da Diviso Inteira Sinal negativo (- unrio) Sinal Positivo (+ unrio) Incremento unitrio Decremento unitrio Tabela 1 - Operadores Estes operadores aritmticos podem ser combinados para formar expresses onde deve ser observada a precedncia (ordem convencional) de avaliao dos operadores. Parntesis podem ser utilizados para determinar uma forma especfica de avaliao de uma expresso. A seguir um exemplo de aplicao que declara algumas variveis, atribui valores iniciais e efetua algumas operaes imprimindo os resultados obtidos. Exemplo a+b ab a*b a/b a%b -a +a ++a ou a++ --a ou a--
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27
package br.com.softpalm; public class Operadores { /** * @param args */ public static void main(String[] args) { int a = 5; int b = 2; // Varios exemplos de operacoes sobre variaveis System.out.println("a = " + a); System.out.println("b = " + b); System.out.println("-b = " + (-b)); System.out.println("a + b = " + (a + b)); System.out.println("a - b = " + (a - b)); System.out.println("a * b = " + (a * b)); System.out.println("a / b = " + (a / b)); System.out.println("(float) a / b = " + ((float) a / b)); System.out.println("a % b = " + (a % b)); System.out.println("a++ = " + (a++)); System.out.println("--b = " + (--b)); System.out.println("a = " + a); System.out.println("b = " + b); } }
Cdigo 7 - Cdigo da classe Operadores (Reviso svn 1)
50
Compilando e executando o cdigo fornecido teramos o resultado ilustrado a seguir:
Figura 82 Resultado da Aplicao Aritmtica Embora o exemplo s tenha utilizado variveis e valores inteiros, o mesmo pode ser realizado com variveis do tipo ponto flutuante (float ou double). Operadores Relacionais Alm dos operadores aritmticos o Java possui operadores relacionais, isto , operadores que permitem comparar valores literais, variveis ou o resultado de expresses retornando um resultado do tipo lgico, isto , um resultado falso ou verdadeiro. Os operadores relacionais disponveis so: Operador == != > < >= <= Significado Igual Diferente Maior que Menor que Maior ou igual a Menor ou igual a Tabela 2 - Tabela de Operadores A seguir um outro exemplo simples de aplicao envolvendo os operadores relacionais. Como para os exemplos anteriores, sugere-se que esta aplicao seja testada como forma de se observar seu comportamento e os resultados obtidos. Exemplo a == b a != b a>b a<b a >= b a <=b
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
package br.com.softpalm; public class Relacionais { /** * @param args */ public static void main(String[] args) int a = 15; int b = 12; System.out.println("a = " + a); System.out.println("b = " + b); System.out.println("a == b -> " + System.out.println("a != b -> " + System.out.println("a < b -> " +
(a == b)); (a != b)); (a < b));
51
16 17 18 19 } 20 }
System.out.println("a > b -> " + (a > b)); System.out.println("a <= b -> " + (a <= b)); System.out.println("a >= b -> " + (a >= b));
Cdigo 8 - Cdigo da clase Relacionais (Reviso svn 2) Operadores Lgicos Como seria esperado o Java tambm possui operadores lgicos, isto , operadores que permitem conectar logicamente o resultado de diferentes expresses aritmticas ou relacionais construindo assim uma expresso resultante composta de vrias partes e portanto mais complexa. Operador && || ! Significado E lgico Ou lgico Negao Tabela 3 - Operadores Lgicos Os operadores lgicos duplos, isto , definidos por dois caracteres, tambm no podem conter espaos em branco. Operador de Atribuio Atribuio a operao que permite definir o valor de uma varivel atravs de uma constante ou atravs do resultado de uma expresso envolvendo operaes diversas. Exemplo a && b a || b !a
1 2 3
boolean result = false; i = 0; y = a*x + b;

Cdigo 9 - Exemplo de Cdigo Em Java vlido o encadeamento de atribuies, tal como abaixo, onde todas as variveis so inicializadas com o mesmo valor:
1 2 3
byte m, n, p, q; M m = n = p = q = 0;
// equivale a m = (n = (p = (q = 0)));
Cdigo 10 - Exemplo de Cdigo
Precedncia de Avaliao de Operadores Numa expresso onde existam diversos operadores necessrio um critrio para determinar-se qual destes operadores ser primeiramente processado, tal como ocorre em expresses matemticas comuns. A precedncia este critrio que especifica a ordem de avaliao dos operadores de um expresso qualquer. Na Tabela 4 temos relacionados os nveis de precedncia organizados do maior (Nvel 1) para o menor (Nvel 15). Alguns dos operadores colocados na tabela no esto descritos neste texto. Nvel 1 2 3 4 Operadores . (Seletor) [] () ++ -- ~ instanceof new clone (unrio) */% +-
52
5 6 7 8 9 10 11 12 13 14 15
<< >> >>>> < > <= >= == != & ^ | && || ? = op= , Tabela 4 - Precedncia dos Operadores em Java
Note que algumas palavras reservadas (instanceof, new e clone) se comportam como operadores. Operadores de um mesmo nvel de precedncia so avaliados conforme a ordem em que so encontrados, usualmente da esquerda para direita. Para modificarmos a ordem natural de avaliao dos operadores necessrio utilizarmos os parntesis, cujo nvel de avaliao o mais alto, para especificar-se a ordem de avaliao desejada.
Estruturas de Controle
Um programa de computador uma seqncia de instrues organizadas de forma tal a produzir a soluo de um determinado problema. Naturalmente tais instrues so executadas em seqncia, o que se denomina fluxo seqencial de execuo. Em inmeras circunstncias necessrio executar as instrues de um programa em uma ordem diferente da estritamente seqencial. Tais situaes so caracterizadas pela necessidade da repetio de instrues individuais ou de grupos de instrues e tambm pelo desvio do fluxo de execuo. As linguagens de programao tipicamente possuem diversas estruturas de programao destinadas ao controle do fluxo de execuo, isto , estruturas que permitem a repetio e o desvio do fluxo de execuo. Geralmente as estruturas de controle de execuo so divididas em: Estruturas de repetio simples Destinadas a repetio de um ou mais comandos, criando o que se denomina laos. Geralmente o nmero de repeties pr-definido ou pode ser determinado pelo programa durante a execuo. No Java dispe-se da diretiva for. Estruturas de desvio de fluxo Destinadas a desviar a execuo do programa para uma outra parte, quebrando o fluxo seqencial de execuo. O desvio do fluxo pode ocorrer condicionalmente, quando associado a avaliao de uma expresso, ou incondicionalmente. No Java dispe-se das diretivas if, if...else e switch. Estruturas de repetio condicionais Semelhantes as estruturas de repetio simples mas cuja repetio est associada a avaliao de uma condio sendo geralmente utilizadas quando no se conhece de antemo o nmero necessrio de repeties. No Java dispe-se das diretivas while e do...while. Alm destas estruturas existem ainda: Mecanismos de modularizao Estruturas de controle de erros
53
Figura 83 - Variaes do Fluxo de execuo de um Programa Os mecanismos de modularizao so aqueles que nos permitem a construo de funes e procedimentos (dentro do paradigma procedural) ou mtodos (dentro da paradigma da orientao objetos) e sero discutidos na prxima seo. J as estruturas de controle de erros constituem uma importante contribuio a programao pois simplifica bastante a incluso e construo de rotinas de tratamento de erros dentro do cdigo. Antes de tratarmos especificamente das estruturas de controle da linguagem necessrio colocarmos algumas definies. Formalmente as instrues de um programa so chamadas diretivas (statements). Tradicionalmente as diretivas so escritas uma aps o outra num programa e so separadas de alguma forma, por exemplo com uma quebra de linha ou um caractere de pontuao. Em Java, tal como na linguagem C/C++, as diretivas so separadas uma das outras atravs do smbolo de pontuao ';' (ponto e vrgula), sendo possvel existir vrias diretivas numa mesma linha desde que separadas por um ponto e vrgula. Abaixo temos um exemplo hipottico de vrias diretivas colocadas seqencialmente:
diretiva1; diretiva2; diretiva3; ... diretivaN;

Como nas outras linguagens de programao, as estruturas de controle podem operar sobre diretivas isoladas (individuais) ou sobre vrias diretivas tratadas como um conjunto que denominado bloco. Um bloco em Java um grupo de diretivas delimitadas por chaves ({K}). Por sua vez um bloco de diretivas recebe um tratamento equivalente ao de uma nica diretiva individual.
{ diretiva1; diretiva2; diretiva3; ... diretivaN; } diretivaUnica;

Estruturas de repetio simples Como repetio simples consideramos um trecho de cdigo, isto , um conjunto de diretivas que
deve ser repetido um nmero conhecido e fixo de vezes. A repetio uma das tarefas mais comuns da programao utilizada para efetuarmos contagens, para obteno de dados, para impresso etc. Em Java dispomos da diretiva for cuja sintaxe dada a seguir:
for (inicializao; condio de execuo; incremento/decremento) diretiva;

O for possui trs campos ou sees, todas opcionais, delimitados por um par de parntesis que efetuam o controle de repetio de uma diretiva individual ou de um bloco de diretivas. Cada campo separado do outro por um ponto e vrgula. O primeiro campo usado para dar valor inicial a uma varivel de controle (um contador). O segundo campo uma expresso lgica que determina a execuo da diretiva associada ao for, geralmente utilizando a varivel de controle e outros valores.
Figura 84- Comportamento da Diretiva for Aps a execuo da seo de inicializao ocorre a avaliao da expresso lgica. Se a expresso avaliada como verdadeira, a diretiva associada executada, caso contrrio o comando for encerrado e a execuo do programa prossegue com o prximo comando aps o for. O terceiro campo determina como a varivel de controle ser modificada a cada iterao do for. Considera-se como iterao a execuo completa da diretiva associada, fazendo que ocorra o incremento ou decremento da varivel de controle. A seguir um exemplo de utilizao da diretiva for:
1 2 3 4 5 6 7 8 9 10 1 2 3 4 5 6 7 8
package livro.linguagem.estControle; import waba.sys.*; /** * Classe que demonstra o uso do FOR * @author Wellington * @version 1.0 */ public class ExemploFor extends waba.ui.MainWindow { public ExemploFor() { for(int j = 0; j < 10; j++) { System.out.println("Volta: " + j); } } }
Cdigo 11 Cdigo da ExemploFor Se executado, o exemplo acima dever exibir uma contagem de 0 at 9 onde cada valor exibido
55
numa linha do console. Estruturas de desvio de fluxo Existem vrias estruturas de desvio de fluxo que podem provocar a modificao da maneira com que as diretivas de um programa so executadas conforme a avaliao de uma condio. O Java dispe de duas destas estruturas: if e switch. O if uma estrutura simples de desvio de fluxo de execuo, isto , uma diretiva que permite a seleo entre dois caminhos distintos para execuo dependendo do resultado falso ou verdadeiro resultante de uma expresso lgica.
if (expresso_lgica) diretiva1; else diretiva2;

A diretiva if permite duas construes possveis: a primeira, utilizando a parte obrigatria, condiciona a execuo da diretiva1 a um resultado verdadeiro oriundo da avaliao da expresso lgica associada; a segunda, usando opcionalmente o else, permite que seja executada a diretiva1 caso o resultado da expresso seja verdadeiro ou que seja executada a diretiva2 caso tal resultado seja falso. Isto caracteriza o comportamento ilustrado pela Figura 7. A seguir um exemplo de uso da diretiva if.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
package br.com.softpalm; public class ExemploIf { /** * @param args */ public static void main(String[] args) { int x = 0; int y = 10; if (x == y) { System.out.println("x igual a y"); } else { System.out.println("x no igual a y"); } } }
Cdigo 12 Cdigo da classe ExemploIf (Reviso svn 3) Ao executar-se ente programa podem ocorrer duas situaes distintas como resultado: ou x igual a y ou diferente.
56
Figura 85 - Uso do if J o switch uma diretiva de desvio mltiplo de fluxo, isto , baseado na avaliao de uma expresso ordinal escolhido um caminho de execuo dentre vrios possveis. Um resultado ordinal aquele pertencente a um conjunto onde se conhecem precisamente o elemento anterior e o posterior, por exemplo o conjunto dos nmeros inteiros ou dos caracteres, ou seja, um valor dentro de um conjunto cujos valores podem ser claramente ordenados (0, 1, 2 .... no caso dos inteiros e 'A', 'B', 'C'... no caso dos caracteres). O switch equivale logicamente a um conjunto de diretivas if encadeadas, embora seja usualmente mais eficiente durante a execuo. Na Figura 86 temos ilustrado o comportamento da diretiva switch. A sintaxe desta diretiva a seguinte:
switch (expresso_ordinal) { case ordinal1: diretiva3; break; case ordinal2: diretiva2; break; default: diretiva_default; }
A expresso utilizada pelo switch deve necessariamente retornar um resultado ordinal. Conforme o resultado selecionado um dos casos indicados pela construo case ordinal. As diretivas encontradas a partir do caso escolhido so executadas at o final da diretiva switch ou at uma diretiva break que encerra o switch. Se o valor resultante no possuir um caso especfico so executadas as diretivas default colocadas, opcionalmente, ao final da diretiva switch.
Figura 86 - Comportamento da Diretiva switch Note que o ponto de incio de execuo um caso (case) cujo valor ordinal aquele resultante da
expresso avaliada. Aps iniciada a execuo do conjunto de diretivas identificadas por um certo caso, tais aes s so interrompidas com a execuo de uma diretiva break ou com o final da diretiva switch. A seguir temos uma aplicao simples que exemplifica a utilizao das diretivas
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
package br.com.softpalm; public class ExemploSW { /** * @param args */ public static void main(String[] args) { int numero = 2; switch (numero) { case 1: System.out.println("Um"); break; case 2: System.out.println("Dois"); break; case 3: System.out.println("Trs"); break; case 4: System.out.println("Quatro"); break; case 5: System.out.println("Cinco"); break; default: System.out.println("Maior que cinco"); } } }
Cdigo 13 Cdigo da ExemploSW (Reviso svn 4) Como a varivel nmero possui o valor 2 natural que ele deva escrever Dois na sada. Estruturas de repetio condicionais As estruturas de repetio condicionais so estruturas de repetio cujo controle de execuo feito pela avaliao de expresses condicionais. Estas estruturas so adequadas para permitir a execuo repetida de um conjunto de diretivas por um nmero indeterminado de vezes, isto , um nmero que no conhecido durante a fase de programao mas que pode ser determinado durante a execuo do programa tal como um valor a ser fornecido pelo usurio, obtido de um arquivo ou ainda de clculos realizados com dados alimentados pelo usurio ou lido de arquivos. Existem duas estruturas de repetio condicionais: while e do while. O while o que chamamos de lao condicional, isto , um conjunto de instrues que repetido enquanto o resultado de uma expresso lgica (uma condio) avaliado como verdadeiro. Abaixo segue a sintaxe desta diretiva enquanto seu o comportamento ilustrado a seguir.
1 2
while (expresso_lgica) diretiva;

Cdigo 14 - Exemplo de Sintaxe Note que a diretiva while avalia o resultado da expresso antes de executar a diretiva associada, assim possvel que diretiva nunca seja executada caso a condio seja inicialmente falsa. Um problema tpico relacionado a avaliao da condio da diretiva while o seguinte: se a condio
nunca se tornar falsa o lao ser repetido indefinidamente.
Figura 87 - Comportamento da Diretiva while O do while tambm um lao condicional, isto , tal como o while um conjunto de instrues repetido enquanto o resultado da condio avaliada como verdadeira mas, diferentemente do while, a diretiva associada executada antes da avaliao da expresso lgica e assim temos que esta diretiva executada pelo menos uma vez. Seguem a sintaxe da diretiva do while e uma ilustrao do seu comportamento.
do diretiva while (expresso_lgica);
Figura 88 - Comportamento da Diretiva do while A seguir temos exemplos da aplicao destas duas diretivas de repetio.
1 2 3 4
package br.com.softpalm; public class ExemploWhile {
59
5 6 7 8 9 10 11 12 13 14 15 16
/** * @param args */ public static void main(String[] args) { int i = 0; while (i < 100) { System.out.println("Volta: " + i); i++; } } }
Cdigo 15 Cdigo da classe ExemploWhile (Reviso SVN 6) O exemplo acima ilustra o uso da diretiva while tal como um lao de repetio simples equivalente a uma diretiva for como abaixo:
1 2 3
for (int i =0; i < 100); i++) { System.out.println("Volta: " + i); }

Cdigo 16 - Exemplo de Cdigo A seguir um exemplo da diretiva do...while.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
//Veja no incio do livro como obter os fontes package br.com.softpalm; /** * Classe que demonstra o uso do FOR * @author Wellington * @version 1.0 */ public class ExemploDoWhile { public static void main(String[] args) { int i = 0; do { System.out.println("Volta: " + i); i++; }while(i < 100); } }
Cdigo 17 Cdigo ExemploDoWhile
Estruturas de controle de erros

O Java oferece duas importantes estruturas para o controle de erros muito semelhantes as estruturas existentes na linguagem C++: try catch e try finally. Ambas tem o propsito de evitar que o programador tenha que realizar testes de verificao e avaliao antes da realizao de certas operaes, desviando automaticamente o fluxo de execuo para rotinas de tratamento de erro. Atravs destas diretivas, delimita-se um trecho de cdigo que ser monitorado automaticamente pelo sistema. A ocorrncia de erros no Java sinalizada atravs de excees, isto , objetos especiais que carregam informao sobre o tipo de erro detectado. Existem vrias classes de exceo adequadas para o tratamento do problemas mais comuns em Java, usualmente inclusas nos respectivos pacotes. excees especiais podem ser criadas em adio s existentes ampliando as possibilidades de
60
tratamento de erro. Com o try catch a ocorrncia de erros de um ou mais tipos dentro do trecho de cdigo delimitado desvia a execuo automaticamente para uma rotina designada para o tratamento especfico deste erro. A sintaxe do try catch a seguinte:
try { diretiva_normal; } catch (exception1) { diretiva_de_tratamento_de erro1; } catch (exception2) { diretiva_de_tratamento_de erro2; }
O cdigo a seguir possui uma ao muito perigosa, trabalhar com conexo a fonte de dados, diretrios, arquivos, dispositivos E/S so todas aes complicadas e com grande chance de exceptions.
1 2 3 4 5 6 7 8 9
try { File f = new File("/sdcard/GrupoAndroid/"); f.mkdir(); } catch(Exception ex) { System.out.println(ex.getMessage()); } No cdigo acima se ocorrer erro na ao mkdir() ento a aplicao deve desviar a execuo para o catch mais apropriado (no exemplo s temos 1) e executar o cdigo de tratamento de erro, neste caso apenas estamos printando na sada o ocorrido.
Com o try finally temos um comportamento bastante diferente: uma rotina de finalizao sempre executada, isto , o trecho particular de cdigo contido na clusula finally sempre executado ocorrendo ou no erros dentro do trecho delimitado pela clusula try. A sintaxe do try finally colocada a seguir:
try { diretiva_normal; } finally { diretiva_de_tratamento_de erro; }

Isto particularmente interessante quando certos recursos do sistema ou estruturas de dados devem ser liberadas, independentemente de sua utilizao.
1 2 3 4 5 6 7 8 9 10 11 12
//Veja no inicio do livro como obter os fontes package livro.linguagem.erros; //No pacote waba.io existe uma classe chamada Catalog import waba.io.*; /** * Classe que demonstra um erro grave, pois o catalog deve ser fechado */ public class ExemploBerro extends waba.ui.MainWindow { public ExemploBerro() {
61
13 14 Catalog catalog = new Catalog("softpalm.com.br.ExemploBerro", 15 Catalog.CREATE_EMPTY); 16 //Se ocorrer erro dentro deste if o catalog no fechado corretamente 17 if (catalog.isOpen()) { 18 byte[] b = new byte[2]; 19 catalog.addRecord(2); 20 catalog.writeBytes(b, 0, b.length); 21 } 22 catalog.close(); 23 24 } 25 26 public void onStart() { 27 28 } 29 }
Cdigo 18- Cdigo da classe ExemploBerro Na classe exposta na listagem acima (ver Cdigo 18) estamos criando um objeto do tipo Catalog na linha 14. Se tudo estiver correto ele deve abrir o objeto e utilizar o mtodo addRecord() conforme podemos ver na linha 19. Se algum erro ocorrer na linha 19 o objeto catalog no ser fechado na linha 22.
1 //Veja no inicio do livro como obter os fontes 2 package livro.linguagem.erros; 3 4 //No pacote waba.io existe uma classe chamada Catalog 5 import waba.io.*; 6 7 /** 8 * Classe que demonstra o uso do finally para executar alguma ao 9 */ 10 public class ExemploBcorrecao extends waba.ui.MainWindow { 11 12 13 public ExemploBcorrecao() 14 { 15 16 try //Try 1 17 { 18 Catalog catalog = new Catalog("softpalm.com.br.ExemploBerro",Catalog.CREATE_EMPTY); 19 try //Try 2 20 { 21 if(catalog.isOpen()) 22 { 23 byte[] b = new byte[2]; 24 catalog.addRecord(2); 25 catalog.writeBytes(b, 0, b.length); 26 } 27 } 28 catch(Exception ex) //Catch do Try 2 29 { 30 waba.sys.Vm.debug("Se ocorreu erro aqui, devemos fechar o catalog pois ele se encontra aberto."); 31 } 32 finally // Finally do Try 2
33 { 34 catalog.close(); 35 } 36 } 37 catch(Exception ex) //Catch do Try 1 38 { 39 waba.sys.Vm.debug("O catalog no foi aberto, ento ele no deve ser fechado."); 40 } 41 42 43 } 44 45 public void onStart() 46 { 47 48 } 49 }
Cdigo 19 - Cdigo da classe ExemploBcorreto No cdigo da classe ExemploBcorreto utilizamos uma seqncia de try...catch, em destaque o try..catch..finally, repare que se ocorrer erros entre a linha 21 e 26 o catalog tem total garantia que ser fechado, pois quer ocorra erros ou no o bloco finally sempre ser executado para o Try 2 (linhas 19 27). Utilizamos dois pois pode haver outro erro, o erro na linha 18 quando o catalog criado, neste caso o catalog no precisa ser fechado pois nem foi aberto, se isso ocorrer ser disparado o catch da linha 37.
Gerando suas Prprias Excees

O exemplo a seguir ensina como trabalhar com throw, a palavra chave usada para levantar excees. Este exemplo se baseia na classe ExemploAerro conforme descrito no Error! Reference source not found.. Nossa exceo ser gerada quando nas operaes de fraes ocorrer uma diviso por zero. Em Java, excees so instncias de classes que pertencem a hierarquia que iniciada, encabeada, pela classe Throwable. Neste exemplo construiremos nossa exceo herdando de Exception que por sua vez herda de Throwable.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
//Veja no inicio do livro como obter os fontes package livro.linguagem.erros; /** * Implementao de uma classe especfica para * manipular informae de exception, poderiamos * gravar no arquivo de Log este erro * @author Wellington * @version 1.0 */ public class ExceptionDvZero extends Exception { /** Mensagem de erro */ private String mensagem = ""; public ExceptionDvZero(String mensagem) { this.mensagem = mensagem; }
63
20 21 22 23 24 25 26 27 28 29
/** * Encapsulamento da varivel mensagem, neste caso * esta varivel somente leitura */ public String getMessage() { return this.mensagem; } }
Cdigo 20 Classe ExceptionDvZero Crie uma nova classe e escreva o seguinte cdigo:
1 //Veja no inicio do livro como obter os fontes 2 package livro.linguagem.erros; 3 4 /** 5 * Classe que demonstra o uso de Throws para tratar excees 6 * @author Wellington 7 * @version 1.0 8 */ 9 public class ExemploAcorrecao2 extends waba.ui.MainWindow { 10 11 public ExemploAcorrecao2() 12 { 13 int x = 0; 14 int y = 10; 15 16 try 17 { 18 int valor = dividir(x,y); 19 waba.sys.Vm.debug("Valor: " + valor); 20 } 21 catch(Exception ex) 22 { 23 waba.sys.Vm.debug("Erro: " + ex.getMessage()); 24 } 25 } 26 27 /** 28 * Mtodo que recebe dois inteiros, se o divisor vor = a zero 29 * ele libera uma exceo e no executa a diviso 30 * @param x Divisor 31 * @param y Dividendo 32 * @return Se no ocorrer erro um nmero inteiro resultada o da diviso 33 * @throws ExceptionDvZero Erro se divisor = a zero 34 */ 35 public int dividir(int x, int y) throws ExceptionDvZero 36 { 37 if(x == 0) 38 { 39 throw new ExceptionDvZero("A varivel X no pode conter um valor 0"); 40 } 41 return y/x; 42 }
43 44 }
Cdigo 21 Cdigo da classe ExemploAcorrecao2 Outro fato importante que um bloco catch tambm pode gerar excees, assim se voc pegou uma exceo e resolveu que no consegue trat-la voc pode fazer um throw dela mesma ou mudar a classe da exceo e continuar propagando (throw de outra exceo), ou fazer o que voc pode para reparar o erro e jogar uma exceo para que o que voc fez seja completado por outros mtodos. Lembre-se que se voc pegou uma exceo, ela para de propagar.
Figura 89 - Execuo da classe ExemploAcorrecao2
65
6
5 Programao Orientada a Objetos
Objetivo Deste Apndice
Endender os princpios da Programao Orientada a Objetos; Conhecer as estruturas Java.
Introduo
Sabemos que na programao temos variveis, at o momento estudamos as primitivas porem j servem de base para nosso estudo de Programao Orientada a Objetos (POO). Quando criamos uma varivel primitiva, tal como o int estamos reservando na memria um determinado espao, a quantidade de bits e como estes bits so iniciados por padro esto definidos no tipo da varivel, que neste caso inteiro. Digamos que eu queira construir o meu tipo, e ainda queira que este tipo seja composto por outros tipos. E se esse meu tipo alm das propriedades (valores que podem ser armazenados) eu queira definir comportamentos. Em POO eu posso construir os meus tipos de acordo com minhas necessidades e a partir destes tipos criar objetos complexos (contraste com variveis primitivas). Preciso ento criar antes de tudo um molde, este molde a especificao para os objetos, algo mais ou menos como no tipo int no qual contm o molde para as variveis declaradas como inteiros. Esse molde ser chamado de classe. Como uma classe pode ser composta de outros tipos internos vamos dizer que estes tipos so os atributos da classe e se pode ter comportamento podemos dizer que temos mtodos. Ateno: Repare que comportamento ao, logo possui bloco de cdigo. Em muitas linguagens estes mtodos so chamados de funes. Exemplo: Um programa que utiliza uma interface controladora de um motor eltrico provavelmente definiria a classe motor. Os atributos desta classe seriam: temperatura, velocidade, tenso aplicada. Estes provavelmente seriam representados na classe por tipos como int ou float. Os mtodos desta classe seriam funes para alterar a velocidade, ler a temperatura, etc. Exemplo: Um programa editor de textos definiria a classe pargrafo que teria como um de seus atributos uma String ou um vetor de Strings, e como mtodos, funes que operam sobre estas strings (corretor ortogrfico, formatador de texto). Quando um novo pargrafo digitado no texto, o editor cria a partir da classe Paragrafo.java um objeto contendo as informaes particulares do novo texto. Isto se
66
chama instanciao ou criao do objeto.
Especificando uma Classe

Suponha um programa que controla um motor eltrico atravs de uma sada serial. A velocidade do motor proporcional a tenso aplicada e esta proporcional aos bits que vo para sada serial e passam por um conversor digital analgico. Vamos abstrair todos estes detalhes por enquanto e modelar somente a interface do motor como uma classe, a pergunta que mtodos e que atributos deve ter nossa classe, que argumentos e valores de retorno devem ter os mtodos? Representao da velocidade A velocidade do motor ser representada por um atributo inteiro (int). Usaremos a faixa de bits que precisarmos, caso o valor de bits necessrio no possa ser fornecido pelo tipo, usaremos ento o tipo long, isto depende do conversor digital analgico utilizado. Representao da sada serial O motor precisa conhecer a sua sada serial, a sua ligao com o motor do mundo real. Suponha uma representao em hexadecimal do atributo endereo de porta serial, um possvel nome para o atributo: enderecomotor. No se preocupe em saber como usar a representao hexadecimal. Alterao do valor da velocidade Internamente o usurio da classe motor pode desejar alterar a velocidade, cria-se ento o mtodo: public void altera_velocidade(int novav);. O cdigo anterior corresponde ao cabealho do mtodo ele definido junto com a classe motor, associado a ela. O valor de retorno da funo que implementa o mtodo void, poderia ser criado um valor de retorno (boolean) que indicasse se o valor de velocidade era permitido e foi alterado ou no era permitido e, portanto no foi alterado. O ato de invocar um mtodo tambm chamado de mensagem, ento quando passamos uma mensagem para o objeto que est executando este mtodo estamos invocando sua funcionalidade atravs do mtodo. No faz sentido usar ou chamar este mtodo separado de uma varivel do tipo motor, mas ento porque na lista de argumentos da funo no se encontra um motor? Este pensamento reflete a maneira de associar dados e cdigo (funes) das linguagens procedurais. Em linguagens orientadas a objetos o cdigo e os dados so ligados de forma diferente, a prpria declarao de um tipo definido pelo usurio j engloba as declaraes das funes inerentes a este tipo. Note que no fornecemos o cdigo do mtodo neste pondo de nosso estudo, isto no importante por hora, a preocupao com a interface definida pela classe: seus cabealhos de mtodos e atributos. Apenas pense que sua interface deve ser flexvel de modo a no apresentar entraves para a criao do cdigo que seria feita numa outra etapa. Nesta etapa teramos que imaginar que o valor numrico da velocidade deve ir para o conversor aonde ir se transformar numa diferena de potencial a ser aplicada nos terminais do motor, etc.
Figura 90 - Classe representada na UML Implementando cdigo descrito na listagem abaixo (ver Cdigo 22 - Cdigo da Classe Motor v.: 1.0).
1 2
package br.com.softpalm.poo;
67
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
// A linha abaixo representa a declarao de uma classe public class Motor { // Duas variveis primitivas so criadas dentro da nossa classe // repare que a classe se torna um tipo composto de outros tipos // chamamos estas variveis de atributos da classe public int velocidade; public int endereco; // A estrutura abaixo um mtodo ou seja, uma funcionalidade repare que o mtodo acessa o atributo velocidade usando o operador this, no precisa se preocupar com este operador que ser estudado public void altera_velocidade(int novav) { this.velocidade = novav; } // Fechar a classe }
Cdigo 22 - Cdigo da Classe Motor v.: 1.0
Objetos
Objetos so instncias de uma classe. Quando um objeto criado ele precisa ser inicializado, ou seja, para uma nica classe de nome Motor podemos ter vrios objetos durante a execuo de um programa.
1 // Exemplo de dois objetos (m1 e m2) sendo instanciados a partir da nossa 2 classe Motor 3 Motor m1 = new Motor(); 4 Motor m2 = new Motor();
Cdigo 23 - Exemplo de objetos Objetos podem conter objetos, ou seja, os atributos de um objeto podem ser objetos, da mesma classe ou no. Objetos podem ser passados pela rede, armazenados em meio fsico. Objetos possuem um estado e um comportamento. Mtodos podem receber objetos como argumentos, podem declarar objetos como variveis locais, podem chamar outros mtodos. Voc pode chamar um mtodo (mandar uma mensagem) para objetos em outras mquinas atravs de sua rede. Um objeto pode ser visto como um RECORD, s que com uma tabela de funes que podem ser chamadas para ele. Na verdade esta definio no muito terica, mas um bom comeo para os programadores que esto acostumados com linguagens procedurais. Na verdade podemos fazer com objetos muito mais do que fazemos com records e procedimentos em Pascal.
Atributos
A classe crculo especificada em um arquivo separado do arquivo da classe que contm o mtodo onStart(). importante entender este exemplo, quando voc estudar interfaces grficas, poder usar a classe crculo pr-definida na linguagem para desenhar crculos que se movem na tela. Embora no tenhamos explicado com detalhes os tipos bsicos da linguagem, usaremos neste exemplo o tipo float (real), e nas explicaes o tipo String e o tipo int (inteiro). No final deste tpico forneceremos uma explicao detalhada sobre tipos.
1 2 3
package br.com.softpalm.geometria; /**

4 5 6 7 8 9 10 11 12 13 14 15 16
* Classe que descreve uma circunferncia * @author Wellington * @version 1.0 */ public class Circulo { // Atributo RAIO da circunferncia public float raio; // Coordenada do ponto central da circunferncia public float x; public float y; }
Cdigo 24 - Cdigo da classe Circulo
Agora vamos utilizar a classe Circulo para gerar objetos.
1 package br.com.softpalm.geometria; 2 3 /** 4 * Classe que utiliza a classe Circulo 5 * @author Wellington 6 * @version 1.0 7 */ 8 public class UsaCirculo { 9 public static void main(String[] args) { 10 11 Circulo umcirc; // declaracao de uma variavel circulo no metodo main. 12 umcirc = new Circulo(); // alocacao dessa variavel 13 System.out.println("(" + umcirc.x + "," + umcirc.y + "," + umcirc.raio 14 + ")"); 15 umcirc.x = umcirc.x + 17; 16 System.out.println("(" + umcirc.x + "," + umcirc.y + "," + umcirc.raio 17 + ")"); 18 19 } 20 21 }
Cdigo 25 Cdigo da classe livro.poo.geometria.UsaCirculo Ento usamos o perador new para criar as instancias dos objetos, no adianta apenas delcarar conforme foi feito na linha 11, temos que instanciar tambm (ver linha 12). Depois do objeto instanciado podemos utilizar os atributos.
Coleta automtica de lixo

A limpeza do objeto feita pela linguagem Java e chamamos de automatic garbage collection, voc no precisa se preocupar com ela. Aps a execuo do mtodo main, a memria do objeto umcirc j pode ser liberada, o que normalmente no ocorre de imediato, pois o ambiente da linguagem executa um tread em baixa prioridade que libera de tempos em tempos os espaos inutilizados de memria, tirando proveito, por exemplo, de eventuais pausas de iterao do usurio com o programa. Por executar em um tread entenda paralelamente ou quase paralelamente, voltaremos a este tpico mais adiante.
69
Acesso aos atributos e mtodos e alteraes dos atributos

O acesso aos atributos da varivel (objeto) umcirc deve ser feito usando o nome do objeto e o nome do atributo deste, separados por um ponto: umcirc.raio = 10.0; . Note que raio sozinho no faz sentido no programa, precisa-se especificar de que objeto se deseja alterar ou obter o raio. A sintaxe de chamadas de mtodos semelhante sintaxe descrita acima usada para atributos, s que ao invs de nome do atributo temos o nome do mtodo seguido dos parnteses que podem conter zero ou mais argumentos. Volte ao primeiro programa (HelloWorld) e verifique a declarao do mtodo onCreate().
Mtodos
Os mtodos determinam o comportamento dos objetos de uma classe. Quando um mtodo invocado, se diz que o objeto est recebendo uma mensagem (para executar uma ao). Programas complexos formam conjuntos de objetos que trocam mensagens entre si gerenciando inclusive os recursos do sistema.
Sintaxe de declarao de mtodos

A sintaxe simplificada para a declarao de mtodos de uma classe :
especificador_de_acesso lista_de_argumentos ) { /*codigo */ }
tipo_de_retorno
nome_do_metodo
O programa a seguir exemplifica chamadas de mtodos, para tal define um objeto que serve como contador, a implementao representa a contagem no atributo num que um nmero inteiro. Os mtodos so simples: + incrementa(): Incrementa a varivel interna em + uma unidade; + decrementa(): Decrementa a varivel interna em uma unidade; + getNum(): Retorna o valor da varivel interna, esta varivel segue os conceitos de encapsulamento; + Contador(): Construtor da classe.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
//Veja no inicio do livro como obter os fontes package br.com.softpalm.poo; /** * Classe que implementa mecanismos de um contador * @author Wellington * @version 1.0 */ public class Contador { /** Atributo que armazena o valor do contador */ private int num = 0; /** * Mtodo que incrementa o atributo em +1 */ public void incrementa() { num++; } /**
70
22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38
* Mtodo que decrementa um atributo em -1 */ public void decrementa() { num--; } /** * Mtodo que prove o encapsulamento da varivel num, afinal * esta varivel no pode ser alterada por outro objeto. * @return Valor do contador */ public int getNum() { return this.num; } }
Cdigo 26 Cdigo da classe Contador Esta classe foi construda somente para armazenar valores de contadores, este valor armazenado em uma varivel interna que no pode ser alterada diretamente pela classe que utiliza um objeto de sua instancia. Abaixo desenvolvemos uma classe que utiliza os servios disponibilizados pela classe Contador.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
//Veja no inicio do livro como obter os fontes package br.com.softpalm.poo; /** * Classe que demonstra o uso da classe Contador * @author Wellington * @version 1.0 */ public class UsaContador { Public static void main(String[] args) { Contador cont = new Contador(); //Contador com valor padro System.out.println ("Antes de incrementar: " + cont.getNum()); //Incrementando cont.incrementa(); //Contador incrementado System.out.println ("Depois de incrementar: " + cont.getNum()); } }
Cdigo 27 Cdigo da classe UsaContador Quando a classe acima executada, inicia-se criando um objeto a partir da classe Contador(). Na linha 16 estamos imprimindo na tela o valor inicial do objeto. Na linha 19 estamos incrementando este valor para imprimir novamente na linha 22. Na figura abaixo temos um Print-Screen que demonstra a execuo desta classe.
71
Figura 91 - Executando o Cdigo 27
this
O operador this uma palavra chave usada em um mtodo como referncia para atributos e mtodos do prprio objeto corrente, ela tem o significado de: o mtodo/atributo que estou chamando est no escopo de eu mesmo. Suponha uma classe (ver Figura 92) que possui a seguinte declarao de atributo: private String nome = , esta varivel publica somente dentro da classe, logo pode ser acessada normalmente. Agora deve-se escrever um mtodo que tem a finalidade de prover a alterao desta varivel pelo meio externo, isso feito na linha 6, repare que na linha 6 declaramos uma nova varivel com o mesmo nome da varivel declarada na linha 4. Porem na linha 8 estamos dizendo que a varivel marcada pelo this refere-se a varivel criada na linha 4 e a varivel (linha 8) sem o this refere-se a varivel criada na linha 6. A varivel criada na linha 4 dizemos que tem o escopo da classe, pois pode ser visualizada em toda a classe, j a varivel criada na linha 6 possui apenas o escopo do mtodo em que criada.
Figura 92 - Uma classe qualquer Ateno: uma boa prtica o uso do this, mesmo que a ocorrncia do nome da varvel que est usando somente aparece no escopo da classe.
Sintaxe de chamada ou acesso a mtodos

A sintaxe de chamada ou acesso mtodos semelhante a sintaxe de acesso aos atributos, com exceo dos parnteses que contm a lista de argumentos da funo que implementa o mtodo, mesmo que a lista seja vazia eles devem estar presentes: umcontador.incrementa();. Primeiro inserese o nome do objeto e depois a chamada da funo, estes so separados por um ponto. Cuidado para no esquecer os parnteses em programas futuros, este um erro bastante comum.
Nova verso do programa Circulo

Agora reapresentaremos o programa Circulo baseado no exemplo 0, porm um pouco mais complicado: Mtodo move O mtodo move altera as coordenadas do objeto. O objeto tem suas coordenadas x e y somadas com os argumentos dessa funo. Note que este mtodo representa uma maneira mais segura, clara, elegante de alterar as coordenadas do objeto do que acess-las diretamente da seguinte forma: ac.x+=dx;. ac.y+=dy;. Lembre-se que ac.x+=dx uma abreviao para ac.x=ac.x+dx;. Mtodo mostra
O mtodo mostra imprime na tela, de forma compacta, os atributos do objeto.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37
//Veja no inicio do livro como obter os fontes package br.com.softpalm.geometria; /** * Classe que descreve uma circunferncia * * @author Wellington * @version 2.0 */ public class CirculoV2 { /** atributo raio do circulo */ public float raio; /** Posio X, coordenada cartesiana */ public float x; /** Posio Y, coordenada cartesiana */ public float y; /** * Movimenta um circulo * @param dx incremento na posio X * @param dy incremento na posio Y */ public void move(float dx, float dy) { this.x += dx; y += dy; } /** * Imprime as informaes do objeto */ public void mostra() { System.out.println ("(" + x + "," + y + "," + raio + ")"); } }
Cdigo 28 - Cdigo da classe CirculoV2 A classe abaixo foi construda somente para manipular objetos criados a partir da classe CirculoV2.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
//Veja no inicio do livro como obter os fontes package br.com.softpalm.geometria; /** * Classe que utiliza a classe CirculoV2 * * @author Wellington * @version 2.0 */ public class UsaCirculoV2 { public static void main(String[] args) { CirculoV2 umcirc; // declaracao de atributo circulo umcirc = new CirculoV2(); umcirc.x = 0;
73
16 17 18 19 20 21 22 23 24 } 25 26 }
umcirc.y = 0; umcirc.raio = 12; umcirc.mostra(); umcirc.move(10, 10); umcirc.mostra(); umcirc.x = 100; umcirc.mostra();
Cdigo 29 - Cdigo da nova verso do UsaCirculo A execuo do cdigo acima pode ser visto na figura abaixo.
Figura 93 - Execuo da classe UsaCirculoV2
Construtores
Construtores so mtodos especiais chamados pelo sistema no momento da criao de um objeto. Eles no possuem valor de retorno, porque voc no pode chamar um construtor para um objeto, voc s usa o construtor no momento da inicializao do objeto. Construtores representam uma oportunidade de inicializar seus dados de forma organizada, imagine se voc esquece de inicializar corretamente ou o faz duas vezes, etc. Um construtor tem sempre o mesmo nome da classe a qual pertence. Para a classe String, prdefinida na linguagem o construtor tem a forma String(Constante do tipo String); com o argumento entre aspas que especificado pelo programador. Ele seria chamado automaticamente no momento da criao, declarao de uma String, sem necessidade de uso do nome do construtor como mtodo, apenas dos argumentos:
1 2 3
String str; str = new String("softpalm.com.br"); //Construtor String(String texto) System.out.println(str.length());

Nos exemplos anteriores tambm usvamos construtores no momento de inicializar nossos objetos, s que eles no possuam argumentos, por isso estavam implcitos. Existem variaes sobre o tema que veremos mais tarde: sobrecarga de construtor, copy constructor, construtor de corpo vazio. O exemplo a seguir simples, semelhante aos anteriores, preste ateno no mtodo com o mesmo nome que a classe, este o construtor:
1 2 3 4 5 6 7
//Veja no inicio do livro como obter os fontes package br.com.softpalm.geometria; /** * Classe Ponto * @author Wellington * @version 1.0
8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41
*/ public class Ponto { /** Variveis que armazenam a posio no plano */ private float x, y; /** * Construtor da classe * @param x Novo valor para X * @param y Novo valor para Y */ public Ponto(float x, float y) { this.x = x; this.y = y; } /** * Movimenta um ponto no plano * @param dx Incremento X * @param dy Incremento Y */ public void move(float dx, float dy) { this.x += dx; this.y += dy; } /** * Escreve os valores X e Y */ public void mostra() { System.out.println("(" + this.x + "," + this.y + ")"); } }
Cdigo 30 - Cdigo da classe Ponto Agora vamos desenvolver a classe que utiliza o Ponto, crie uma nova classe chamada UsaPonto e escreva o seguinte cdigo:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
//Veja no inicio do livro como obter os fontes package br.com.softpalm.geometria; /** * Classe que demonstra o uso do Ponto * @author Wellington * @version 1.0 */ public class UsaPonto { public UsaPonto() { Ponto ap; ap = new Ponto((float) 0.0, (float) 0.0); ap.mostra(); ap.move(1, 1); ap.mostra(); } public static void main(String[] args) {
75
21 22 } 23 }
UsaPonto usar = new UsaPonto();
Cdigo 31 - Cdigo da classe UsaPonto Quando esta classe executada, o construtor automaticamente invocado (dentro do cdigo main). Neste construtor temos um objeto chamado ap, este objeto recebe em seu construtor dois valores que sero armazenados, em seguida podemos utilizar este objeto para exibir valores ou at alterar estes valores. Veja na figura abaixo o resultado da execuo da classe.
Figura 94 - Resultado da execuo da classe UsaSPonto
Destrutores Ou finalizers
A presena de coleta automtica de lixo torna o conceito de destrutores um pouco diferente de seus equivalentes em outras linguagens orientadas a objetos. Em Java destrutores so mtodos chamados pelo sistema quando a memria de um objeto est para ser liberada pelo coletor automtico de lixo (no quando est para ser coletada). A sintaxe dos destrutores a seguinte:
protected void finalize() { //codigo para arrumar a casa, antes que o objeto seja apagado }
Note que o que caracteriza o construtor ter o mesmo nome da classe, j o destrutor caracterizado por possuir o nome finalize. Voc pode chamar o destrutor, mas isso no implica que o objeto ser deletado. Ao contrrio dos construtores, os destrutores no tem argumentos, mas possuem valor de retorno que igual a void. Os destrutores so muito teis para limpar a casa quando um objeto deixa de ser usado. Um exemplo bastante comum do uso de destrutores o de um objeto que lida com arquivos que devem ser fechados quando o objeto for destrudo (ver Cdigo 19). Existem outros casos onde um objeto deve comunicar aos outros objetos que ser inutilizado, destrudo, ou seja: sair do programa conforme figura abaixo.
Figura 95 - Exemplo de processamento com finalizador Em Java, que possui coleta automtica de lixo, um objeto passa a no existir mais no programa quando nenhuma varivel faz referncia a ele. Nesse ponto, ele armazenado no coletor automtico de lixo, onde receber o tratamento adequado. Um n de uma lista ligada pode ser apagado simplesmente fazendo o n anterior apontar para o posterior a ele. Os programadores no acostumados com esse conceito precisam ouvir a seguinte frase: Voc no obrigado a liberar explicitamente a memria de um objeto como feito em C++ e outras linguagens. Se estivssemos, por exemplo, em C++ que no possui coleta automtica de lixo, o destrutor seria chamado sempre que a memria de um objeto fosse desalojada, o que feito pelo programador atravs de uma chamada a delete nomedoobjeto(); . Em Java a liberao de memria que feita pelo coletor automtico de lixo que executado de
76
modo assncrono com o restante do programa, ou seja, voc no pode contar com o fato de que o destrutor ser chamado imediatamente aps o momento em que seu objeto sai de escopo, a no ser que o programa seja executado com o modo assncrono do coletor automtico de lixo desligado (java -noasyncgc NomePrograma).
Ponteiros, Referncias e Objetos

Algum pode ter achado estranho que no foram discutidos ponteiros em Java, ocorre que eles no existem nessa linguagem. Existem estudos que afirmam que erros com ponteiros so um dos principais geradores de bugs em programas, alm disso com todos os recursos que temos no precisaremos deles. Os programadores acostumados ao uso de ponteiros (e aos erros decorrentes desse uso) acharo natural e segura a transio para Java onde passaro a usar principalmente vetores e classes. A estruturao de seu cdigo dever agora ser feita em um modelo que se baseia no uso de objetos (vetores e Strings tambm so objetos). Objetos superam a representatividade obtida com records, funes isoladas e ponteiros. De certo modo voc estar usando referncias, mas de forma implcita. Por exemplo: objetos so alocados dinamicamente com new, eles so referncias ou ponteiros para posies na memria, mas a linguagem mascara este fato por razes de segurana. Como objetos so ponteiros (s que transparentes para voc), nos depararemos com o problema de reference aliasing quando discutirmos cpia de objetos com outros objetos como atributos.
Passagem por Referncia

Linguagens como Pascal ou C criam meios de passar parmetros por valor ou por referncia. Como Java no possui ponteiros, a passagem por referncia deve ser feita atravs de objetos. Se o parmetro j um objeto, ento a passagem dele obrigatoriamente por referncia. No caso de tipos simples, podemos pass-los dentro de vetores que so objetos, ou ento criar classes para embalar, empacotar estes tipos. Dada a necessidade destas classes, elas j foram definidas na linguagem. So classes definidas para conter cada tipo bsicos e permitir certas converses entre eles, falaremos destas classes conforme necessitarmos de seu uso. As vezes estas classes so chamadas de wrappers.
Vetores e Matrizes
Vetores so objetos, eles possuem papel importante no estilo de programao desta linguagem que exclui ponteiros. Por serem objetos, vetores so obrigatoriamente alocados de maneira dinmica. O exemplo a seguir aloca um vetor de inteiros com trs posies, seguindo uma sintaxe semelhante a de alocao de objetos:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
//Veja no inicio do livro como obter os fontes package br.com.softpalm.vetores; /** * Classe que demonstra o uso simples de um vetor * * @author Wellington * @version 1.0 */ public class SimplesVetor{ public static void main(String[] args) { int vetor[] = new int[5]; vetor[0] = 0; vetor[1] = 10; vetor[2] = 20; vetor[3] = 90; vetor[4] = 100;
77
20 21 22 23 24 } 25 26 }
for(int i = 0; i < vetor.length; i++) { System.out.println("I: " + i + " Valor: " + vetor[i] ); }
Cdigo 32 - Cdigo da classe SimplesVetor No cdigo acima, estamos criando na linha 13 um simples vetor de 5 posies, na linha 14 inserimos o valor zero na primeira posio do vetor. Em Java vetor inicia-se na posio 0. Na linha 20 estamos realizando um lao for para imprimir os valores armazenados no vetor. Abaixo temo uma imagem que ilustra esta ao.
Figura 96 - Execuo da classe SimplesVetor
Encapsulamento
Encapsulamento, data hiding um conceito importante em orientao a objetos. Neste tpico vamos falar das maneiras de restringir o acesso as declaraes de uma classe e a prpria classe, isto feito atravs do uso das palavras reservadas conhecidas como modificador de acesso (public, private e protected) que so qualificadores (ver Figura 92). Algum pode estar se perguntando o porqu de se restringir o acesso a certas partes de uma classe. A idia simples, devemos fornecer ao usurio, cliente de uma classe, o necessrio e somente o necessrio para que ele tire proveito da funcionalidade desta classe. Os detalhes devem ser omitidos, somente a lista de operaes a qual uma classe deve atender fica visvel. Os benefcios so muitos: clareza do cdigo, minimizao de erros, facilidade de extenso. Talvez a facilidade de modificao seja o mais importante dos benefcios. Como a classe conhecida pela sua interface, muito fcil mudar a representao interna sem que o cliente, usurio, perceba a diferena Estaremos preocupados em separar design de implementao, Java uma linguagem boa de programar em termos de design e em termos de implementao. Programar tendo em vista o design tambm chamado de programming in the large, enquanto que programar tendo em vista implementao, codificao chamado de programming in the small. Alguns programadores experientes afirmam que Java se parece com C quando estamos preocupados com codificao, mas quando estamos preocupados com design, Java se assemelha a Smalltalk. Com encapsulamento voc ser capaz de criar componentes de software reutilizveis, seguros, fceis de modificar.
Encapsulando Mtodos e Atributos

At agora no nos preocupvamos com o modo de acesso de declaraes de uma classe, pois, mesmo sem saber o porqu voc foi avisado para qualificar todos os atributos e mtodos de suas classes como public o que significa que eles so acessveis, visveis, em qualquer local de seu cdigo. Por visvel entenda o seguinte: se o atributo x do objeto UmPonto no visvel por exemplo fora de sua classe, ento no faz sentido escrever em main: UmPonto.x=0; . Mas ento como controlar o acesso de atributos e mtodos em uma classe? Simples, atravs das palavras reservadas private, public e protected cujos significados quando qualificando mtodos e
78
atributos (private e public podem tambm qualificar classes) so descritos abaixo: public Estes atributos e mtodos so sempre acessveis em todos os mtodos de todas as classes. Este o nvel menos rgido de encapsulamento, que equivale a no encapsular. Estes atributos e mtodos so acessveis somente nos mtodos(todos) da prpria classe. Este o nvel mais rgido de encapsulamento.
private
protected
Estes atributos e mtodos so acessveis nos mtodos da prpria classe e suas subclasses, o que ser visto em Herana 0.
Nada especificado equivale a package ou friendly
Estes atributos e mtodos so acessveis somente nos mtodos das classes que pertencem ao package em que foram criados. Este modo de acesso tambm chamado de friendly.
(existem outros qualificadores, no relacionados com encapsulamento que sero explicados depois) Protected ser explicado no tpico Herana, pois este no ter grande utilidade neste momento, por hora vamos focalizar nossa ateno em private e public que qualificam os atributos e mtodos de uma classe quanto ao tipo de acesso (onde eles so visveis). Public, private e protected podem ser vistos como qualificadores ou specifiers. Fica fcil entender essas declaraes se voc pensar no seguinte: esses qualificadores se aplicam aos mtodos e atributos que vem imediatamente aps eles. Agora vamos entender o que private e o que public. Vamos supor que voc instanciou (criou) um objeto do tipo Ponto em seu programa:
Ponto meu; //Declarao da varivel meu=new Ponto();//gerando a instancia

No exemplo Cdigo 30 - Cdigo da classe Ponto vimos a maneira correta de se utilizar o encapsulamento, veja que impossvel acessar a varivel conforme o cdigo abaixo:
meu.x=(float)5.0; //No d para executar, x privado

Voc pode escrever: meu.move(5.0,5.0); porque sua declarao (move) est como public na classe, em qualquer lugar se pode escrever meu.move(5.0,5.0);. Quando Utilizar Encapsulamento? Em muitos livros voc vai encontrar Use encapsulamento sempre..., em outros o leitor encontra uma lambana de cdigo terrvel, fica a pergunta: Quando utilizar o encapsulamento? O programador deve ter bom censo, visto que estamos trabalhando com dispositivos de baixo recurso, eu particularmente utilizo a seguinte regra: Uma regra de negcio: Alguma regra que no permite a entrada de qualquer valor, exemplo idade de uma pessoa, esta varivel no pode ser negativa; Quando a varivel somente Leitura ou somente Escrita: Em alguns casos o valor da varivel no pode ser alterado, imagine o atributo razao na classe Cliente, em algumas foras de vendas este atributo no pode ser alterado, ele est somente para leitura. Se a sua varivel se enquadra em alguma destas clusulas ento se deve utilizar o conceito de encapsulamento.
Herana
Neste tpico apresentaremos o conceito de herana, fundamental para programao orientada a objetos e um dos fatores de sucesso desta como muito mais que uma simples maneira de organizar melhor seu cdigo. Um dos aspectos que distinguem objetos de procedimentos e funes que o tempo de existncia
de um objeto pode ser maior do que o do objeto que o criou. Isto permite que em sistemas distribudos objetos criados em um local, sejam passados atravs da rede para outro local e armazenados l quem sabe na memria ou mesmo em um banco de dados.
Hierarquia de Tipos
Neste tpico mostraremos como construir hierarquias de tipo por generalizao/especializao. Para entender o que generalizao especializao e as regras de atribuio entre elementos dessas hierarquias, acompanhe a seguinte comparao: Se voc vai a um restaurante e pede o prato de frutos do mar, natural que voc aceite uma lagosta com catupiry, ou ento fil de badejo. Mas se o garom lhe serve uma salada de tomates isto no se encaixa no pedido. Por outro lado, se o seu pedido for peixe, uma lagosta com catupiry, embora muito saborosa no serve mais, assim como a salada. Note que peixe e lagosta so especializaes de frutos do mar. Generalizao e Especializao so ferramentas para lidar com complexidade, elas so abstraes. Os sistemas do mundo real apresentam complexidade muito maior que ordenar um prato listado em um cardpio. O uso de generalizao e especializao permite controlar a quantidade de detalhes presente nos seus modelos do mundo real, permite capturar as caractersticas essenciais dos objetos e tratar os detalhes de forma muito mais organizada e gradual. Existe muito mais para falar sobre herana, principalmente no que diz respeito a polimorfismo de incluso e acoplamento dinmico de mensagens, tpicos estes que sero abordados em separado.
Uma Hierarquia Simples

Construiremos uma hierarquia de tipos simples para demonstrar herana pblica em Java. Vamos antes entender o modelo (trecho de um diagrama de classe) da UML.
Figura 97 - Diagrama de Classes O diagrama acima representa a hierarquia de classes, neste exemplo e foi obtido a partir da janela de edio de uma ferramenta case para programao orientada a objetos. A classe ponto que est no topo da hierarquia chamada de classe base, enquanto que as classes ponto_reflete e ponto_move so chamadas classes filhas ou herdeiras. As classes da hierarquia so simples, ponto_move apresenta o mtodo move, j abordado neste material, ponto_reflete apresenta o mtodo (reflete) que inverte o sinal das coordenadas. Dada a simplicidade das classes o leitor poderia se perguntar, porque no juntar as trs em uma s. A pergunta faz sentido, mas e se quisssemos criar uma classe Ponto que no se movesse, apenas refletisse e outra que s se movesse? E se quisssemos projetar nosso programa segundo uma hierarquia de especializao/generalizao da classe Ponto? O exemplo mostra como faz-lo. Na herana as classes filhas passam a atender mtodos e atributos public e protected da classe pai (base), as classes filhas podem acrescentar mtodos, atributos e at redefinir mtodos herdados (veremos mais tarde). Por isso que se diz que as classes subclasses garantem pelo menos o comportamento behaviour das superclasses, podendo acrescentar mais caractersticas. Os atributos encapsulados (private) da classe pai no so acessveis diretamente na classe filha a no ser que sejam qualificados como protected ou public.
80
Construtores e herana
No construtor de uma classe filha o programador pode incluir a chamada do construtor da classe pai existente nela. Para referenciar a classe pai use a keyword super de modo anlogo a this (objeto corrente).
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52
//Veja no inicio do livro como obter os fontes package br.com.softpalm.heranca; /** * Classe Area capaz de armazenar valores de base e altura * de qualquer coisa que tenha uma medida real no negativa * @author Wellington * @version 1.0 */ public class Area { /** Base da area */ private int base = 0; /** Altura da area */ private int altura = 0; /** * Construtor da area * @param base A area no pode ter uma base negativa * @param altura A area no pode ter uma latura negativa * @throws Exception Erros */ public Area(int base, int altura) throws Exception { if(base < 0 || altura < 0) throw new Exception("Valores negativos."); this.base = base; this.altura = altura; } //Usando a teoria de encapsulamento public int getBase() { return this.base; } public int getAltura() { return this.altura; } public void setBase(int base) throws Exception { if(base < 0) throw new Exception("A base no pode ser negativa."); this.base = base; } public void setAltura(int altura) throws Exception { if(altura < 0) throw new Exception("A altura no pode ser negativa."); this.altura = altura; }
81
53 54 55 56 57 58 59 60 61
/** * Area total da figura * @return retorna a Base x Altura */ public int areaTotal() { return this.base*this.altura; } }
Cdigo 33 - Cdigo da class Area No cdigo acima, implementamos uma classe capaz de abstrair as propriedades de algo que no mundo real chamamos de rea retangular, tudo que for um retngulo pode ser expresso pela classe acima. Todo retngulo no pode ter lados negativos, pois no h reas com valores negativos no mundo real. Abaixo implementamos uma classe que herda as propriedades da superclasse Area. Porem esta nova classe faz chamada ao construtor na superclasse (ver linha 14).
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 entre 18 19 entre 20 21
//Veja no inicio do livro como obter os fontes package br.com.softpalm.heranca; public class AreaCampoFutebol extends Area{ /** * Construtor da classe AreaCampoFutebol * @param base base do campo, ser a linha de fundo * @param altura altura do campo, ser a lateral * @throws Exception Valores invlidos lanam exception */ public AreaCampoFutebol(int base,int altura) throws Exception { super(base,altura); if(base < 75 || base > 90) throw new Exception("A base do campo deve ser um valor 75 e 90"); if(altura < 75 || altura > 90) throw new Exception("A altura do campo deve ser um valor 90 e 120"); } }
Cdigo 34 - Cdigo da classe AreaCampoFutebol
1 2 3 4 5 6 7 8 9 10 11 12
//Veja no inicio do livro como obter os fontes package livro.poo.heranca; /** * Classe utilizada para demonstrar o uso da classe AreaCampoFutebol * @author Wellington * */ public class UsaCampoFutebol { public static void main(String[] args) {
82
13 try 14 { 15 //Segundo o Inmetro as dimenses de um campo so: 16 //Extenso (altura): 17 //valor mximo: 120m 18 //valor mnimo: 90m 19 //Largura (base): 20 //valor mximo: 90m 21 //valor mnimo: 75m 22 23 AreaCampoFutebol area = new AreaCampoFutebol(50,120); 24 System.out.println("A rea total : " + area.areaTotal()); 25 } 26 catch(Exception ex) 27 { 28 System.out.println("Um erro foi encontrado, descrio: " + ex.getMessage()); 29 } 30 } 31 }
Cdigo 35 - Classe utilizada para demonstrao Executando o cdigo da classe UsaCampoFutebol obtemos o resultado expresso na imagem abaixo.
Figura 98 - Exceo se um valor no estiver na especificao
Protected
Quando vimos o tpico encapsulamento, foi mencionado que private era o modo de encapsulamento mais restritivo, seguido de protected, package e depois public (o mais aberto). Naquele tpico mostramos um exemplo para cada tipo de encapsulamento, exceto protected que depende da existncia de uma hierarquia para ser demonstrado. Igual ao exemplo anterior, mas agora tornando os atributos da classe pai acessveis para as classes filhas atravs do uso de protected. Protected deixa os atributos da classe pai visveis, acessveis hierarquia abaixo. Mas para o restante do programa tem o mesmo efeito que private. Outra frase sobre protected: A herana permite que uma subclasse ganhe acesso a declaraes protected de sua superclasse, mas o usurio no percebe isso, para o usurio (uma classe externa) o que continua existindo o que public.
Interfaces
Java por motivos de simplicidade, abandona a idia de herana mltipla, cedendo lugar ao uso de interfaces. Interfaces so um conjunto de mtodos e constantes (no contm atributos). Os mtodos definidos na interface so ocos ou desprovidos de implementao. Classes podem dizer que implementam uma interface, estabelecendo um compromisso, uma espcie de contrato, com seus clientes no que se refere a prover uma implementao para cada mtodo da referida interface.. Ao cliente, pode ser dada a definio da interface, ele acaba no sabendo o que a classe , mas sabe o que faz. Quem programa em Objective C, deve ver as interfaces como algo semelhante ao conceito de protocolos. Neste exemplo usaremos uma interface de nome imprimvel para capturar as caractersticas comuns as classe que podem ser imprimidas em algum dispositivo de sada de dados.
1 //Exemplo de cdigo 2 public interface Imprimivel { //alem das classes, so interfaces pode ocupar um arquivo 3 final char nlin='\n'; //nova linha 4 public String toString(); 5 6 //forma preferida para impressao na tela 7 8 public void toSystemOut(); 9 }
Cdigo 36 - Exemplo de Cdigo Fonte No exemplo acima criamos uma interface chamada Imprimvel, ela ser utilizada mais adiante.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
//Exemplo de cdigo public class Produto implements Imprimivel { //um produto comercial qualquer protected String descricao; protected int quantidade; public Produto(String d,int q) { descricao=d; quantidade=q; } public String toString() { return new String(" "+descricao+" "+quantidade); } //forma preferida para impressao na tela public void toSystemOut() { System.out.print(descricao + quantidade); } }
Cdigo 37 - Exemplo de Cdigo Na classe acima, estamos utilizando a implementao da interface Imprimvel. O paradigma de orientao a objetos est refletido na capacidade de herana e encapsulamento das interfaces. No caso deste exemplo, a interface foi declarada como public, mas se nada fosse especificado ela pertenceria ao package dela, ou seja os modos de encapsulamento so semelhantes aos de classes. Uma interface poderia estender a interface Imprimivel:
interface Imprimivel2 extends Imprimivel { }

Interfaces tem sido representadas por retngulos de bordas arredondadas ligadas as classes que as implementam por linhas tracejadas.
84
Muitos confundem interfaces com classes e o ato de implementar uma interface com o ato de estender ou herdar uma classe. Por isso a relao entre interfaces e herana ser explicada s agora, depois que voc j pensou no assunto. Uma classe Produto2 herda da classe Produto(nosso exemplo) que implementa a interface Imprimivel. A classe produto j fez a parte difcil que implementar a interface, agora a classe Produto2 pode optar por aceitar ou redefinir os mtodos herdados, ou seja: A interface um dos itens que herdado de uma classe, assim como os atributos e mtodos.
Polimorfismo e Classes Abstratas

Existem vrias classificaes e tipos de polimorfismo. C++ apresenta vrios tipos de polimorfismo . Java apresenta um conjunto mais reduzido evitando principalmente polimorfismos ad-hoc. Polimorfismo, do grego: muitas formas. Polimorfismo a capacidade de um operador executar a ao apropriada dependendo do tipo do operando. Aqui operando e operador esto definidos num sentido mais geral: operando pode significar argumentos atuais de um procedimento e operador o procedimento, operando pode significar um objeto e operador um mtodo, operando pode significar um tipo e operador um objeto deste tipo.
Redefinio de Mtodos para uma Classe Herdeira

Este exemplo j foi apresentado em Error! Reference source not found.. Tambm trata-se de um polimorfismo, pode ser classificado como polimorfismo de incluso. Um mtodo uma redefinio de um mtodo herdado, quando est definido em uma classe construda atravs de herana e possui o mesmo nome, valor de retorno e argumentos de um mtodo herdado da classe pai. A assinatura do mtodo tem que ser idntica, ou seja, teremos redefinio quando uma classe filha fornece apenas uma nova implementao para o mtodo herdado e no um novo mtodo. Se a classe filha fornecer um mtodo de cabealho ou assinatura parecida com a do mtodo herdado (difere ou no nmero ou no tipo dos argumentos, ou ento no tipo do valor de retorno) ento no se trata mais de redefinio, trata-se de uma sobrecarga, pois criou-se um novo mtodo. Uma chamada ao mtodo herdado no mais interceptada por esse novo mtodo de mesmo nome. O mtodo tem o mesmo nome, mas ligeiramente diferente na sua assinatura (o corpo ou bloco de cdigo {} no importa), o que j implica que no proporciona o mesmo comportamento (behaviour) do mtodo da superclasse.
85
7
7 Interface com o Usurio
Entender o comportamento de uma aplicao em Android; Conhecer a ideia por traz do conceito Activity; Conhecer os elementos bsicos de interface; Abstrair dicas de usabilidade.
Introduo
Uma aplicao no reside isolada em um equipamento, geralmente a aplicao interage com outras aplicaes em busca de atingir alguns resultados (funcionalidades). No prprio sistema operacional temos aplicaes que podem interagir com sua aplicao e vice-versa, desta forma sua aplicao deve ter a capacidade de receber eventos do sistema como por exemplo de uma ligao telefnica ou de um controlador GPS. Imagine que o usurio esteja no meio de um jogo, e recebe uma ligao. A aplicao que neste caso um jogo no pode sair de cena, e como fica o status do jogo, vai continuar executando enquanto o usurio est no telefone? E quando voltar? Para satisfazer isso a aplicao deve ter um ciclo de vida que recebe eventos do Sistema Operacional, essa ideia no explorada no mundo dos Desktops.
View
Na plataforma Android a interface com o usurio est baseada no uso de View e ViewGroup. Existem muitos tipos de Views, o importante que se deve saber neste momento que todas herdam de View. A classe View serve de base para subclasses chamadas widgets que oferecem uma forma de implementar interfaces, tais como caixas de texto e botes. A classe ViewGroup serve de base para subclasses chamadas layouts que oferece a base das interfaces. Um objeto View uma estrutura de dados, cujas propriedades armazenam dados do layout e determinada rea de interface. A View tambm capaz de gerenciar suas propriedades como proporo, posio, foco, aparncia (baseado no status), scrolling.
Activity
Um Activity um componente do aplicativo que fornece uma tela no qual o usurio podem interagir, a fim de realizar alguma tarefa como discar o telefone, tomar um foto, envie um e-mail, ou ver um mapa. Cada Activity controla uma janela na qual se pode desenhar sua interface com o usurio. A
86
janela normalmente preenche a tela, mas pode ser menor do que a tela e flutuar em cima de outras janelas. Um aplicativo normalmente consiste de mltiplas Activities que so fracamente ligadas umas as outras. Normalmente, uma Activity em um aplicativo especificada como a Activity Main, que apresentada ao usurio ao iniciar o aplicativo pela primeira vez, no exemplo acima essa Activity Main ser chamada de Gerenciador. Cada Activity pode comear outra Activity, a fim de executar vrias aes diferentes. Cada vez que uma comea a Activity anterior interrompida, mas o sistema preserva a Activity em uma pilha (pilha de retorno).
Ciclo de vida de uma Activity

Vimos que as Activities so gerenciados como uma pilha, quando uma nova Activity iniciada ela assume o topo da pilha e se torna a Activity em execuo. A Activity anterior (que estava em execuo antes desta nova Activity) permanece abaixo e s retornar a ser a Activity em execuo se a mais recente for finalizada. Uma Activity pode assumir um estado, essencialmente temos quatro estados possveis: Se uma Activity estiver em primeiro plano (no topo da pilha), ele est ativo e em execuo. Se a Activity perdeu o foco, mas ainda visvel (ou seja, uma nova Activity no preencheu toda a tela ou possui transparncia), ento a Activity inferior est no estado de pausa. Uma Activity em pausa ainda est presente na memria e consequentemente na pilha (pois mantm todas as informaes do estado e dos membros, e sem contar que ainda persiste no gerenciador de janelas), mas podem ser mortos pelo sistema em situaes extremas de baixa memria; Se uma Activity totalmente obscurecida por outra Activity, ento ela est parada (stop). Ela ainda mantm todas as informaes de estados e membros, no entanto, j no visvel para o usurio e assim que a janela est oculta e que esta pode ser eliminada pelo sistema no caso de falta de memria. Se uma Acivity est em pausa ou parada, o sistema pode reivindicar a memria utilizada por ela, para isso pode finalizar a thread responsvel por tal Activity. Quando ele exibido novamente para o usurio, deve ser completamente reiniciado e restaurado ao seu estado anterior. O diagrama a seguir mostra os caminhos importantes entre aes que pode alterar os estados de uma Activity. Os retngulos quadrados representam mtodos (eventos) que voc pode utilizar para implementar operaes ou aes especiais em momentos especficos de troca de estado. As elipses coloridas so os estados mais importantes que uma Activity pode assumir.
87
H trs sequencia de aes que devemos monitorar: vida de uma Activity, tempo visvel de uma Activity e Activity no topo da pilha. Vida de uma Activity A vida de uma Activity acontece entre a primeira chamada para onCreate (Bundle) at a chamada do finally() que resulta no evento onDestroy(). Uma Activity ir fazer toda a configurao do estado de suas propriedades no OnCreate() e liberar todos os recursos remanescentes em onDestroy().
Figura 99 - Ciclo de vida de uma Activity Temo de visibilidade de uma Activity O tempo de vida visvel de uma Activity acontece entre uma chamada para onStart() at uma chamada correspondente para onStop(). Durante este perodo o usurio pode ver a Activity na tela, embora no possa estar em primeiro plano e interagir com o usurio. Entre estes dois mtodos que voc pode manter os recursos que so necessrios para mostrar a atividade para o usurio.
88
Figura 100 - Visibilidade de uma Activity Activity no topo da pilha O tempo de vida do primeiro plano (topo da pilha) de uma Activity acontece entre uma chamada para onResume() at uma chamada correspondente para onPause(). Durante esse tempo, a Activity est na frente de todas as outras atividades e pode interagir com o usurio.
Figura 101 - Activity no topo da pilha O ciclo de vida de uma Activity definida pelos eventos, todos estes eventos invocam mtodos na Activity e nestes mtodos que implementamos nossos cdigos para executar as funcionalidades requeridas. Logo abaixo temos uma classe Activity, repare que temos as implementaes dos mtodos expostos nas figuras acima.
1 public class Activity extends ApplicationContext { 2 3 protected void onCreate(Bundle savedInstanceState); 4 5 protected void onStart(); 6 7 protected void onRestart(); 8 9 protected void onResume(); 10 11 protected void onPause(); 12 13 protected void onStop(); 14 15 protected void onDestroy(); 16 }
onCreate(): Chamado quando a Activity criada pela primeira vez. Isto onde voc pode: criar pontos de vista, vincular dados em listas, carregar dados, etc.. Esse mtodo tambm fornece a voc um pacote contendo o estado previamente congelado da atividade, se houvesse um; onRestart(): Chamado aps uma Activity ser parada (stop), ela prepara a Activity para retomada do topo da pilha; onStart(): Chamado quando a Activity est se tornando visvel para o usurio; onResume(): Chamado quando a Activity vai comear a interagir com o usurio. Neste ponto, sua atividade est no topo da pilha de atividade. onPause(): Chamado quando o sistema est prestes a comear a retomar uma Activity anterior. Isso normalmente usado para salvar alteraes no salvas da Activity corrente. Implementaes deste mtodo deve ser muito rpida porque a prxima Activity no ser iniciada at que esse mtodo retorne. onStop(): Chamado quando a Activity j no visvel para o usurio, porque outra Activity est cobrindo toda a tela. Isso pode acontecer ou porque uma nova Activity que est sendo iniciada ou uma j existente est sendo trazida frente da pilha. onDestroy(): A ltima chamada recebida pela Activity antes de ser destruda, isso porque a Activity foi finalizada pelo mtodo finally() ou o espao da memria est sendo requerido pelo sistema. Voc
89
pode distinguir entre estas duas opes atravs do mtodo isFinishing(). Ateno: No prximo exemplo (aps estudar sobre o padro de interface) vamos demonstrar com detalhes o ciclo de vida de uma Activity.
Editor de Layout
Um ponto interessante na tecnologia adotada pelo Android a forma que desenvolvido a interface, se voc um programador Java que est acostumado a criar interfaces pelo cdigo ver que nesta plataforma as interfaces por padro so feitas em arquivos .xml. Ateno: Eu disse por padro, porque possvel desenvolver interfaces toda via cdigo porem pelos exemplos e pela documentao oficial isso no comum. Vamos criar um exemplo chamado Exemplo003 no qual vamos criar dois formulrios simples e navegar de um para o outro. Tambm vamos aproveitar para demonstrar a sequncia de mtodos do ciclo de vida de uma Activity.
Figura 102 - Boto que cria um projeto Crie o projeto com as seguintes propriedades: New Android Project Project name Build Target Application Name Package name Create Activity (selecionado) Min SDK Version Exemplo003 Android 2.2 Exemplo003 br.com.softpalm.layout Main 8
Quando o projeto criado alguns arquivos so gerados, ente eles encontramos um arquivo .xml chamado main.xml e um Main.java (ver figura abaixo).
Figura 103 - Arquivo XML e Activity Estes dois arquivos representam (na mesma sequncia) o arquivo de interface e a Activity controladora. Nada liga um ao outro, logo esta Activity Main.java pode carregar quantos arquivos .xml
o programador quiser, alguns programas exemplos na Internet (no prprio repositrio do Android) aponta para o uso de vrios XML de laytou para uma Activity somente. Neste livro vou abordar uma ttica diferente, mesmo no havendo o elo entre a Activity e o arquivo de layout XML vou manter: para cada arquivo de layout XML vou criar uma Activity. Pense: Imagine 15 janelas (arquivos XML) utilizando a mesma Activity, os componentes de interface possuem mtodos, pense em todos os mtodos no mesmo cdigo. Vamos aprender Como criar uma Activity e um arquivo de layout XML. Primeiro crie uma classe dentro do pacote, no nosso caso pacote br.com.softpalm.layout.
Fique atento ao nome, sempre com primeira letra maiscula pois uma classe, veja na imagem abaixo que estou informando uma superclasse. Isso porque nossa classe dever herdar de android.app.Activity.
Figura 104 - Criando a classe Activity O cdigo gerado fica (procurar em Project Explorer a classe Tela) :
1 2 3 4 5 6 7
package br.com.softpalm.layout; import android.app.Activity; public class Tela extends Activity { }

Vamos agora registrar no Manifest a nossa Activity. Clique no arquivo AndroidManifest.xml (ver figura abaixo) escolha a aba Application e veja a lista de Activities da sua aplicao.
91
Figura 105 - Editor AndroidManifest Para adicionar ento o registro da Activity clique em Add... (ver figura acima) para adicionar uma nova Activity.
Figura 106 - Registrando uma Activity Agora temos que selecionar a classe (cdigo Java) associado a esse registro, selecione Activity (clicando em Browser).
Figura 107 - Configurao da Activity Encontre a classe Tela (nossa Activity) e clique em OK.
Figura 108 - Localizando a classe Activity Lembre-se de escrever um texto em Label (Figura 107). Agora vamos criar o arquivo de layout XML,
conforme dito para cada layout vamos utilizar um arquivo de layout XML e uma Activity.
Figura 109 - Boto que adicona um XML Quando instalamos o pluguin do Android trs botes foram adicionados na nossa barra (ver figura acima), clique em Adicionar XML.
Figura 110 - Adicionando um arquivo XML D um nome ao seu resource, repare que estou utilizando o nome minsculo para acompanhar o padro dos exemplos Android. Clique em Finish. O arquivo gerado pode ser encontrado em Exemplo003 | res | layout conforme figura abaixo. D um duplo clique no arquivo main.xml, vamos comear a adicionar objetos a interface.
93
Figura 111 - Editor de Layout Foi aberto o Editor de Layout (ver figura acima), repare que podemos ver a tela e tambm simular alterando os parmetros. Isso bom para poder testar vrios ambientes com vrias configuraes sem ter que fazer o Deploy (captulos anteriores) para ver. Arraste um Button da Palette para a tela, conforme figura abaixo. Mantenha o Button selecionado e veja as propriedades na aba Properties (ver figura abaixo). Procure a propriedade Id e altere para: @+main/btnNavegar conforme figura abaixo. Aproveite e tambm altere o Text para Navegar. Ateno: Se no encontrar a aba Properties (ver figura abaixo) recorra ao Apndice 3 como o Apndice 3 genrico saiba que a aba que procura est em Geral | Properties.
Figura 112 - Editor de Layout
94
Voc deve estar se perguntando, porqu dar um Id to complexo, nas demais linguagens Ids eram palavras simples. Vamos mais a fundo para entender. Repare que comecei o Id com main, veja no arquivo R.java temos vrias constantes que so geradas automaticamente pela ferramenta. Veja (ver figura abaixo) que temos public static final class main e dentro desta classe temos a constante btnNavegar. S de olhar para este arquivo podemos entender o resto do Id.
Figura 113 - Cdigo da classe R Lembre-se: Esse arquivo no pode ser alterado pelo programador manualmente. Ento nosso layout main ficar assim:
Figura 114 - Layout do primeiro formulrio Proximo passo e adicionar um evento para o boto, neste evento ns vamos navegar para a prxima Activity. Acesse o arquivo Main.java e edite o cdigo abaixo.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
package br.com.softpalm.layout; import import import import import android.app.Activity; android.content.Intent; android.os.Bundle; android.view.View; android.widget.Button;
public class Main extends Activity { /** Called when the activity is first created. */ @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); // Carrega o arquivo de layout XML chamado main.xml setContentView(R.layout.main); // Criando o evento para o boto
95
19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69
// primeiro vamos pegar o boto Button bt = (Button) this.findViewById(R.main.btnNavegar); // agora vamos adicionar o evento bt.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { btnNavegar_Click(v); } }); } // Criei este mtodo s para tratar o evento public void btnNavegar_Click(View v) { // Arqui eu inicio a Activity Tela this.startActivity(new Intent(this, Tela.class)); } // O cdigo abaixo implementa os eventos // do ciclo de vida da Activity s para testes protected void onStart() { super.onStart(); System.out.println("Start"); } protected void onRestart() { super.onRestart(); System.out.println("Restart"); } protected void onResume() { super.onResume(); System.out.println("Resume"); } protected void onPause() { System.out.println("Pause"); super.onPause(); } protected void onStop() { System.out.println("Stop"); super.onStop(); } protected void onDestroy() { System.out.println("Destroy"); super.onDestroy(); } }
Cdigo 38 - Cdigo da classe Main.java J podemos executar a aplicao, execute a aplicao no emulador e mude para a perspectiva Debug. Veja que sua aplicao ser carregada e no output dever aparecer Start e Resume (ver figura abaixo).
96
Figura 115 - Output Isso porque (j abordado no ciclo de vida) primeiro ser executado onCreate() seguido de onStart() e onResult(). Agora no emulador clique no boto Navegar para chamar a outra Activity. Conforme teoria abordada no ciclo de vida quando a nova Activity assume o topo da pilha a Activity (em execuo) invoca na sequencia os eventos onPause() e onStop().
Figura 116 - Output Vamos agora fazer o boto voltar na segunda tela, para isso abra o arquivo tela.xml em layout e adicione um boto. Para esse boto altere o Id para Id @+tela/btnVoltar e o texto para Voltar.
Figura 117 - Layout do segundo formulrio Agora vamos adicionar o evento para o boto, abra o arquivo Tela.java em src. Edite o cdigo abaixo.
1 2 3 4 5 6 7 8 9 10 11 12 13 14
package br.com.softpalm.layout; import import import import android.app.Activity; android.os.Bundle; android.view.View; android.widget.Button;
public class Tela extends Activity { public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); // Carrega o arquivo de layout XML chamado tela.xml setContentView(R.layout.tela);
97
15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33
// Criando o evento para o boto // primeiro vamos pegar o boto Button bt = (Button) this.findViewById(R.tela.btnVoltar); // agora vamos adicionar o evento bt.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { btnNavegar_Click(v); } }); } public void btnNavegar_Click(View v) { this.finish(); } }
Cdigo 39 - Cdigo da classe Tela.java (Reviso svn 9) Repare que basta finalizar a Activity que ela sai do topo da pilha e volta a dar foco ao formulrio anterior. Quando o formulrio anterior volta a ser o primeiro da pilha, novamente ele roda na sequncia onRestart(), onStart() e onResume(). Faa assim, fique clicando em Navegar e Voltar sempre analisando o output.
android.widget
O pacote android.widget reune elementos grficos para serem utilizados para interao humano aplicao, neste captulo vamos abordar os principais componentes grficos e ao final abordar a construo dos nossos prprios Widgets.
TextView
TextView utilizado para exibir um texto e permitir a sua edio. Porem por padro sua configurao no permite a edio, substitui o Label utilizado nas outras tecnologias. Ateno: Para permitir a edio de textos utilize o componente EditText.
Figura 118 - TextView na Palette
EditText
O controle EditText herda de TextView (visto acima), sua configurao permite a edio de texto por padro, similar ao TextBox (Framework .NET) ou do JTextFied (Java).
Figura 119 - EditText na Palette
98
Button
Controle utilizado para disponibilizar aes ao usurio e pode assumir o comportamento clicvel (click-button) ou pressionado com estado (push-button). Por padro o comportamnto click-button.
Figura 120 - Button na Palette Vamos agora criar um projeto para demonstrar o uso do TextView, EditText e Button. Neste novo projeto vamos exigir um texto e ao clicar no boto o texto ser transformado e um texto todo maisculo. Ento os dados do novo projeto so: New Android Project Project name Build Target Application Name Package name Create Activity (selecionado) Min SDK Version Exemplo004 Android 2.2 Exemplo004 br.com.softpalm.layout.text Main 8
Arraste da Palette um objeto TextView, EditText e um Button conforme figura abaixo. Altere o Id do TextView para @+main/txvLabel e Text para Digite um texto:. Do componente EditText altere o Id para @+main/edtText. Do Button o Id para @+main/btnExecutar e Text Executar.
Figura 121 - Layout do formulrio main.xml Se preferir pode ir por XML conforme cdigo abaixo.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
<?xml version="1.0" encoding="utf-8"?> <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:orientation="vertical" android:layout_width="fill_parent" android:layout_height="fill_parent"> <TextView android:id="@+main/txvLabel" android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="Digite um texto: "> </TextView> <EditText android:layout_height="wrap_content" android:id="@+main/edtText" android:layout_width="match_parent"> </EditText> <Button
99
18 android:text="Executar" 19 android:id="@+main/btnExecutar" 20 android:layout_width="wrap_content" 21 android:layout_height="wrap_content"> 22 </Button> 23 </LinearLayout>

Ateno: Se no sabe como ver o formulrio na view XML basta selecionar a aba main.xml.
Prximo passo editar o cdigo fonte que vai executar a ao. O cdigo da classe Main.java :
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35
package br.com.softpalm.layout.Text; import android.app.Activity; import android.os.Bundle; import android.view.View; import android.widget.Button; import android.widget.EditText; // Reviso SVN 10 public class Main extends Activity { /** Called when the activity is first created. */ @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); // relacionando XML com cdigo edtText = (EditText)this.findViewById(R.main.edtText); btnExecutar = (Button) this.findViewById(R.main.btnExecutar); // Criando o evento btnExecutar.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { btnExecutar_Click(v); } }); } /** * Executa a ao Click do boto * @param v a View que est sendo invocada */ public void btnExecutar_Click(View v) {
100
36 37 38 39 40 41 42 43
String texto = edtText.getText().toString(); edtText.setText(texto.toUpperCase()); } // Elementos da interface private Button btnExecutar ; private EditText edtText ; } Alguns pontos importantes que podemos citar que o getText() da linha 36 no retorna um texto em String, retorna na verdade uma classe Editable, por isso precisamos do toString().
Outro ponto que podemos citar o comentrio Javadoc feito na linha 30, veja mais sobre Javadoc na Internet. Execute a aplicao, escreva algum texto e pressione o boto, veja que o texto vai ser alterado. Usabilidade: Est claro que quando queremos exibir um texto onde o usurio no pode editar utilizamos TextView e quando precisamos de uma caixa para edio de um texto usamos EditText.
ToggleButton
ToggleButton um boto que exibe um estado "ON" ou "OFF" no qual o usurio pode pressionar e alterar o estado caso queira.
Figura 122 - ToggleButton na Palette Usabilidade: Utilize o ToggleButton para solicitar um Sim ou No e quando uma resposta obrigatria. Deixe a opo padro marcada de acordo com sua necessidade. Para deixar claro o uso do ToggleButton vamos criar um projeto simples, conforme tabela abaixo: New Android Project Project name Build Target Application Name Package name Create Activity (selecionado) Min SDK Version Exemplo005 Android 2.2 Exemplo005 br.com.softpalm.layout.button Main 8
O usurio vai ter um ToggleButton na tela, e a medida que ele pressiona ou libera vamos escrever no output a ao executada. Arraste da Palette um objeto ToggleButton conforme figura abaixo.
Figura 123 - Layout do exemplo Se preferir (assim como eu) utilize o Editor XML para editar o arquivo main.xml.
<?xml version="1.0" encoding="utf-8"?>

101
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:orientation="vertical" android:layout_width="fill_parent" android:layout_height="fill_parent" android:background="#ffffff" > <ToggleButton android:text="ToggleButton" android:layout_width="wrap_content" android:layout_height="wrap_content" android:id="@+main/tgbOnOff" android:textOff="Estado Off" android:textOn="Estado On"> </ToggleButton> </LinearLayout> Repare que temos na linha 13 e 14 o texto que ser exibido caso esteja pressionado ou liberado. Por padro pressionado ON e liberado OFF.
Agora vamos editar o cdigo executvel do arquivo Main.java em src.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35
package br.com.softpalm.button; import import import import android.app.Activity; android.os.Bundle; android.view.View; android.widget.ToggleButton;
public class Main extends Activity { /** Called when the activity is first created. */ @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); tgbOnOff = (ToggleButton)this.findViewById(R.main.tgbOnOff); // Utilizando o evento Click tgbOnOff.setOnClickListener(new View.OnClickListener() { public void onClick(View v) { tgbOnOff_Click(v); } }); } public void tgbOnOff_Click(View v) { if (tgbOnOff.isChecked()) System.out.println("Pressionado"); else System.out.println("Liberado"); } ToggleButton tgbOnOff; }
Na linha 28 estamos usando o mtodo isChecked() para verificar se o componente de interface est pressionado ou liberado. No output (Perspective Debug) podemos ver o resultado de nossas aes.
102
Figura 124 - Output do Emulador
RadioButton e RadioGroup
Um RadioButton um boto de dois estados que pode ser marcado ou desmarcado. Quando o RadioButton est desmarcado, o usurio pode pressionar e marcar. Um comportamento interessante que depois de marcado o RadioButton no pode ser desmarcado pelo usurio pela interface (diretamente). O que ocorre que um RadioButton nunca est sozinho, no faz sentido usar um RadioButton isolado. Utiliza-se grupos de RadioButtons que esto associados em um RadioGroup, quando o usurio marca um RadioButton o RadioGroup automaticamente desmarca os demais. Utiliza-se o RadioGroup para gerenciar um conjunto de RadioButton no qual exigimos uma escolha do usurio dentre o grupo, ou seja, exigir uma escolha somente.
Figura 125 - RadioGroup e RadioButton na Palette Vamos criar um projeto para demonstrar o uso do RadioGroup, crie um projeto Android conforme tabela abaixo: New Android Project Project name Build Target Application Name Package name Create Activity (selecionado) Min SDK Version Exemplo006 Android 2.2 Exemplo006 br.com.softpalm.layout.radio Main 8
O usurio vai ter um RadioGroup na tela, e a medida que ele marca as opes vamos escrever na prpria tela usando uma janelinha Toast (vamos estudar mais a frente). O layout do formulrio simples, basta acompanhar o XML abaixo, repare que apenas altreis os Ids.
1 2 3 4 5 6 7 8 9
<?xml version="1.0" encoding="utf-8"?> <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:orientation="vertical" android:layout_width="fill_parent" android:layout_height="fill_parent" > <RadioGroup android:id="@+main/rdgGrupo" android:layout_width="wrap_content" android:layout_height="wrap_content">
103
10 <RadioButton 11 android:layout_width="wrap_content" 12 android:text="RadioButton" 13 android:layout_height="wrap_content" 14 android:id="@+main/rdgGrupoOp01" 15 android:checked="true"> 16 </RadioButton> 17 <RadioButton 18 android:layout_width="wrap_content" 19 android:text="RadioButton" 20 android:layout_height="wrap_content" 21 android:id="@+main/rdgGrupoOp02"> 22 </RadioButton> 23 <RadioButton android:layout_width="wrap_content" 24 android:text="RadioButton" 25 android:layout_height="wrap_content" 26 android:id="@+main/rdgGrupoOp03"> 27 </RadioButton> 28 </RadioGroup> 29 </LinearLayout> Veja que as Tags RadioButton esto todas internas a Tag RadioGroup. Outro ponto interessante a linha 15 na qual estamos marcando a opo 1 como marcado.
Agora vamos digitar o cdigo que faz o mecanismo funcionar, abra o arquivo Main.java em src e codifique o cdigo abaixo.
1 package br.com.softpalm.layout.radio; 2 3 import android.app.Activity; 4 import android.os.Bundle; 5 import android.view.View; 6 import android.widget.RadioButton; 7 import android.widget.Toast; 8 9 /** 10 * 11 * @author Wellington 12 * Reviso SVN 11 13 */ 14 public class Main extends Activity { 15 /** Called when the activity is first created. */ 16 @Override 17 public void onCreate(Bundle savedInstanceState) { 18 super.onCreate(savedInstanceState); 19 setContentView(R.layout.main); 20 21 // Como sempre, pegando os objetos da interface e 22 // armazenando em atributos da classe 23 this.rdgGrupoOp01 = (RadioButton)this.findViewById(R.main.rdgGrupoOp01); 24 this.rdgGrupoOp02 = (RadioButton)this.findViewById(R.main.rdgGrupoOp02); 25 this.rdgGrupoOp03 = (RadioButton)this.findViewById(R.main.rdgGrupoOp03); 26 27 // Criando os eventos, s que em vez de criar um evento 28 // para cada componente conforme os demais exemplos 29 // vou criar um nico tratador de evento (ver o cdigo 30 // mais abaixo)
31 this.rdgGrupoOp01.setOnClickListener(this.rdgGrupo_Click); 32 this.rdgGrupoOp02.setOnClickListener(this.rdgGrupo_Click); 33 this.rdgGrupoOp03.setOnClickListener(this.rdgGrupo_Click); 34 35 // Marcar como a Opo 1 como padro 36 this.rdgGrupoOp01.setChecked(true); 37 } 38 39 /** 40 * Tratador do evento Click para todos as opes Radio 41 */ 42 private RadioButton.OnClickListener rdgGrupo_Click = new RadioButton.OnClickListener() { 43 public void onClick(View v) { 44 String str = "Opo 1 : " + rdgGrupoOp01.isChecked() + "\n"; 45 str += "Opo 2 : " + rdgGrupoOp02.isChecked() + "\n"; 46 str += "Opo 3 : " + rdgGrupoOp03.isChecked(); 47 48 // O Toast ser estudado mais a frente, apenas use ele 49 // para exibir uma pequena janela com um texto 50 Toast.makeText(Main.this, str, Toast.LENGTH_SHORT).show(); 51 } 52 }; 53 54 // Atributos da classe 55 private RadioButton rdgGrupoOp01, rdgGrupoOp02, rdgGrupoOp03; 56 } Note que por estar usando o mesmo evento em trs componentes decidi criar o evento fora e relacionar o mesmo evento. Nas linhas 44, 45 e 46 podemos ver como fcil saber se um radio est ou no marcado.
Voc deve ter ficado impressionado com o elemento Toast em execuo, repare que ao clicar nas opes ele aparece e desaparece, mais a frente vamos detalhar o Toast. Usabilidade: Usamos o RadioGroup para exigir do usurio uma opo somente e obrigatriamente.
CheckBox
Ao contrrio do RadioButton o CheckBox pode estar sozinho, posso ter mais de um CheckBox marcado ao mesmo tempo, posso at no ter nenhum marcado. Por isso no requer controlador de grupo.
Figura 126 - CheckBox na Palette Vamos agora criar um projeto para demonstrar o uso do CheckBox, crie um projeto de acordo com os dados abaixo. New Android Project Project name Build Target Exemplo007 Android 2.2
105
Application Name Package name Create Activity (selecionado) Min SDK Version
Exemplo007 br.com.softpalm.layout.check Main 8
Neste programa o usurio vai marcar CheckBox dizendo se tem gatos e cachorros. Sempre comeamos com a edio do arquivo XML de layout, no nosso caso s vamos ter main.xml no projeto. Adicione dois CheckBox conforme figura abaixo.
Figura 127 - Layout do formulrio main.xml Para isso vamos usar o XML abaixo no arquivo main.xml.
1 <?xml version="1.0" encoding="utf-8"?> 2 <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" 3 android:orientation="vertical" 4 android:layout_width="fill_parent" 5 android:layout_height="fill_parent" 6 > 7 <CheckBox 8 android:id="@+main/ckbCachorro" 9 android:layout_width="wrap_content" 10 android:layout_height="wrap_content" 11 android:text="Possui Cachorro?"> 12 </CheckBox> 13 <CheckBox 14 android:id="@+main/ckbGato" 15 android:layout_width="wrap_content" 16 android:layout_height="wrap_content" 17 android:text="Possui Gato?"> 18 </CheckBox> 19 </LinearLayout> Simples, nada de novo. Se quiser que um CheckBox esteja marcado utilize a propriedade android:checked conforme exemplo do RadioButton. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 package br.com.softpalm.layout.check; import import import import import android.app.Activity; android.os.Bundle; android.view.View; android.widget.CheckBox; android.widget.Toast;
/** * Reviso SVN 12 * @author Wellington * */ public class Main extends Activity { /** Called when the activity is first created. */ @Override
106
// Como sempre, pegando os objetos da interface e // armazenando em atributos da classe this.ckbCachorro = (CheckBox)this.findViewById(R.main.ckbCachorro); 24 this.ckbGato = (CheckBox)this.findViewById(R.main.ckbGato); 25 26 // Criando os eventos, s que em vez de criar um evento 27 // para cada componente conforme os demais exemplos 28 // vou criar um nico tratador de evento (ver o cdigo 29 // mais abaixo) 30 this.ckbCachorro.setOnClickListener(this.rdgGrupo_Click); 31 this.ckbGato.setOnClickListener(this.rdgGrupo_Click); 32 } 33 34 /** 35 * Tratador do evento Click para todos os CheckBox 36 */ 37 private CheckBox.OnClickListener rdgGrupo_Click = new CheckBox.OnClickListener() { 38 public void onClick(View v) { 39 String str = "Possui cachorros : " + ckbCachorro.isChecked() + "\n"; 40 str += "Possui gatos : " + ckbGato.isChecked(); 41 42 // O Toast ser estudado mais a frente, apenas use ele 43 // para exibir uma pequena janela com um texto 44 Toast.makeText(Main.this, str, Toast.LENGTH_SHORT).show(); 45 } 46 }; 47 48 // Atributos da classe 49 private CheckBox ckbCachorro, ckbGato; 50 }
17 18 19 20 21 22 23
public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main);
AutoCompleteTextView
Assim como a EditText o AutoCompleteTextView permite que o usurio digite uma determinada informao, porem o AutoCompleteTextView exibe opes de palavras a medida que o usurio digita a palavra desejada a aplicao sujere opes. Usabilidade: Em dispositivos mveis a Interao Humano Computador uma das prioridades visto que a entrada de dados por parte do usurio demorado. Imagine que o usurio escreveu "Cad", o programa automaticamente pode sugerir algumas palavras, tais como Cadeira, Cad, Cadncia, etc.. O programador pode gerar uma lista de possveis palavras para facilitar a usabilidade. Usabilidade: Para caixa de texto com palavras simples o AutoCompleteTextView o componente indicado. Quando voc disponibiliza opes facilita o entendimento de aplicaes de retaguarda, imagine um sistema de inventariado patrimonial, cadeira pode ser escrito de diferentes formas, exemplos: Ca deira, cadera, |cadeira, etc.. Isso porque o usurio final utiliza um equipamento de baixa qualidade de usabilidade, muito restrito. Se ele escrever Cad e j aparecer na listagem Cadeira ele vai selecionar, vai ser mais rpido e vai padrozinar os dados que sero tratados pela retaguarda.
107
MultiAutoCompleteTextView
O MultiAutoCompleteTextView extende de AutoCompleteTextView, logo o MultiAutoCompleteTextView disponibiliza ao usurio uma srie de opes, porem neste componente temos a opo de utilizar um MultiAutoCompleteTextView.Tokenizer para selecionar as opes sugeridas. Para fixar o MultiAutoCompleteTextView e AutoCompleteTextView vamos criar um projeto exemplo, neste projeto o usurio dever digitar algumas palavras e o device dever ajudar exibindo uma lista de possveis palavras. Crie um projeto baseado nas configuraes da tabela abaixo. New Android Project Project name Build Target Application Name Package name Create Activity (selecionado) Min SDK Version Exemplo008 Android 2.2 Exemplo008 br.com.softpalm.layout.auto Main 8
Adicione um controle AutoCompleteTextView e um MultiAutoCompleteTextView, altere o arquivo main (XML) conforme a listagem abaixo.
1 <?xml version="1.0" encoding="utf-8"?> 2 <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" 3 android:orientation="vertical" 4 android:layout_width="fill_parent" 5 android:layout_height="fill_parent" 6 android:background="#ffffff"> 7 <AutoCompleteTextView 8 android:layout_height="wrap_content" 9 android:id="@+main/txtAuto" 10 android:layout_width="match_parent" 11 > 12 </AutoCompleteTextView> 13 <MultiAutoCompleteTextView 14 android:completionThreshold="1" 15 android:layout_height="wrap_content" 16 android:id="@+main/txtMulti" 17 android:layout_width="match_parent"> 18 </MultiAutoCompleteTextView> 19 </LinearLayout>
Nesta aplicao vamos demonstrar como o AutoCompleteTextView e o MultiAutoCompleteTextView auxiliam o usurio na entrada de dados, outro ponto importante que pretendemos destacar a padronizao da entrada. Se voc pedir para usurios de aplicaes mveis digitar a palavra Cadeira pode ser que voc tenha surpresas, experincias anteriores em projetos de inventariado demonstraram que existem vrias formas de se escrever cadeira, veja, neste texto foi digitado Cadeira e cadeira, mas no ficaria surpreso com caddeira, cadira, c adeira, (acredite existem mais de 100 formas diferentes). O impacto deste problema maior na retaguarda, que tem a funo de tratar os dados para uma possvel aplicao de negcio, algumas tcnicas de Inteligncia Artificial podem corrigir isso porem prefiro atuar na linha de frente (na aplicao mvel) exigindo um texto mais formatado. Porem obrigar usurio a digitar direito como obrigar um Elefante a criar asas e voar, ento o recurso de autocompletar um trunfo que o programador pode utilizar (um porque existem outras formas). Vou comear montando um atributo na classe Main.java do tipo array de String (linha 30), neste array vamos adicionar as possveis opes que eu acredito que o usurio encontre quando estiver em campo. Porm nada impede do sistema aprender e criar esta lista baseado nas experincias do
108
usurio (em 2012 lano um livro de Inteligncia Artificial para plataforma mvel).
1 package br.com.softpalm.auto; 2 3 import android.app.Activity; 4 import android.os.Bundle; 5 import android.widget.ArrayAdapter; 6 import android.widget.AutoCompleteTextView; 7 import android.widget.MultiAutoCompleteTextView; 8 // Reviso SVN 13 9 public class Main extends Activity { 10 11 public void onCreate(Bundle savedInstanceState) { 12 super.onCreate(savedInstanceState); 13 setContentView(R.layout.main); 14 15 // Criando um Adapter para associar a um array de opes mais provveis 16 ArrayAdapter<String> adapter = new ArrayAdapter<String>(this, android.R.layout.simple_dropdown_item_1line, OPCOES); 17 18 // Resgatando o objeto (definido no XML) 19 AutoCompleteTextView txtAutoComplete = (AutoCompleteTextView)this.findViewById(R.main.txtAuto); 20 MultiAutoCompleteTextView txtMultiAutoComplete = (MultiAutoCompleteTextView)this.findViewById(R.main.txtMulti); 21 22 // Passando o Adapter para os dois objetos 23 txtAutoComplete.setAdapter(adapter); 24 txtMultiAutoComplete.setAdapter(adapter); 25 26 // Passando um Tokenizer para o Multi 27 txtMultiAutoComplete.setTokenizer(new MultiAutoCompleteTextView.CommaTokenizer()); 28 } 29 30 private static final String[] OPCOES = new String[] { 31 "Cadeira", "Brao", "Cor", "Encosto", "Mola", "Estofada", "Azul", "Vermelha" , "Rodinha" 32 }; 33 } Nas linhas 19 e 20 estamos resgatando a referncia dos objetos, nada de novo at ai. Porem nas linhas 23 e 24 passamos para os controles de interface um objeto Adapter.
Este objeto foi criado na linha 16, utilizamos as opes (array de String) e um DropDown para exibir as opes (parmetro simple_dropdown_item_1line). At este ponto os dois tipos de controles so iguais, agora vamos passar para o MultiAutoComplete um Tokenizer que ser utilizado para escolher as opes e adicionar a opo selecionada a caixa de texto. Vou neste primeiro exemplo usar o Tokenizer padro, que completa a palavra e adiciona virgula seguido de espao. Vamos aos testes que dever ficar mais claro.
109
Figura 128 - MultiAutoCompleteTextView e AutoCompleteTextView No campo AutoCompleteTextView vamos digitar Ca e vamos ver se ele exibe a opo Cadeira conforme esperado.
Figura 129 - Anlise do comportamento do AutoCompleteTextView Repare na figura acima que na caixa de digitao foi digitado Ca e apareceu um DropDown List com as opes definidas no array OPCOES. Foi exibido em um DropDown List porque no cdigo linha 16 quando definimos o Adapter o parmetro simple_dropdown_item_1line, existem outros parmetros que podem alterar o layout da lista de opes, como o select_dialog_multichoice que exibe um MultiChoice conforme figura abaixo.
Figura 130 - Uso do select_dialog_multichoice Vamos agora escolher a palavra cadeira e digitar na sequncia de Bra conforme figura abaixo (a ideia e digitar a frase Cadeira de Brao).
Figura 131 - AutoCompleteTextView com duas palavras Repare que no aparece o DropDown List, porque j fizemos a escolha da cadeira. Usabilidade: Utiliza-se o AutoCompleteTextView para dar a opo de escrita de uma palavra. Vamos agora passar para o MultiAutoCompleteTextView porque nosso objetivo escrever a frase: Cadeira de Brao. Vamos digitar Ca no MultiAutoCompleteTextView.
Figura 132 - Digitando Ca no MultiCompleteTextView Repare que a figura acima semelhante a Figura 129 exceto que o DropDown Lista apareceu acima do controle, mas isso foi apenas por posicionamento do controle. Selecione Cadeira na lista do
110
DropDown List.
Figura 133 - MultiCompleteTextView Por padro ele adicionou o Token virgula , e um espao para voc comear a digitar a prxima palavra. Vamos digitar Bra e ver se aparece o DropDown List.
Figura 134 MultiCompleteTextView Repare que aparece o DropDown List para que voc escolha a sua segunda opo. Mas no o que eu queria, desta forma vai ficar Cadeira, Brao e no Cadeira de Brao. Para uma mquina o uso da vrgul muito melhor do que a frase que estou propondo, se servir voc j pode parar por ai. Mas digamos que seja obrigatrio a frase completa Cadeira de Brao, vamos ver como fazer nosso Token. Crie uma classe dentro do pacote br.com.softpalm.auto chamada EspacoTokenizer, conforme figura abaixo.
Figura 135 - Project Explorer Agora vamos criar nosso Tokenizer conforme cdigo abaixo.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
package br.com.softpalm.auto; import android.widget.MultiAutoCompleteTextView.Tokenizer; // Vamos herdar de android.widget.MultiAutoCompleteTextView.Tokenizer public class EspacoTokenizer implements Tokenizer { // Precisamos sobrescrever 3 mtodos, o primeiro est relacionado // com a localicao do final do Token @Override public int findTokenEnd(CharSequence text, int cursor) { int pos = text.toString().indexOf(' ', cursor); return (pos < 0) ? (text.length() - 1) : (pos - 1); } // O segundo est relacionado com o incio da sequncia @Override public int findTokenStart(CharSequence text, int cursor) { int pos = text.toString().lastIndexOf(' ', cursor); return (pos < 0) ? 0 : (pos + 1); }
111
22 23 24 25 26 27 28 29 nada 30 31 32 33 34 35 36
// O terceiro deve avaliar a palavra escolhida e escolher // o Token que ser usado aps @Override public CharSequence terminateToken(CharSequence text) { String textStr = text.toString(); // Se o texto excolhido finaliza com espao ento no vamos fazer // caso contrrio vamos adicionar um espao no final if(textStr.endsWith(" ")) return textStr; else return textStr + " "; } }
O mtodo que dever adicionar nosso Token espao o terminateToken() que se uma palavra que no termina com espao for escolhida vamos adicionar no else. Agora falta voltar no cdigo da classe Main (que j foi feito) e alterar uma nica linha, por motivos de explicao vou recolocar todo o cdigo da classe com um destaque para a linha alterada.
1 package br.com.softpalm.auto; 2 3 import android.app.Activity; 4 import android.os.Bundle; 5 import android.widget.ArrayAdapter; 6 import android.widget.AutoCompleteTextView; 7 import android.widget.MultiAutoCompleteTextView; 8 // Reviso SVN 14 9 public class Main extends Activity { 10 11 public void onCreate(Bundle savedInstanceState) { 12 super.onCreate(savedInstanceState); 13 setContentView(R.layout.main); 14 15 // Criando um Adapter para associar a um array de opes mais provveis 16 ArrayAdapter<String> adapter = new ArrayAdapter<String>(this, android.R.layout.simple_dropdown_item_1line, OPCOES); 17 18 // Resgatando o objeto (definido no XML) 19 AutoCompleteTextView txtAutoComplete = (AutoCompleteTextView)this.findViewById(R.main.txtAuto); 20 MultiAutoCompleteTextView txtMultiAutoComplete = (MultiAutoCompleteTextView)this.findViewById(R.main.txtMulti); 21 22 // Passando o Adapter para os dois objetos 23 txtAutoComplete.setAdapter(adapter); 24 txtMultiAutoComplete.setAdapter(adapter); 25 26 // LINHA ALTERADA <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< 27 // Repare que estou fazendo uma instancia de EspacoTokenizer() 28 txtMultiAutoComplete.setTokenizer(new EspacoTokenizer()); 29 } 30 31 private static final String[] OPCOES = new String[] { 32 "Cadeira", "Brao", "Cor", "Encosto", "Mola", "Estofada", "Azul", "Vermelha" , "Rodinha"
33 34 }
};
Vamos agora executar a aplicao e ver o seu comportamento. Digite Ca e escolha a opo Cadeira no DropDown List, depois digite de e logo em seguida Br (ver figura abaixo).
Figura 136 - EspacoTokenizer Repare que ele exibe a segunda opo Brao, escolha e vamos ter nossa frase.
Spinner
Este componente possui um nome diferente em cada tecnologia, no vou explicar de imediato o que ele faz, vou apenas dizer seus nomes em outras tecnologias e vocs j vo associar: Em Java podemos chamar ele de JComboBox, em Visual Studio .NET chamamos de DropDownList quando estamos programando para Web Application e ComboBox quando estamos desenvolvendo aplicaes Windows Applicaton, em HB++ chamamos de ComboBox e em C++ para Palm temos que fazer. um controle que permite a seleo de itens de uma lista, porem seu estado adormecido tem a aparncia de uma caixa (com a descrio selecionada) associado a um boto, neste boto uma imagem de um triangulo.
Figura 137 - Layout do Spinner Quando pressionado o Spinner abre uma caixa de seleo com vrios itens em forma de lista (ver figura abaixo), basta o usurio selecionar e esta ser a opo exibida na descrio.
Figura 138 - Lista de um Spinner Na Palette procure por Spinner.
113
Figura 139 - Spinner na Palette Para fixar o uso do Spinner vamos desenvolver um exemplo com o seu uso e comentar algumas dicas de Usabilidade. Vamos criar um projeto exemplo, neste projeto o usurio dever escolher uma palavra de uma lista de palavras. Crie um projeto baseado nas configuraes da tabela abaixo. New Android Project Project name Build Target Application Name Package name Create Activity (selecionado) Min SDK Version Exemplo009 Android 2.2 Exemplo009 br.com.softpalm.layout.spinner Main 8
Adicione um controle Spinner, altere o arquivo main (XML) conforme a listagem abaixo.
1 2 3 4 5 6 7 8 9 10 11
<?xml version="1.0" encoding="utf-8"?> <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:orientation="vertical" android:layout_width="fill_parent" android:layout_height="fill_parent" android:background="#ffffff"> <Spinner android:layout_width="match_parent" android:id="@+id/spinner1" android:layout_height="wrap_content"> </Spinner> </LinearLayout> Agora que adicionamos o Spinner no modelo de design vamos partir para a edio do cdigo fonte da Activity, abra o arquivo Main.java. Edite o cdigo abaixo. package br.com.softpalm.layout; import import import import import import import android.app.Activity; android.os.Bundle; android.view.View; android.widget.AdapterView; android.widget.ArrayAdapter; android.widget.Spinner; android.widget.Toast;
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
/** * Activity que controla o arquivo main.xml * @author Wellington * * SVN: * * Ateno: o implements da linha abaixo adicionado para poder
114
18 19 e
* *
tratar os eventos do Spinner dentro da prpria classe porem obrigatrio implementar os mtodos onItemSelected
20 * onNothingSelected conforme podem ser observados neste cdigo 21 */ 22 public class Main extends Activity implements AdapterView.OnItemSelectedListener{ 23 @Override 24 public void onCreate(Bundle savedInstanceState) { 25 super.onCreate(savedInstanceState); 26 setContentView(R.layout.main); 27 28 // Resgatando a referncia do objeto 29 Spinner spinner = (Spinner) findViewById(R.id.spinner1); 30 31 // Criando um Adapter com os itens do array 32 ArrayAdapter<String> adapter = new ArrayAdapter<String>(this, android.R.layout.simple_dropdown_item_1line, OPCOES); 33 34 // Passando o Adapter com as opes para o Spinner 35 spinner.setAdapter(adapter); 36 37 // Criando o envento Selected 38 spinner.setOnItemSelectedListener(this); 39 } 40 41 /** 42 * Evento que ocorre quando algum item selecionado 43 */ 44 public void onItemSelected(AdapterView<?> parent, View v, int position, long id) { 45 // Exibindo a seleo feita pelo usurio 46 Toast.makeText(parent.getContext(), "Voc escolheu: " + OPCOES[position], Toast.LENGTH_LONG).show(); 47 } 48 49 /** 50 * Evento que ocorre quando a lista aberta mais o usurio no seleciona nada 51 */ 52 public void onNothingSelected(AdapterView parent) { 53 // No faa nada 54 } 55 56 // Array montado s para ter as opes 57 private static final String[] OPCOES = new String[] { "Cadeira", "Brao", "Cor", "Encosto", "Mola", "Estofada", "Azul", "Vermelha" , "Rodinha"}; 58 }
Ao executar a aplicao e selecionar um item uma mensagem dever ser exibida, conforme figura abaixo.
115
Figura 140 - Spinner com elementos O evento do Spinner s deve ser usado quando a ao do usurio sobre ele influenciar a tela ou os atributos da classe. Se for uma escolha com posterior ao de salvar (em um boto por exemplo) ento pegue o valor somente neste momento. Use o mtodo getSelectedItemPosition(). Spinner s = (Spinner)findViewById(R.id.spinner1); int x = s.getSelectedItemPosition();
Data e Hora
A manipulao de Data e Hora uma tarefa muito complicada, devido a formatao das diferentes culturas, o que gera sempre uma batalha para analisar a portablidade entre aplicaes e repositrios. Por se tratar de uma plataforma que ser utilizada por pessoas para gerenciamento pessoa natural que tenha vrios componentes destinados a manipulao de Data e Hora. DatePicker Componete destinado a edio de uma data contendo Ano, Ms e Dia. Possui botes grandes, visto que nesta plataforma no seu usa as famosas canetinhas e sim as pontas dos dedos. Na figura abaixo fiz questo de adicionar toda a tela para que se tenha ideia do espao ocupado pelo componente em sua configurao padro.
Figura 141 - DatePicker TimePicker Est evidente que o DatePicker no edita Hora e Minuto ( que em muitas plataformas um nnico componente edita Data e Hora). Para editar Hora e Minuto utilizamos o TimePicker, sua aparncia semelhante ao DatePicker conforme podemos observar na figura abaixo.
116
Figura 142 - DatePicker e TimePicker Perdemos quase uma tela toda, em tpicos futuros quando abordar formulrios vamos aprender a criar formulrios s para edio de Data e Hora. New Android Project Project name Build Target Application Name Package name Create Activity (selecionado) Min SDK Version Exemplo010 Android 2.2 Exemplo010 br.com.softpalm.layout.date Main 8
Vamos comear editando o arquivo XML de layout (main.xml), edite o layout conforme a listagem abaixo.
1 <?xml version="1.0" encoding="utf-8"?> 2 <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" 3 android:orientation="vertical" 4 android:layout_width="fill_parent" 5 android:layout_height="fill_parent" 6 android:background="#ffffff"> 7 <DatePicker android:id="@+main/dtpData" 8 android:layout_width="wrap_content" 9 android:layout_height="wrap_content"> 10 </DatePicker> 11 <TimePicker android:id="@+main/pthHora" 12 android:layout_width="wrap_content" 13 android:layout_height="wrap_content"> 14 </TimePicker> 15 <Button android:text="Exibir" 16 android:id="@+main/btnVer" 17 android:layout_width="wrap_content" 18 android:layout_height="wrap_content"> 19 </Button> 20 </LinearLayout> O objetivo permitir que o usurio selecione uma data e uma hora e clique no boto, quando clicar vamos exibir uma mensagem com os valores selecionados no DatePicker e TimePicker.
Vamos ento editar a Activity relacionada com o arquivo main.xml.
1 2 3 4
package br.com.softpalm.layout.date; import android.app.Activity; import android.os.Bundle;
117
5 import android.view.View; 6 import android.view.View.OnClickListener; 7 import android.widget.Button; 8 import android.widget.DatePicker; 9 import android.widget.TimePicker; 10 import android.widget.Toast; 11 12 /** 13 * Activity que gerencia o arquivo main.xml 14 * @author Wellington 15 * 16 * SVN: 16 17 * 18 */ 19 public class Main extends Activity { 20 /** Called when the activity is first created. */ 21 @Override 22 public void onCreate(Bundle savedInstanceState) { 23 super.onCreate(savedInstanceState); 24 setContentView(R.layout.main); 25 26 // Recuperando objeto Data 27 DatePicker dtpData = (DatePicker)this.findViewById(R.main.dtpData); 28 29 // Alterando o objeto data para exibir o dia em que um dos autores nasceu 30 dtpData.updateDate(1979, 05, 12); 31 32 // Resgatando o controle Button e criando um evento par ele 33 Button btnVer = (Button)this.findViewById(R.main.btnVer); 34 btnVer.setOnClickListener(new OnClickListener() { 35 public void onClick(View v) { 36 btnVer_Click(v); 37 } 38 }); 39 } 40 41 /** 42 * Evento que ocorre quando boto pressionado 43 */ 44 public void btnVer_Click(View v) 45 { 46 // Resgatando a referncia 47 DatePicker dtpData = (DatePicker)this.findViewById(R.main.dtpData); 48 TimePicker pthHora = (TimePicker)this.findViewById(R.main.pthHora); 49 50 // Utilizando os mtodos getMonth(), getDatyOfMonth(), getYear(), getCurrentHour() e getCurrentMinute 51 // para pegar os valores dos controles alterados pelo usurio 52 Toast.makeText(this, "Data: " + dtpData.getDayOfMonth() + "/" + dtpData.getMonth() + "/" + dtpData.getYear() + "\nHora: " + pthHora.getCurrentHour() + ":" + pthHora.getCurrentMinute(), 30).show(); 53 } 54 }
118
Comentrio do Autor: Senti a falta de um mtodo getDate() e achei estranho o updateDate(), esperava um setDate() para manter o padro, porem foi fcil o uso. O resultado da execuo da nossa aplicao pode ser vista na figura abaixo.
Figura 143 - DatePicker e TimePiker CalendarView CalendarView um Widget desenvolvido para exibir e selecionar uma ou mais datas. Verso: Este componente s pode ser utilizado a partir da verso 11 da API (Android 3.0).
Figura 144 - CalendarView Chronometer Classe que implementa um temporizador simples. Iniciamos a contagem a partir da chamada do mtodo start() e paralisamos a contagem chamando o mtodo stop(). Vamos ento criar um cronometro simples, um boto que inicia a contagem e outro que para. New Android Project Project name Build Target Application Name Package name Create Activity (selecionado) Min SDK Version Exemplo011 Android 2.2 Exemplo011 br.com.softpalm.layout.date Main 8
Vamos comear editando o arquivo XML de layout (main.xml), edite o layout conforme a listagem abaixo.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27
<?xml version="1.0" encoding="utf-8"?> <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:orientation="vertical" android:layout_width="fill_parent" android:layout_height="fill_parent" android:background="#ffffff"> <Chronometer android:text="Chronometer" android:id="@+main/chrCronometro" android:layout_width="wrap_content" android:layout_height="wrap_content" android:background="#000000"> </Chronometer> <Button android:text="Iniciar/Parar" android:id="@+main/btnIniciarParar" android:layout_width="wrap_content" android:layout_height="wrap_content"> </Button> <Button android:text="Zerar Contador" android:id="@+main/btnZerar" android:layout_width="wrap_content" android:layout_height="wrap_content"> </Button> </LinearLayout> Vamos resgatar as referncias dos objetos definidos no arquivo XML e criar os eventos necessrio. Lembrando que um boto deve iniciar a contagem se a contagem estiver parada ou parar a contagem caso j esteja iniciada.
J o segundo boto deve reiniciar a contagem em 00:00.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
package br.com.softpalm.date; import import import import import import import android.app.Activity; android.os.Bundle; android.os.SystemClock; android.view.View; android.view.View.OnClickListener; android.widget.Button; android.widget.Chronometer;
/** * Activity responsvel por gerenciar o arquivo main.xml * @author Wellington * * SVN: */ public class Main extends Activity { /** * Vriavel usada para guardar o status do Cronometro */ private boolean ligado = false; @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main);
120
27 28 // Fazer as referncias para os objetos no XML 29 this.btnIniciarParar = (Button)this.findViewById(R.main.btnIniciarParar); 30 this.btnZerar = (Button)this.findViewById(R.main.btnZerar); 31 this.chronometer = (Chronometer)this.findViewById(R.main.chrCronometro); 32 33 // Eventos do boto 34 this.btnIniciarParar.setOnClickListener( new OnClickListener(){ 35 public void onClick(View v) 36 { 37 btnIniciarParar_Click(v); 38 } }); 39 this.btnZerar.setOnClickListener( new OnClickListener(){ 40 public void onClick(View v) 41 { 42 btnZerar_Click(v); 43 } }); 44 } 45 46 public void btnIniciarParar_Click(View v) 47 { 48 // Os mtodos Start() e Stop() alteram o status do Cronometro 49 if(ligado) 50 this.chronometer.stop(); 51 else 52 this.chronometer.start(); 53 54 // Comutar o valor apenas 55 ligado = !ligado; 56 } 57 58 public void btnZerar_Click(View v) 59 { 60 this.chronometer.stop(); 61 62 // Zeramos o contador usando stBase() 63 this.chronometer.setBase(SystemClock.elapsedRealtime()); 64 ligado = false; 65 } 66 67 // Objetos 68 Button btnIniciarParar; 69 Button btnZerar; 70 Chronometer chronometer; 71 } A sequncia de imagem abaixo demonstra a funcionalidade da aplicao Exemplo011.
a) clique em iniciar
b) depois de um tempo zere o contador
c) contador zerado
121
Figura 145 - Sequncia de telas da aplicao Exemplo011
Imagens e Mdia
Por se tratar de um dispositivo voltado a um pblico que busca entretenimento a plataforma Android possui vrios componentes dedicados a exibio de imagens e mdias. O uso do vdeo pode ser til at em aplicaes coorporativas como uma Fora de Vendas, pense que o cliente esteja com receio de comprar um novo produto, um vdeo sobre o produto pode mudar sua opinio. Pene em um usurio de primeira viagem, talvez um vdeo possa explicar partes complexas do sistema. ImageView ImageView uma classe que rene membros destinados a exibio de imagem. Uma boa ferramenta para exibio de imagens de produtos e servios para o cliente. Uma imagem pode ser carregada dentro da prpria aplicao como uma Resource ou ser carregado a partir de um caminho dentro do Android, geralmente utilizamos o carto. Quando desenvolvia aplicaes para plataforma Palm OS (princpio em C++) eu tinha que ter todo o cuidado com a qualidade da imagem, se eu adicionasse imagens com alta qualidade e minha aplicao fosse executada em um equipamento com baixa resoluo ocorria um problema. A soluo era procurar nas variveis do sistema a informao sobre resoluo e escolher a imagem adequada. Quando conheci a ferramenta da Handheld-Basic vi que esta ao exibir a imagem realizava a validao e procurava a melhor imagem sem precisar de programao por parte do desenvolvedor, mas para isso eu deveria criar as imagens nas mais diferentes resolues, isso funcionava e era bom. difcil desenvolver aplicaes quando o host que dever executar nossa aplicao possui as mais diversas variedades. Como a plataforma Android surge aps as plataformas Symbian, Palm OS, Windows CE, etc. esta pode implementar casos de sucesso j ocorrido. A plataforma Android no ponto de vista dos autores deste livro a plataforma mais adaptada as diversidades, lgico que se sua aplicao requer o recurso GPS e o hardware do cliente no possui, natural que no funcione. Voc pode organizar os recursos (Resources) do projeto Android baseado em vrios critrios de configuraes, incluindo a lngua, a regio, as caractersticas da tela, mtodos de entrada, etc.. A plataforma Android possui um mecanismo muito robusto para o carregamento dos recursos apropriados em tempo de execuo, imagine que precisamos exibir um logo na tela inicial, podemos criar trs verses do logo com densidades diferentes, seriam adicionados nas pastas: TODO: IMAGEM A pasta drawable-hdpi requeresse a imagens de alta densidade, a pasta drawable-mdpi de mdia densidade e drawable-hdpi de baixa densidade. Ento nossas trs verses de logo ficaro em: /res/drawable-ldpi/meuLogo.png /res/drawable-mdpi/meuLogo.png /res/drawable-hdpi/meuLogo.png Vamos criar um projeto com 3 imagens diferentes, com o mesmo nome e testar em vrias densidades diferentes, voc deve estar se perguntando o porque ter trs imagens diferentes e no trs verses da mesma imagem para densidades diferentes, isso porque quero que veja que ele escolhe uma imagem baseado na densidade, se usar imagens parecidas no vamos ver a diferena. Abaixo temos as trs imagens.
drawable-ldpi
drawable-mdpi Figura 146 - Imagens em densidades diferentes
drawable-hdpi
Vamos ento criar um novo projeto conforme a descrio abaixo. New Android Project
122
Project name Build Target Application Name Package name Create Activity (selecionado) Min SDK Version
Exemplo012 Android 2.2 Exemplo012 br.com.softpalm.layout.image Main 8
Vamos ento distribuir as imagens acima (ver Figura 146) nas pastas conforme descrito, para isso utilize o Windows Explorer navegando at os diretrios do projeto e colando. Agora preciso atualizar o projeto no Eclipse, para isso selecione o projeto e clique no boto refresh.
Figura 147 - Atualizando o projeto Veja que as imagens apareceram.
Figura 148 - Project Explorer Vamos comear editando o cdigo do arquivo XML de layout (main.xml), edite o layout conforme a listagem abaixo.
1 <?xml version="1.0" encoding="utf-8"?> 2 <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" 3 android:orientation="vertical" 4 android:layout_width="fill_parent" 5 android:layout_height="fill_parent" 6 android:background="#ffffff"> 7 <ImageView 8 android:layout_height="wrap_content" 9 android:layout_width="wrap_content" 10 android:src="@drawable/logo" 11 android:id="@+main/imgLogo">
12 </ImageView> 13 </LinearLayout> Veja que na linha 10 estamos carregando o arquivo logo sem especificar a densidade, durante a execuo a aplicao dever pegar este ID e carregar a verso correta da imagem. Existe tambm a possibilidade de carregar via cdigo, mais a frente vamos demonstrar. O que j temos suficiente para demonstrar a troca de imagem baseado na resoluo.
Vamos executar a aplicao no emulador e ver qual imagem ele carregou.
Figura 149 - Imagem exibida em baixa densidade Carregou a imagem de baixa densidade, vou agora demonstrar como configurar a densidade do emulador, abra o Android SDK and AVD Manager conforme figura abaixo.
Figura 150 - Acessando o Android SDK and AVD Manager Selecione a configurao do seu emulador, vamos editar os parmetros do emulador.
Figura 151 - Lista de emuladores Mas lembre-se de fechar o emulador antes, clique no boto editar. Repare que em Hardware temos a propriedade Abstracted LCD densidty com o valor 120. Vamos alterar para 300 e salvar a configurao.
Figura 152 - Alterando a densidade Execute novamente a aplicao para carregar o emulador com a nova configurao.
Figura 153 - Imagem exibida em alta densidade A imagem mudou, isso porque estamos em alta densidade, 300 j hdpi. Voc pode agora ficar alterando estes valores (lembre-se que o padro para 2.2 120) e testando suas imagens. Agora vamos carregar uma nova imagem (como Resource) atravs de um evento de um boto.
Vamos comear alterando o arquivo main.xml.
1 <?xml version="1.0" encoding="utf-8"?> 2 <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" 3 android:orientation="vertical" 4 android:layout_width="fill_parent" 5 android:layout_height="fill_parent" 6 android:background="#ffffff"> 7 <ImageView 8 android:layout_height="wrap_content" 9 android:layout_width="wrap_content" 10 android:src="@drawable/logo" 11 android:id="@+main/imgLogo"> 12 </ImageView> 13 <Button 14 android:text="Carregar" 15 android:id="@+main/btnCarregar" 16 android:layout_width="wrap_content" 17 android:layout_height="wrap_content"> 18 </Button> 19 </LinearLayout> Repare que apenas adicionamos um boto, vamos agora editar um evento para o boto, este evento vamos trocar a imagem, para isso adicionei no projeto mais uma imagem, desta vez uma foto que ser capaz de assustar baratas tanto em ldpi quanto em hdpi, vou chamar essa foto de wellington.jpg.
O evento do boto ser editado na Activity Main.java conforme imagem abaixo.
1 package br.com.softpalm.layout.image; 2 3 import android.app.Activity; 4 import android.os.Bundle; 5 import android.view.View; 6 import android.view.View.OnClickListener; 7 import android.widget.Button; 8 import android.widget.ImageView; 9 10 /** 11 * 12 * @author Wellington 13 * 14 * SVN: 19 15 */ 16 public class Main extends Activity { 17 /** Called when the activity is first created. */ 18 @Override 19 public void onCreate(Bundle savedInstanceState) { 20 super.onCreate(savedInstanceState); 21 setContentView(R.layout.main); 22 23 Button btnCarregar = (Button)this.findViewById(R.main.btnCarregar); 24 25 btnCarregar.setOnClickListener( new OnClickListener(){ 26 27 public void onClick(View v) 28 { 29 btnCarregar_Click(v); 30 } 31 });
32 33 34 35 36 37 38 39 40 41 42 }
} public void btnCarregar_Click(View v) { ImageView img = (ImageView) this.findViewById(R.main.imgLogo); // Usamos o mtodo setImageResource() par alterar a imagem quando // ela est anexada ao projeto img.setImageResource(R.drawable.wellington); }
Ao executar a aplicao e clicar no boto voc ver que a imagem foi trocada, pronto, primeira aplicao capaz de dar susto em baratas, coloque um doce perto do equipamento e espere que a barata pise no boto, a imagem ser trocada e ser menos uma. Vamos voltar a falar srio agora, se voc quer desenvolver uma aplicao de fora de vendas e quer exibir a foto dos produtos, recomendo que carregue dinamicamente a partir de um carto. Geralmente o caminho para o carto interno /sdcard/ ou se preferir use o carto externo /extcard/. Para acessar o sdcard do emulador vou ensinar a utilizar uma Perspectiva nova, no vou entrar em detalhes agora pois vamos ter um captulo s para ela, chama-se perspectiva DDMS, voc j est acostumado a acessar as perspectivas Debug e Java conforme figura abaixo.
Figura 154 - Duas perspectivas Para acessar a perspectiva DDMS vamos precisar ativar ela, em Window | Open Perspective | DDMS conforme figura abaixo.
Figura 155 - Acessando perspectivas no visveis Apareceu a nova opo, conforme figura abaixo.
Figura 156 - Trs perspectivas Vamos agora navegar na estrutura interna do emulador e adicionar a figura wellington.jpg dentro da pasta /sdcard/. Para isso selecione o emulador, clique na aba File Explorer e cole o arquivo na pasta sdcard conforme seqncia abaixo.
Figura 157 - DDMS
126
Agora sabemos aonde est nossa figura, prximo passo criar um novo projeto para carregar esta figura quando necessrio. New Android Project Project name Build Target Application Name Package name Create Activity (selecionado) Min SDK Version Exemplo013 Android 2.2 Exemplo013 br.com.softpalm.layout.image Main 8
O arquivo main.xml ser igual ao utilizado no projeto anterior, vamos adicionar ele aqui para manter o padro do livro, voc pode copiar e colar se quiser.
1 <?xml version="1.0" encoding="utf-8"?> 2 <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" 3 android:orientation="vertical" 4 android:layout_width="fill_parent" 5 android:layout_height="fill_parent" 6 android:background="#ffffff"> 7 <ImageView 8 android:layout_height="wrap_content" 9 android:layout_width="wrap_content" 10 android:src="@drawable/icon" 11 android:id="@+main/imgLogo"> 12 </ImageView> 13 <Button 14 android:text="Carregar" 15 android:id="@+main/btnCarregar" 16 android:layout_width="wrap_content" 17 android:layout_height="wrap_content"> 18 </Button> 19 </LinearLayout> O cdigo da Activity responsvel pela manipulao do arquivo main.xml est descrita abaixo. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 package br.com.softpalm.layout.image; import java.io.File; import import import import import import import import android.app.Activity; android.graphics.Bitmap; android.graphics.BitmapFactory; android.os.Bundle; android.view.View; android.view.View.OnClickListener; android.widget.Button; android.widget.ImageView;
/** * * @author Wellington * * SVN: */ public class Main extends Activity { /** Called when the activity is first created. */ @Override
127
23 public void onCreate(Bundle savedInstanceState) { 24 super.onCreate(savedInstanceState); 25 setContentView(R.layout.main); 26 27 Button btnCarregar = (Button)this.findViewById(R.main.btnCarregar); 28 29 btnCarregar.setOnClickListener( new OnClickListener(){ 30 31 public void onClick(View v) 32 { 33 btnCarregar_Click(v); 34 } 35 }); 36 } 37 38 public void btnCarregar_Click(View v) 39 { 40 ImageView img = (ImageView) this.findViewById(R.main.imgLogo); 41 42 // Caminho da imagem, voc pode montar dinamicamente 43 // com informaes vindas do SQLite que vamos estudar 44 String imgPath = "/sdcard/wellington.jpg"; 45 46 // Cria um File para validar se existe arquivo 47 File imgFile = new File(imgPath); 48 if(imgFile.exists()){ 49 // Criamos um Bitmap, sei que est pensado que um jpg, mas funciona 50 Bitmap myBitmap = BitmapFactory.decodeFile(imgPath); 51 52 // Usamos o mtodo setImageBitmap() par alterar a imagem 53 // quando ela est anexada ao projeto 54 img.setImageBitmap(myBitmap); 55 } 56 else 57 { 58 // Imagem padro, pois no existe a imagem que procuramos 59 img.setImageResource(R.drawable.icon); 60 } 61 } 62 } Voc pode criar pastas com o rtulo igual ao ID do produto e listar as fotos, se no tiver a pasta ento carrega a imagem padro.
Figura 158 - Exemplo 13 ImageButton Quando programava para plataforma Palm OS a questo Boto com Imagem sempre foi algo complicado de se implementar, geralmente crivamos imagens e aguardvamos o evento Mouse Up sobre a imagem. Isso era ruim, pois o evento clique no somente composto pelo Mouse Up, ele composto por Mouse Down e Mouse Up em um determinado intervalo de tempo.
128
Outra questo interessante est relacionado a Interao Humano Computador, utilizar muitas imagens e com escala reduzida pode confundir usurios de primeira viagem, veja na imagem abaixo que uma ToolBar de botes foi desenvolvida, repare que o segundo elemento (da esquerda para a direita) d para saber que um disquete e que provavelmente vai salvar algo. Agora o que significa o nono elemento da barra?
Figura 159 - Toolbar Outro ponto importante que o boto com o disquete para uma pessoa com a mesma experincia que os autores do livro entendem como persistncia de algo, j para a nova gerao disquete no est em seus conhecimentos pois no conviveram, apenas sabem que algo que se salva, no futuro nem isso ser associado. A plataforma Android possui um problema para botes e componentes muito pequenos e to acoplados como esta barra, o problema que no se utiliza canetas para aplicar sobre touchscreen, a ponta do dedo. Se o usurio no tiver um equipamento bom este ter dificuldades para selecionar uma ao, o que causa certo nervosismo. No estamos dizendo que voc deva evitar o uso, apenas evitar o mau uso destes recursos. Por padro o ImageButton realmente uma juno de boto e imagem, logo ter bordas como um boto e uma imagem dentro, conforme imagem Figura 160 a. Esta imagem resultado do cdigo baixo.
1 <?xml version="1.0" encoding="utf-8"?> 2 <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" 3 android:orientation="vertical" 4 android:layout_width="fill_parent" 5 android:layout_height="fill_parent" 6 android:background="#ffffff" > 7 8 <ImageButton 9 android:layout_width="wrap_content" 10 android:layout_height="wrap_content" 11 android:id="@+id/imageButton1" 12 android:src="@drawable/icon" 13 > 14 </ImageButton> 15 </LinearLayout>
a) Boto com borda Figura 160 - Estilos de botes
b) Boto sem borda
Podemos alterar o estilo do ImageButton de acordo com nessas necessidades, a Figura 160 b
resultado da listagem abaixo.
1 <?xml version="1.0" encoding="utf-8"?> 2 <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" 3 android:orientation="vertical" 4 android:layout_width="fill_parent" 5 android:layout_height="fill_parent" 6 android:background="#ffffff" > 7 8 <ImageButton 9 android:layout_width="wrap_content" 10 android:layout_height="wrap_content" 11 android:id="@+id/imageButton1" 12 android:src="@drawable/icon" 13 android:background="#ffffff" 14 android:layout_marginTop="5dip" 15 android:layout_marginBottom="5dip" 16 > 17 </ImageButton> 18 </LinearLayout> Trs propriedades foram adicionadas, background que significa cor de fundo, marginTop e marginBottom definem as margens do controle.
Gallery Gallery um widget que exibe uma lista de imagens na horizontal na qual o usurio pode interagir rolando. Na figura abaixo temos vrias imagens, para visualizar as demais basta rolar com as mos e as imagens se movimentaro. Esse componente ideal para exibir vrias imagens de um produto.
Figura 161 - Gallery Porem a construo da aplicao no to trivial quanto as demais anteriores, requer um pouco mais de conhecimento sobre o ambiente. Ento vamos iniciar um novo projeto. New Android Project Project name Build Target Application Name Package name Create Activity (selecionado) Min SDK Version Exemplo014 Android 2.2 Exemplo014 br.com.softpalm.layout.image Main 8
O arquivo main.xml deve ser editado conforme a listagem abaixo.
130
1 2 3 4 5 6 7
<?xml version="1.0" encoding="utf-8"?> <Gallery xmlns:android="http://schemas.android.com/apk/res/android" android:id="@+main/gllImagens" android:layout_width="fill_parent" android:layout_height="fill_parent" android:background="#ffffff"> </Gallery> Agora vamos comear com algumas particularidades, vamos criar um arquivo resource XML que deve definir um atributo, par isso clique com o boto direito do mouse sobre e escolha New | Other conforme figura abaixo.
Figura 162 - Adicionando um arquivo XML Escolha Android XML File conforme figura abaixo.
Figura 163 - Android XML File O nome deste arquivo dever ser attrs.xml, salve e entre no editor para editar seu contedo, utilize para isso a listagem abaixo.
8 <?xml version="1.0" encoding="utf-8"?> 9 <resources> 10 <declare-styleable name="Exemplo014"> 11 <attr name="android:galleryItemBackground" /> 12 </declare-styleable> 13 </resources> Este um recurso personalizado pode ser aplicado a um layout. Neste caso, ser aplicado aos itens individuais colocados no Gallery. A tag <attr/> define um atributo especfico para o aplicativo, e neste caso, refere-se a um atributo existente na plataforma chamado galleryItemBackground, que define um estilo de borda para os itens da galeria. Na prxima etapa, voc ver como este atributo
referenciado e, posteriormente, aplicadas a cada item na galeria Precisamos agora adicionar quatro imagens nas pastas de resources drawable, vou utilizar as seguintes imagens JPG: Imagem
Nome
Imagem1
Imagem2
Imagem3
Imagem4
Quando trabalhamos com a caixa de seleo utilizamos um Adapter do prprio ambiente, adicionamos ao Adapter a lista de strings. Agora vamos criar nosso prprio Adapter pois temos mais detalhes para customizar. Crie uma classe nova chamada ImageAdapter e edite o cdigo desta conforme a listagem abaixo.
1 package br.com.softpalm.layout; 2 3 import android.content.Context; 4 import android.content.res.TypedArray; 5 import android.view.View; 6 import android.view.ViewGroup; 7 import android.widget.BaseAdapter; 8 import android.widget.Gallery; 9 import android.widget.ImageView; 10 11 /** 12 * 13 * @author Wellington 14 * 15 */ 16 public class ImageAdapter extends BaseAdapter { 17 int galleryItemBackground; 18 19 //Interface com as informaes globais do ambiente da aplicao. 20 // Esta uma classe abstrata, cuja implementao fornecida pelo sistema Android. 21 // Ele permite acesso a aplicaes especficas recursos e classes. 22 private Context context; 23 24 // Um array de referncias para resources 25 private Integer[] resourceId = { 26 R.drawable.imagem1, 27 R.drawable.imagem2, 28 R.drawable.imagem3, 29 R.drawable.imagem4 30 }; 31 32 // O construtor dever receber o context para recuperar informaes 33 // do ambiente, em especial galleryItemBackground 34 public ImageAdapter(Context context) { 35 this.context = context; 36 37 // Pegando o array de atributos de um resource (ver listagem attrs.xml)
38 TypedArray array = context.obtainStyledAttributes(R.styleable.Exemplo014); 39 40 // Obtendo um id de resource que est no atributo 41 galleryItemBackground = array.getResourceId( R.styleable.Exemplo014_android_galleryItemBackground, 0); 42 43 array.recycle(); 44 } 45 46 public int getCount() { 47 return resourceId.length; 48 } 49 50 public Object getItem(int position) { 51 return position; 52 } 53 54 public long getItemId(int position) { 55 return position; 56 } 57 /** 58 * Retorna uma View que ser exibida a imagem, vamos ento 59 * retornar uma ImageView 60 */ 61 public View getView(int position, View convertView, ViewGroup parent) { 62 ImageView imageView = new ImageView(this.context); 63 64 imageView.setImageResource(resourceId[position]); 65 imageView.setLayoutParams(new Gallery.LayoutParams(120, 120)); 66 imageView.setScaleType(ImageView.ScaleType.FIT_XY); 67 imageView.setBackgroundResource(galleryItemBackground); 68 69 return imageView; 70 } 71 } Veja que no getView() estou apenas retornando uma ImageView, se fosse preciso eu poderia criar uma View composta de vrios componentes grficos e retornar. Se as imagens esto vindo de um banco ou de um carto SD ento na linha 64 que voc dever alterar para carregar a imagem e anexar ao ImageView.
Est faltando somente editar nossa Activity responsvel por gerenciar o arquivo main.xml, abra o arquivo Main.java e codifique o cdigo abaixo.
1 2 3 4 5 6 7 8 9 10 11 12 13 14
package br.com.softpalm.layout; import import import import import import import android.app.Activity; android.os.Bundle; android.view.View; android.widget.AdapterView; android.widget.AdapterView.OnItemClickListener; android.widget.Gallery; android.widget.Toast;
/** * @author Wellington * * SVN:
133
15 */ 16 public class Main extends Activity { 17 /** Called when the activity is first created. */ 18 @Override 19 public void onCreate(Bundle savedInstanceState) { 20 super.onCreate(savedInstanceState); 21 setContentView(R.layout.main); 22 23 Gallery g = (Gallery) findViewById(R.main.gllImagens); 24 25 // Assim como nos Lists um Adapter que exibe as opes e o 26 // layout das opes, vamos construir nosso prprio adapter 27 // para ober o resultado que procuramos 28 g.setAdapter(new ImageAdapter(this)); 29 30 // Se clicar sobre uma imagem vamos exibir um texto 31 g.setOnItemClickListener(new OnItemClickListener() { 32 public void onItemClick(AdapterView parent, View v, int position, long id) { 33 gllImagens_Click(parent, v, position, id); 34 } 35 }); 36 } 37 38 public void gllImagens_Click(AdapterView parent, View v, int position, long id) 39 { 40 // Vamos apenas exibir a posio, mas seria interessante 41 // se fosse ampliada a imagem atravs do auxlio de um segundo formulrio 42 Toast.makeText(this, "" + position, Toast.LENGTH_SHORT).show(); 43 44 } 45 } Ao executar a aplicao voc poder ver as imagens, corra o dedo sobre a tela para a horizontal como se estivesse passando uma pgina, veja que as imagens se movimentam.
Se voc precisar exibir a imagem ampliada pode alterar o mtodo gllImagens_Click(), na qual em vez de exibir o Toast voc pode exibir um segundo formulrio com a imagem ampliada.
Listas e Tabelas
Um ponto forte na plataforma Android a variedade de elementos de interface, lgico que se comparado com a plataforma Palm OS ou Windows Mobile, tambm o que podemos esperar de uma plataforma que nasce aps anos do surgimento da plataforma mvel. Um grupo de controles que so muito usados so os de listagem, isso porque tudo temos que listar para escolha do usurio, evite fazer o usurio ficar digitando, sempre proponha algo para se selecionar, e se no tiver d a oportunidade do usurio criar opes na lista. ListView No nosso prximo exemplo vamos exibir uma lista simples, de uma nica coluna apenas com nomes. Ateno: Se tiver que usar mais de uma coluna de texto use o GridView, mesmo que o ListView possa atender a esta necessidade. O ListView o componente ideal, simples e de fcil manipulao exibe uma coluna nica, geralmente 6 itens por tela, ento nada de fazer lista com mais de 60 elementos. Neste nosso exemplo vamos listar as equipes que Ayrton Senna competiu. Vamos ver se voc brasileiro. Crie o Projeto conforme tabela abaixo.
134
New Android Project Project name Build Target Application Name Package name Create Activity (selecionado) Min SDK Version Exemplo016 Android 2.2 Exemplo016 br.com.softpalm.layout.lista Main 8
Agora vamos adicionar um ListView na interface main.xml conforme listagem abaixo.
1 2 3 4 5 6 7 8 9 10 11 12
<?xml version="1.0" encoding="utf-8"?> <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:orientation="vertical" android:layout_width="fill_parent" android:layout_height="fill_parent"> <ListView android:layout_height="wrap_content" android:id="@+main/lstEquipes" android:layout_width="match_parent"> </ListView> </LinearLayout> Agora vamos editar o arquivo de cdigo associado, abra o arquivo Main.java e edite o cdigo abaixo. package br.com.softpalm.layout.lista; import android.app.Activity; import android.os.Bundle; import android.view.View; import android.widget.AdapterView; import android.widget.AdapterView.OnItemClickListener; import android.widget.ArrayAdapter; import android.widget.ListView; import android.widget.Toast; // SVN: 20 public class Main extends Activity { // Equipes que tiveram o prazer de trabalhar com Ayrton Senna private String[] equipes = { "Toleman", "Lotus", "McLaren", "Williams"
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 };
16 ListView lstEquipes; 17 18 @Override 19 public void onCreate(Bundle savedInstanceState) { 20 super.onCreate(savedInstanceState); 21 setContentView(R.layout.main); 22 23 lstEquipes = (ListView) this.findViewById(R.main.lstEquipes); 24 25 // Para adicionar valores no ListView voc vai precisar de um Adapter 26 // dessa vez vou usar o Adapter padro, mas no prximo exemplo 27 // vamos criar nosso prprio adapter 28 lstEquipes.setAdapter(new ArrayAdapter<String>(this, 29 android.R.layout.simple_list_item_1,
135
equipes)); 30 31 // Criando o evento, daqui para baixo j estamos carecas de saber como funciona 32 lstEquipes.setOnItemClickListener(new OnItemClickListener() { 33 @Override 34 public void onItemClick(AdapterView<?> a, View v, int position, 35 long id) { 36 lista_ItemClick(v, position); 37 } 38 }); 39 } 40 41 public void lista_ItemClick(View v, int position) 42 { 43 Toast.makeText(Main.this, "Equipe: " + lstEquipes.getItemAtPosition(position), 300).show(); 44 } 45 } Voc pode executar a aplicao, clique nos itens que dever exibir uma mensagem. Agora digamos que voc queira abstrair os itens de uma fonte no fixa, por exemplo uma base SQLite, HTTP/WebService, arquivo txt, etc..
Vou demonstrar como alterar esta classe Main.java (reviso svn 20), vamos alterar a forma de carregamento utilizando o mtodo Add.
1 package br.com.softpalm.layout.lista; 2 3 import android.app.Activity; 4 import android.os.Bundle; 5 import android.view.View; 6 import android.widget.AdapterView; 7 import android.widget.AdapterView.OnItemClickListener; 8 import android.widget.ArrayAdapter; 9 import android.widget.ListView; 10 import android.widget.Toast; 11 12 public class Main extends Activity { 13 14 ListView lstEquipes; 15 16 @Override 17 public void onCreate(Bundle savedInstanceState) { 18 super.onCreate(savedInstanceState); 19 setContentView(R.layout.main); 20 21 lstEquipes = (ListView) this.findViewById(R.main.lstEquipes); 22 23 // Repare que no estamos passando um array, estamos apenas criando um Adapter 24 ArrayAdapter<String> array = new ArrayAdapter<String>(this, 25 android.R.layout.simple_list_item_1); 26 27 lstEquipes.setAdapter(array); 28 29 // Aqui voc vai fazer um lao (for, while, do...while) em alguma fonte de dados e usar o mtodo Add do adapter para adicionar, vou aqui criar 4 Adds apenas para ilustrar, no captulo de SQLite vamos usar novamente porem
136
dentro de um lao 30 array.add("Toleman"); 31 array.add("Lotus"); 32 array.add("McLaren"); 33 array.add("Williams"); 34 35 // Criando o evento, daqui para baixo j estamos carecas de saber como funciona 36 lstEquipes.setOnItemClickListener(new OnItemClickListener() { 37 @Override 38 public void onItemClick(AdapterView<?> a, View v, int position, 39 long id) { 40 lista_ItemClick(v, position); 41 } 42 }); 43 } 44 45 public void lista_ItemClick(View v, int position) 46 { 47 Toast.makeText(Main.this, "Equipe: " + lstEquipes.getItemAtPosition(position), 300).show(); 48 } 49 } Execute a aplicao (reviso SVN 21) e veja que ter o mesmo resultado do exemplo em que usamos um array de strings.
Agora vamos melhorar nosso exemplo, digamos que voc queira exibir uma seleo, atravs de um check simples. Temos duas alternativas a opo de exibir uma imagem de um crculo ou um
quadrado . A opo do crculo descreve implicitamente que s pode haver um selecionado na lista e a opo do quadrado descreve que muitos podem ser selecionados. Vamos alterar o cdigo Main.java e vamos usar seleo simples com a imagem do cruculo.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
package br.com.softpalm.layout.lista; import import import import import import import import android.app.Activity; android.os.Bundle; android.view.View; android.widget.AdapterView; android.widget.AdapterView.OnItemClickListener; android.widget.ArrayAdapter; android.widget.ListView; android.widget.Toast;
public class Main extends Activity { // Reviso SVN: 22 ListView lstEquipes; @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); lstEquipes = (ListView) this.findViewById(R.main.lstEquipes); // A opo simple_list_item_single_choice no construtor abaixo // cria uma view para cada item com um objeto circular
137
25 // que representa uma seleo simples (no mximo 1 elemento) 26 ArrayAdapter<String> array = new ArrayAdapter<String>(this, 27 android.R.layout.simple_list_item_single_choice); 28 29 lstEquipes.setAdapter(array); 30 array.add("Toleman"); 31 array.add("Lotus"); 32 array.add("McLaren"); 33 array.add("Williams"); 34 35 // A linha abaixo muito importante, no adianta somente 36 // escolher o valor simple_list_item_single_choice no construtor 37 // do Adapter, voc precisa informar ao list que seu modo ser 38 // seleo simples (no mximo 1 elemento) 39 lstEquipes.setChoiceMode(ListView.CHOICE_MODE_SINGLE); 40 41 42 lstEquipes.setOnItemClickListener(new OnItemClickListener() { 43 @Override 44 public void onItemClick(AdapterView<?> a, View v, int position, 45 long id) { 46 lista_ItemClick(v, position); 47 } 48 }); 49 } 50 51 public void lista_ItemClick(View v, int position) 52 { 53 Toast.makeText(Main.this, "Equipe: " + lstEquipes.getItemAtPosition(position), 300).show(); 54 } 55 } Execute a aplicao, escolha um item, agora escolha outro. Veja que o primeiro desmarcado, isso porque ele somente aceita seleo simples.
Nosso prximo passo transformar este exemplo em seleo mltipla, para isso vamos usar a imagem do quadrado que descreve implicitamente ao usurio que ele pode selecionar mais de um elemento.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
package br.com.softpalm.layout.lista; import import import import import import import import android.app.Activity; android.os.Bundle; android.view.View; android.widget.AdapterView; android.widget.AdapterView.OnItemClickListener; android.widget.ArrayAdapter; android.widget.ListView; android.widget.Toast;
public class Main extends Activity { // Reviso SVN: 23 ListView lstEquipes; @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main);
138
20 21 22 23 24 25 26 27
lstEquipes = (ListView) this.findViewById(R.main.lstEquipes); // A opo simple_list_item_multiple_choice no construtor abaixo // cria uma view para cada item com um objeto quadrado // que representa uma seleo mltipla ArrayAdapter<String> array = new ArrayAdapter<String>(this,
android.R.layout.simple_list_item_multiple_choice); 28 29 lstEquipes.setAdapter(array); 30 array.add("Toleman"); 31 array.add("Lotus"); 32 array.add("McLaren"); 33 array.add("Williams"); 34 35 // A linha abaixo muito importante, no adianta somente 36 // escolher o valor simple_list_item_multiple_choice no construtor 37 // do Adapter, voc precisa informar ao list que seu modo ser 38 // seleo mltipla 39 lstEquipes.setChoiceMode(ListView.CHOICE_MODE_MULTIPLE); 40 41 42 lstEquipes.setOnItemClickListener(new OnItemClickListener() { 43 @Override 44 public void onItemClick(AdapterView<?> a, View v, int position, 45 long id) { 46 lista_ItemClick(v, position); 47 } 48 }); 49 } 50 51 public void lista_ItemClick(View v, int position) 52 { 53 Toast.makeText(Main.this, "Equipe: " + lstEquipes.getItemAtPosition(position), 300).show(); 54 } 55 } Execute a aplicao, selecione vrios itens e veja que ele no desmarca, isso porque o controle aceita seleo mltipla.
ExpandableListView Vimos neste captulo como criar listas simples, porem existem casos em que precisamos criar listas e sub-listas, um exemplos: Uma lista de computadores em que d para se ver os itens como lista; Uma lista de carros com descrio dos acessrios em lista; Uma lista de produtos com uma sub-lista de alternativas concorrente. A interface seria semelhante a imagem abaixo.
139
No exemplo acima eu criei uma lista principal (chamada grupo) que tem os itens Famlia e Animais. Cada um elemento da lista principal possui uma lista secundria chamadas de filhos. Na figura acima podemos ver que o elemento 0 da lista principal foi pressionado abrindo 5 elementos da lista secundria. J o elemento 1 da lista principal encontra-se recolhido. Gosto sempre de demonstrar um exemplo prtico e funcional, ento vamos iniciar um novo projeto. New Android Project Project name Build Target Application Name Package name Create Activity (selecionado) Min SDK Version Exemplo015 Android 2.2 Exemplo015 br.com.softpalm.layout.lista Main 8
Como de costume vamos implementar a interface, ou seja, o arquivo main.xml de acordo com a listagem abaixo.
1 <?xml version="1.0" encoding="utf-8"?> 2 <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" 3 android:orientation="vertical" 4 android:layout_width="fill_parent" 5 android:layout_height="fill_parent" 6 android:background="#ffffff"> 7 <ExpandableListView 8 android:id="@+main/expLista" 9 android:layout_height="wrap_content" 10 android:layout_width="match_parent"> 11 </ExpandableListView> 12 </LinearLayout> O exemplo simples, apenas estamos adicionando um elemento ExpandableListView, nenhum segredo.
Agora o prximo passo o segredo do objeto, vamos criar uma classe que vai controlar o comportamento e a aparncia da lista, como sempre ensino a criar estas classes que herdam de Adapter para que o leitor conhea o poder do controle. Crie uma classe e adicione ao pacote principal, chame este classe de MyExpandableListAdapter e codifique a listagem abaixo.
1 2 3 4 5 6
package br.com.softpalm.lista; import import import import android.app.Activity; android.graphics.Color; android.graphics.Typeface; android.view.Gravity;
140
7 import android.view.View; 8 import android.view.ViewGroup; 9 import android.widget.AbsListView; 10 import android.widget.BaseExpandableListAdapter; 11 import android.widget.TextView; 12 13 public class MyExpandableListAdapter extends BaseExpandableListAdapter 14 { 15 // Vamos criar um objeto Activity na qual possui o objeto de interface 16 public Activity main; 17 18 // ATENO: Neste exemplo vou adicionar os dados em um array mas voc pode extrair dados de uma base de dados 19 // Vamos criar um Array com os itens famlha e um de animais, 20 // esses dois grupos devero conter elementos 21 private String[] groups = { "Famlia", "Animais" }; 22 23 // Vamos criar agora uma madriz de 2xN, 2 pois temos dois grupos 24 private String[][] children = { 25 { "Wallace", "Wellington", "Wanderson", "Jordelina", "Jos" }, 26 { "Pipinho", "Katy Maria", "Beto", "Penelopinha", "Mimizo", "Meuzinho" } 27 }; 28 29 // Construtor 30 public MyExpandableListAdapter(Main main) 31 { 32 this.main = main; 33 } 34 35 // Retorna um elemento da matriz dado o grupo e a posio do filho 36 public Object getChild(int groupPosition, int childPosition) { 37 return children[groupPosition][childPosition]; 38 } 39 40 // Retorna a posio do filho, obrigatrio pois estamos 41 // herdando de BaseExpandableListAdapter 42 public long getChildId(int groupPosition, int childPosition) { 43 return childPosition; 44 } 45 46 // Nmero de filhos em um grupo 47 public int getChildrenCount(int groupPosition) { 48 return children[groupPosition].length; 49 } 50 51 // Retorna uma TextView para montagem da lista 52 // ento nossa lista ser composta por TextView 53 public TextView getGenericView() { 54 // LayoutParams um objeto utilizado para passar parmetros para o layout MATCH_PARENT o tamanho do elemento, utilizado a partir da API 8 neste caso vamos usar tamanho 25, mais lembre-se que quanto maior 55 // lista menos elementos porem quanto menor fica mais difcil selecionar 56 AbsListView.LayoutParams lp = new AbsListView.LayoutParams( 57 ViewGroup.LayoutParams.MATCH_PARENT, 25); 58
141
59 // Cria a TextView para a Activity e passa os parametros 60 TextView textView = new TextView(main); 61 textView.setLayoutParams(lp); 62 63 // Vamos centralizar o texto 64 textView.setGravity(Gravity.CENTER_VERTICAL | Gravity.LEFT); 65 66 // dar 5 pixels para a esquerda para no colar na tela 67 textView.setPadding(5, 0, 0, 0); 68 return textView; 69 } 70 71 // Cada elemento uma TextView que por sua vez herda de View 72 // neste exemplo apenas retornamos o prprio TextView, voc pode 73 // customizar esta view e adicionar ImageView entre outros elementos 74 // grficos 75 public View getChildView(int groupPosition, int childPosition, boolean isLastChild, View convertView, ViewGroup parent) { 76 77 // Pega o TextView genrico 78 TextView textView = getGenericView(); 79 80 // Altera as propriedades para os elementos filhos (matriz) 81 textView.setPadding(30, 0, 0, 0); 82 textView.setText(getChild(groupPosition, childPosition).toString()); 83 textView.setTextColor(Color.BLUE); 84 return textView; 85 } 86 87 // Retorna um grupo dado sua posio no array 88 public Object getGroup(int groupPosition) { 89 return groups[groupPosition]; 90 } 91 92 // Retorna o numero de grupos existentes no array de grupos 93 public int getGroupCount() { 94 return groups.length; 95 } 96 97 // Retorna o numero da posio do grupo 98 public long getGroupId(int groupPosition) { 99 return groupPosition; 100 } 101 102 // Retorna uma View para o grupo, vimos que existe o getChildView 103 // esse mtodo faz a mesma coisa porem par grupos, voc pode 104 // querer ter um layout diferente para grupo 105 public View getGroupView(int groupPosition, boolean isExpanded, View convertView, ViewGroup parent) { 106 TextView textView = getGenericView(); 107 108 // Para manter o layout diferente vou exibir o nmero de filhos 109 textView.setText(getGroup(groupPosition).toString() + " (" + getChildrenCount(groupPosition) + ")"); 110 111 // Ser vermelho
142
112 textView.setTextColor(Color.RED); 113 textView.setTextSize(14); 114 115 // Ter a fonte em negrito 116 textView.setTypeface(Typeface.DEFAULT, Typeface.BOLD); 117 return textView; 118 } 119 120 // Todos podem ser selecionados 121 public boolean isChildSelectable(int groupPosition, int childPosition) { 122 return true; 123 } 124 public boolean hasStableIds() { 125 return true; 126 } 127 } Criamos primeiro a classe MyExpandableListAdapter pois precisamos de uma instancia desta classe no cdigo da classe Main.java. Abra o arquivo Main.java e edite conforme listagem abaixo. 1 package br.com.softpalm.lista; 2 3 import android.app.Activity; 4 import android.os.Bundle; 5 import android.view.View; 6 import android.widget.ExpandableListAdapter; 7 import android.widget.ExpandableListView; 8 import android.widget.ExpandableListView.OnChildClickListener; 9 import android.widget.ExpandableListView.OnGroupClickListener; 10 import android.widget.Toast; 11 12 public class Main extends Activity { 13 14 // Criamos um objeto MyExpandableListAdapter 15 ExpandableListAdapter mAdapter; 16 17 @Override 18 public void onCreate(Bundle savedInstanceState) { 19 super.onCreate(savedInstanceState); 20 setContentView(R.layout.main); 21 22 // Fazemos a instancia passando esta activity 23 mAdapter = new MyExpandableListAdapter(this); 24 25 // Pegamos a referncia para o objeto na interface 26 ExpandableListView expLista = (ExpandableListView)findViewById(R.main.expLista); 27 28 // Passamos o adapter para este objeto de interface 29 expLista.setAdapter(mAdapter); 30 31 // Criamos o evento Click para os itens da lista secundria (filhos) 32 expLista.setOnChildClickListener(new OnChildClickListener() { 33 34 @Override 35 public boolean onChildClick(ExpandableListView parent, View v, int groupPosition, int childPosition, long id)
143
36 { 37 return exp_ChildClick(parent, v, groupPosition, childPosition, id); 38 } 39 }); 40 41 // Criamos o evento Click para os itens da lista principal (grupos) 42 expLista.setOnGroupClickListener(new OnGroupClickListener() { 43 44 @Override 45 public boolean onGroupClick(ExpandableListView parent, View v, int groupPosition, long id) { 46 47 return exp_GroupClick(parent, v, groupPosition, id); 48 } 49 }); 50 } 51 52 // Apenas para exibir uma mensagem 53 public boolean exp_ChildClick(ExpandableListView parent, View v, int groupPosition, int childPosition, long id) 54 { 55 Toast.makeText(this, "Lista Secundria\r\n\r\n" + parent + ",\r\n " + v + ",\r\n (" + groupPosition + "|" + childPosition + "),\r\n " + id, 500).show(); 56 57 // Nenhum evento mais deve ocorrer para o click no filho 58 return true; 59 } 60 61 public boolean exp_GroupClick(ExpandableListView parent, View v, int groupPosition, long id) 62 { 63 Toast.makeText(this, "Lista Primria\r\n\r\n" + parent + ",\r\n " + v + ",\r\n " + groupPosition + ",\r\n " + id, 500).show(); 64 65 // Muito importante, estamos retornado false pois quer dizer 66 // que o evento no deve ser parado, se colocar true a lista 67 // de filhos no ser aberta, faa o teste 68 return false; 69 } 70 } Voc pode usar o Adapter criado aqui em qualquer tela, pois toda interface herda de Ativity, talvez a sua nica alterao no carregamento do Array e da Matriz com os elementos. Sei que no parece to simples como deveria ser (se comparado com os ambientes Microsoft) mas lembre-se que uma API que est em evoluo.
GridView GridView um componente que permite exibir linhas e colunas, imagine uma planilha Excel. Ideal para exibir informaes do tipo (so apenas alguns exemplos): Lista de produtos; Vendas realizadas; Produtos adquiridos; Quando me deparei com o GridView na plataforma Android encontrei um componente rico e flexvel, porem tambm me deparei com a complexidade de programao, tanto que neste tpico vou criar vrios projetos para deixar bem claro como manipular este componente.
Nosso primeiro exemplo ser uma aplicao com um GridView que dever ter trs colunas (Cdigo, Descrio e Valor) no qual vou exibir alguns produtos. New Android Project Project name Build Target Application Name Package name Create Activity (selecionado) Min SDK Version Exemplo017 Android 2.2 Exemplo017 br.com.softpalm.layout.grid Main 8
Se voc programa em Delphi ou alguma linguagem de alto nvel da Microsoft est acostumado a clicar com o boto direito do mouse sobre o DataGrid (GridView) e editar as colunas. Aqui na plataforma Android vamos ter que criar (para este exemplo, existem formas mais complexas que no utilizam XML) um arquivo XML que dever ter trs TextViews, um para cada coluna (Cdigo, Descrio e Preo). Veja na imagem abaixo que na barra existe um boto que adiciona um arquivo XML (ver imagem abaixo).
Uma nova janela ser aberta, digite no campo File o nome row.xml e finalize o processo, repare que em Layout ser criado um arquivo row.xml (ver figura abaixo). Selecione o novo arquivo e entre no editor XML conforme imagem abaixo.
Vamos criar um LinearLayout (que ser discutido no futuro) com trs TextViews, repare que os IDs revelam quais colunas vamos exibir.
1 <?xml version="1.0" encoding="utf-8"?> 2 <LinearLayout 3 xmlns:android="http://schemas.android.com/apk/res/android" 4 android:paddingTop="4dip" 5 android:paddingBottom="6dip" 6 android:layout_width="fill_parent" 7 android:layout_height="wrap_content" 8 android:orientation="horizontal"> 9 10 <TextView android:id="@+row/CODIGO_CELL" 11 android:layout_width="50dip" 12 android:textColor="#000000" 13 android:layout_height="wrap_content"/>
14 15 <TextView android:id="@+row/DESCRICAO_CELL" 16 android:layout_width="wrap_content" 17 android:textColor="#000000" 18 android:layout_height="wrap_content" android:layout_weight="1"/> 19 20 <TextView android:id="@+row/VALOR_CELL" 21 android:layout_width="60dip" 22 android:textColor="#000000" 23 android:gravity="right" 24 android:layout_height="wrap_content" android:layout_weight="1"/> 25 </LinearLayout> Agora vamos editar o arquivo main.xml que dever conter o GridView, para isso utilize a listagem abaixo. 1 <?xml version="1.0" encoding="utf-8"?> 2 <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" 3 android:orientation="vertical" 4 android:layout_width="fill_parent" 5 android:layout_height="fill_parent" 6 android:background="#ffffff"> 7 <GridView 8 android:id="@+main/grdLista" 9 android:layout_width="match_parent" 10 android:layout_height="wrap_content"> 11 </GridView> 12 </LinearLayout> Repare que adicionamos um GridView porem no fizemos nenhuma referncia ao row.xml, mas se o row.xml dever ser exibido dentro do GridView como isso vai funcionar? Simples, o relacionamento entre o GridView e o row.xml ser feito pelo intermedirio Adapter, novamente trabalhando com Adapter, porem desta vez vamos usar um que j existe.
Vamos ento alterar a Activity que controla o arquivo main.xml, abra o arquivo Main.java e edite o cdigo abaixo.
1 package br.com.softpalm.grid; 2 3 import java.util.ArrayList; 4 import java.util.HashMap; 5 6 import android.app.Activity; 7 import android.os.Bundle; 8 import android.view.View; 9 import android.widget.AdapterView; 10 import android.widget.AdapterView.OnItemClickListener; 11 import android.widget.GridView; 12 import android.widget.SimpleAdapter; 13 import android.widget.Toast; 14 15 // Saiba mais sobre colees de dados 16 // (1) = (http://download.oracle.com/javase/1.4.2/docs/api/java/util/ArrayList.html) 17 // (2) = (http://download.oracle.com/javase/1.4.2/docs/api/java/util/HashMap.html) 18 // Reviso SVN: 24 19 public class Main extends Activity { 20
146
21 GridView grdLista; 22 @Override 23 public void onCreate(Bundle savedInstanceState) { 24 super.onCreate(savedInstanceState); 25 setContentView(R.layout.main); 26 27 grdLista = (GridView) findViewById(R.main.grdLista); 28 29 // Vamos criar um ArrayList (1) e os elementos deste ArrayList 30 // sero do tipo HashMap (2) 31 ArrayList<HashMap<String, String>> mylist = new ArrayList<HashMap<String, String>>(); 32 33 // Vamos criar a primeira linha, se voc quiser pode carregar 34 // dados de um SQLite e fazer um lao de repetio 35 HashMap<String, String> map = new HashMap<String, String>(); 36 map.put("codigo", "108"); 37 map.put("descricao", "Antena Yagui 8 elementos"); 38 map.put("valor", "5,60"); 39 mylist.add(map); 40 41 // Criar mais um s para exibir uma lista com 2 itens 42 map = new HashMap<String, String>(); 43 map.put("codigo", "110"); 44 map.put("descricao", "Antena Yagui 10 elementos"); 45 map.put("valor", "10,90"); 46 mylist.add(map); 47 48 // Agora vem a mgica, vamos criar um SimpleAdapter (j existe na 49 // API android) e vamos passar a lissta de elementos 50 // o row.xml e um dois arrays que faro a referncia entre 51 // os TextViews do row.xml com as colunas definidas no HashMap 52 SimpleAdapter mSchedule = new SimpleAdapter(this, mylist, R.layout.row, 53 new String[] { "codigo", "descricao", "valor" }, 54 new int[] { R.row.CODIGO_CELL, R.row.DESCRICAO_CELL,R.row.VALOR_CELL }); 55 // Repare que nas linhas acima eu posicionei s para o leitor fazer 56 // a referncia visual e enxergar como relacionamos os 57 // TextViews com as colunas do HashMap 58 59 // Daqui para frente padro, j discutimos em exemplos anteriores 60 grdLista.setAdapter(mSchedule); 61 62 grdLista.setOnItemClickListener(new OnItemClickListener() { 63 @Override 64 public void onItemClick(AdapterView<?> a, View v, int position, long id) { 65 grdLista_ItemClick(v, position); 66 } 67 }); 68 } 69 70 public void grdLista_ItemClick(View v, int position) { 71 72 // Esse ponto interessante, como adicionamos HashMap 73 // os registros do Grid possuem HashMap, por isso
147
74 // estou fazendo o CAST (HashMap<String, String>) 75 HashMap<String, String> map = (HashMap<String, String>)grdLista.getItemAtPosition(position); 76 77 // Exibir mensagem padro 78 Toast.makeText(Main.this,"Equipe: " + map.get("codigo"), 300).show(); 79 } 80 } Se voc recupera os dados de um SQLite, WebService, arquivo txt, etc.. basta criar um HashMap para cada elemento e adicionar ao ArrayList, talvez a nica ateno Mgica est nos parmetros do SimpleAdapter.
Execute a aplicao e clique em um item, veja, uma mensagem ser exibida.
Figura 164 - Exemplo 17
Gerenciadores de Layout
Gerenciadores de Layout controlam a disposio dos objetos de interface e suas dimenses, com o uso correto deste recurso possvel desenvolver aplicaes que se adaptem a qualquer disposio de interface. At o momento no configuramos a disposio dos elementos de interface, isso porque usamos o padro, agora vamos exibir os principais gerenciadores de layout.
FrameLayout
FrameLayout um gerenciador de layout que organiza objetos de interface baseado nas configuraes individuais, se nenhuma configurao for feita no controle por padro todos sero sobrepostos no canto superior esquerdo, veja o exemplo abaixo:
0 <?xml version="1.0" encoding="utf-8"?> 1 <FrameLayout xmlns:android="http://schemas.android.com/apk/res/android" 2 android:background="#ffffff" 3 android:id="@+id/frameLayout1" 4 android:layout_width="fill_parent" 5 android:layout_height="fill_parent" > 6 <TextView 7 android:text="TextView" 8 android:id="@+id/textView1" 9 android:layout_width="wrap_content" 10 android:layout_height="wrap_content"> 11 </TextView> 12 <Button 13 android:text="Button" 14 android:id="@+id/button1"
148
15 android:layout_width="wrap_content" 16 android:layout_height="wrap_content"> 17 </Button> 18 </FrameLayout> O layout esperado para o XML acima exibido na imagem abaixo.
Figura 165 - FrameLayout com dois objetos Veja que tanto o TextView quanto o Button foram alinhados no canto superior esquerdo, isso porque no definimos a posio de cada um, vamos ento centralizar o TextView e posicionar o Button no canto inferior direito.
0 <?xml version="1.0" encoding="utf-8"?> 1 <FrameLayout xmlns:android="http://schemas.android.com/apk/res/android" 2 android:background="#ffffff" 3 android:id="@+id/frameLayout1" 4 android:layout_width="fill_parent" 5 android:layout_height="fill_parent" > 6 <TextView 7 android:text="TextView" 8 android:id="@+id/textView1" 9 android:layout_width="wrap_content" 10 android:layout_height="wrap_content" 11 android:layout_gravity="center"> 12 </TextView> 13 <Button 14 android:text="Button" 15 android:id="@+id/button1" 16 android:layout_width="wrap_content" 17 android:layout_height="wrap_content" 18 android:layout_gravity="right|bottom"> 19 </Button> 20 </FrameLayout> Na linha 11 estamos informando que o TextView deve ser centralizado no formulrio, para isso informamos que layout_gravity possui o valor center. J o boto associamos right com bottom para alinhar o boto no canto inferior direito.
Figura 166 - Dois objetos configurados

Se voc preferir fazer a configurao por XML ento utilize o intellisense conforme imagem abaixo:
Figura 167 - Intellisense do Eclipse com opes de Gravity Caso queira fazer a configurao pela interface (editor grfico) ento ative a aba de propriedade, para isso clique com o boto direito do mouse sobre o boto e escolha a opo Show in | Properties conforme figura abaixo.
Figura 168 - Ativando a aba de propriedades Veja que a aba propriedades dever ser exibida na parte inferior, vamos arrastar ela para o lado esquerdo do IDE. Agora selecione o boto novamente e veja que a aba Properties dever exibir todas as propriedades do objeto, redimensione as colunas de acordo com a sua necessidade. Localize a propriedade layout_gravity conforme figura abaixo.
150
Figura 169 - Propriedade do boto Clique na propriedade e abra o editor conforme figura abaixo.
Figura 170 - Acessando editor da propriedade Gravity
Figura 171 - Valores possveis para a propriedade Gravity Agora vamos testar nosso formulrio em outros layouts, vamos redimensionar a tela para ver, altere as propriedades do editor para poder simular.
151
Figura 172 - Landscape Na figura acima temos o mesmo formulrio (Figura 166) porem com a opo Landscape ativada. No importa qual configurao de lauyout o boto sempre estar sendo exibido no canto inferior direito e o TextView no centro da tela. LinearLayout At o momento usamos em nossos exemplos sem abordar o gerenciador de layout LinearLayout com orientao vertical. LinearLayout permite organizar os componentes em uma linha vertical ou horizontal, essa orientao deve ser informada durante a programao. Vamos demonstrar um exemplo, veja o XML abaixo.
0 <?xml version="1.0" encoding="utf-8"?> 1 <LinearLayout 2 xmlns:android="http://schemas.android.com/apk/res/android" 3 android:orientation="vertical" 4 android:layout_width="match_parent" 5 android:layout_height="match_parent" 6 android:background="#ffffff"> 7 <TextView 8 android:text="TextView" 9 android:id="@+id/textView1" 10 android:layout_width="wrap_content" 11 android:layout_height="wrap_content" 12 android:textColor="#000000"> 13 </TextView> 14 <EditText 15 android:layout_width="match_parent" 16 android:layout_height="wrap_content" 17 android:id="@+id/editText1"> 18 </EditText> 19 </LinearLayout> Na linha 3 estamos definindo que a orientao dos componentes ser feita na vertical, ou seja, um abaixo do outro conforme podemos ver na imagem abaixo.
152
Figura 173 - LinearLayout com orientao vertical Essa orientao tima quando temos que exibir um texto seguido de um Grid ou List. Vamos agora ver como fica a orientao horizontal, para isso altere a linha 3 conforme XML abaixo.
0 <?xml version="1.0" encoding="utf-8"?> 1 <LinearLayout 2 xmlns:android="http://schemas.android.com/apk/res/android" 3 android:orientation="horizontal" 4 android:layout_width="match_parent" 5 android:layout_height="match_parent" 6 android:background="#ffffff"> 7 <TextView 8 android:text="TextView" 9 android:id="@+id/textView1" 10 android:layout_width="wrap_content" 11 android:layout_height="wrap_content" 12 android:textColor="#000000"> 13 </TextView> 14 <EditText 15 android:layout_width="match_parent" 16 android:layout_height="wrap_content" 17 android:id="@+id/editText1"> 18 </EditText> 19 </LinearLayout> O resultado exibido na imagem abaixo.
Figura 174 - LinearLayout com orientao horizontal Esse tipo de orientao timo para exibir um texto seguido de um componente de uma nica linha.
TableLayout
TableLayout posiciona controles em linhas e colunas, como se estivesse usando uma tabela no Word. Para orientar na construo a API exige que voc crie TableRow no qual os objetos so adicionados.
0 1 2 3 4 5 6 7
<?xml version="1.0" encoding="utf-8"?> <TableLayout xmlns:android="http://schemas.android.com/apk/res/android" android:layout_width="fill_parent" android:layout_height="fill_parent" android:background="#ffffff" android:stretchColumns="1"> <TableRow> <TextView
153
8 android:text="Posicao [0,0]" 9 android:padding="3dip" /> 10 <TextView 11 android:text="Posicao [0,1]" 12 android:gravity="right" 13 android:padding="3dip" /> 14 </TableRow> 15 16 <TableRow> 17 <TextView 18 android:text="Posicao [1,0]" 19 android:padding="3dip" /> 20 <TextView 21 android:text="Posicao [1,1]" 22 android:gravity="right" 23 android:padding="3dip" /> 24 </TableRow> 25 </TableLayout> Da linha 6 at a linha 14 estamos definindo a primeira ROW que ter duas colunas com dois TextView, j na linha 16 estamos iniciando uma segunda ROW tambm com dois objetos. O interessante que posso ter uma linha com duas mais ou menos colunas que as outras.
Figura 175 - TableLayout com duas linhas e duas colunas
Figura 176 - TableLayout com primeira linha com duas colunas e com segunda linha com trs colunas
RelativeLayout
RelativeLayout organiza os componentes baseado na configurao individual de sua posio referente ao Gerenciador de Layout (parent) ou outros controles. Desta forma quando um controle recebe alguma alterao de posio ou de dimenses os demais controles se reorganizam.
0 <?xml version="1.0" encoding="utf-8"?> 1 <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android" 2 android:layout_width="fill_parent" 3 android:layout_height="wrap_content" 4 android:background="#ffffff" 5 android:padding="10px" > 6 <TextView 7 android:text="Digite: " 8 android:id="@+id/label" 9 android:textColor="#000000" 10 android:layout_width="fill_parent" 11 android:layout_height="wrap_content" 12 android:layout_alignParentTop="true" 13 android:layout_alignRight="@+id/txtEntry"> 14 </TextView> 15 <EditText 16 android:layout_width="fill_parent" 17 android:id="@+id/txtEntry" 18 android:layout_height="wrap_content" 19 android:layout_below="@+id/label" 20 android:layout_centerHorizontal="true">
21 </EditText> 22 <Button android:id="@+id/btnOk" 23 android:layout_width="wrap_content" 24 android:layout_height="wrap_content" 25 android:text="OK" 26 android:layout_below="@+id/txtEntry" 27 android:layout_alignRight="@+id/txtEntry"> 28 </Button> 29 <Button 30 android:id="@+id/btnCancelar" 31 android:layout_width="wrap_content" 32 android:layout_height="wrap_content" 33 android:text="Cancelar" 34 android:layout_alignBaseline="@+id/btnOk" 35 android:layout_alignBottom="@+id/btnOk" 36 android:layout_toLeftOf="@+id/btnOk"> 37 </Button> 38 </RelativeLayout> Na linha 12 estou alinhado o TextView no topo do gerenciador de layout e estou associando na linha 13 este controle com um EditText que ainda no foi comentado. Na horizontal este TextView dever preencher todo o espao.
Na linha 20 estou forando o EditText a assumir toda a linha horizontal. Resta agora posicionar dois botes, o boto btnOK dever ser exibido alinhado a direita (em relao ao EditText) e abaixo conforme linhas 26 e 27. J nas linhas 34 35 estou alinhado o boto btnCancel com o btnOk pela base inferior e a esquerda do btnOK. O resultado pode ser visto nas imagens abaixo.
Figura 177 - Layout em Landscape
Figura 178 - Layout em Portrait
Criando Interfaces Eficientes

Android UI Tookit oferece vrios gerenciadores de layouts que so fceis de se usar, e na maioria das vezes voc precisar de usar somente um gerenciador dado a caracterstica da interface que queira desenvolver. Alterar as caractersticas bsicas no a forma mais eficiente de se criar interfaces flexveis para a plataforma Android, por exemplo o uso do abusivo de vrios Gerenciadores LinearLayout em uma interface pode sobrecarregar o processamento que gasta recursos na inicializao da interface. Vamos considerar um exemplo simples exposto no site oficial da plataforma Android, trata-se de um formulrio com uma imagem alinhada a esquerda e dois textos conforme modelo baixo.
Figura 179 - Laytou proposto (Android, 2011) Para produzir este layout o XML utilizado descrito abaixo.
<?xml version="1.0" encoding="utf-8"?>

155
1 <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" 2 android:layout_width="fill_parent" 3 android:layout_height="?android:attr/listPreferredItemHeight" 4 android:background="#ffffff" 5 android:padding="6dip"> 6 <ImageView 7 android:id="@+id/icon" 8 9 android:layout_width="wrap_content" 10 android:layout_height="fill_parent" 11 android:layout_marginRight="6dip" 12 android:src="@drawable/icon" /> 13 <LinearLayout 14 android:orientation="vertical" 15 android:layout_width="0dip" 16 android:layout_weight="1" 17 android:layout_height="fill_parent" 18 android:background="#ff0011"> 19 20 <TextView 21 android:layout_width="fill_parent" 22 android:layout_height="0dip" 23 android:layout_weight="1" 24 android:background="#222222" 25 android:gravity="center_vertical" 26 android:text="Primeiro TextView" /> 27 <TextView 28 android:layout_width="fill_parent" 29 android:layout_height="0dip" 30 android:layout_weight="1" 31 android:singleLine="true" 32 android:text="Outro TextView" /> 33 </LinearLayout> 34 </LinearLayout> Temos dois LinearLayouts no exemplo acima, o mais geral controla a rea branca da imagem baixo, sua orientao horizontal, dentro deste LinearLayout encontramos um ImageView a esquerda e a direita um outro LinearLayout, este segundo LinearLayout possui uma orientao vertical e controla a rea preta e vermelha no qual adicionamos dois TextViews.
Figura 180 - Layout formado por dois gerenciadores Esse layout funciona, mas pode ser um desperdcio se voc instanci-lo cada item da lista de um ListView. O mesmo layout pode ser rescrito usando um nico gerenciador de layout, para este exemplo o portal oficial da plataforma indica o uso do RelativeLayout, ser muito mais rpido instanciar um nico gerenciador de layout por elemento da lista (lembre-se que um layout pode ser usado como item em colees). Segue o mesmo layout utilizando RelativeLayout.
0 <?xml version="1.0" encoding="utf-8"?> 1 <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android" 2 android:layout_width="fill_parent" 3 android:layout_height="?android:attr/listPreferredItemHeight" 4 android:background="#ffffff" 5 android:padding="6dip">

6 <ImageView 7 android:id="@+id/icon" 8 android:layout_width="wrap_content" 9 android:layout_height="fill_parent" 10 android:layout_alignParentTop="true" 11 android:layout_alignParentBottom="true" 12 android:layout_marginRight="6dip" 13 android:src="@drawable/icon" /> 14 <TextView 15 android:id="@+id/secondLine" 16 android:layout_width="fill_parent" 17 android:layout_height="26dip" 18 android:layout_toRightOf="@id/icon" 19 android:layout_alignParentBottom="true" 20 android:layout_alignParentRight="true" 21 android:background="#ff0000" 22 android:singleLine="true" 23 android:ellipsize="marquee" 24 android:text="Outro TextView" /> 25 <TextView 26 android:layout_width="fill_parent" 27 android:layout_height="wrap_content" 28 android:layout_toRightOf="@id/icon" 29 android:layout_alignParentRight="true" 30 android:layout_alignParentTop="true" 31 android:layout_above="@id/secondLine" 32 android:layout_alignWithParentIfMissing="true" 33 android:background="#000000" 34 android:gravity="center_vertical" 35 android:text="Primeiro TextView" /> 36 </RelativeLayout> Com apenas um gerenciador de layout foi possvel construir a mesma interface, associando os elementos com RelativeLayout. O resultado pode ser visto abaixo.
Figura 181 - Mesmo layout porem com RelativeLayout
157
8
8 Persistncia de Dados
.
Introduo
Uma aplicao voltada ao pblico corporativo geralmente requer que dados sejam armazenados em algum repositrio para posterior acesso. Um conjunto de dados organizados em bytes podem ser armazenados em arquivos gerenciados pela prpria aplicao, um exemplo o padro de armazenamento .cvs, .txt, .xml. Outra forma utilizar APIs desenvolvidas por terceiros para gerenciar tais dados, desta forma a aplicao no controla o mecanismo de persistncia dos bits no arquivo e nem sua formatao, tais mecanismos esto escritos na API que est sendo utilizada. Neste captulo vamos abordar o uso destas tecnologias para persistir dados e posteriormente a consulta dos mesos.
Persistncia em Arquivos
// TODO: fazer
SQLite
Algumas plataformas as APIs mencionadas na introduo deste captulo levam a servios oferecidos por outros programas, a complexidade deste ambiente garante que a informao no vai estar acoplada ao programa e que vrios outros programas podem acessar estas informaes. Tais sistemas de gerenciamento de dados so chamados de Sistemas de Gerenciamento de Banco de Dados orientado a servios. Outras APIs como a API do SQLite funciona como um Sistema de Gerenciamento de Banco de Dados embutido, onde no encontramos um servio disponibilizado por uma mquina (remota ou local), a prpria API faz as transaes com um arquivo utilizado para armazenamento de dentro da sua aplicao. A vantagem de um banco de dados embutido sua simplicidade que requer menos do ambiente no qual est sendo executado, no preciso instalar nada, no preciso configurar nenhum sistema operacional, ou seja, muito simples. Se voc est acostumado a utilizar sistemas de gerenciamento de dados baseado em servios, tais como Oracle, Microsoft SqlServer, etc.. pode estar pensando o porque a simplicidade a pea chave e porque perdemos a robustez do ambiente voltado a servios. A resposta simples: problemas simples requerem solues simples.
158
O SQLite se prope a trabalhar em diversos ambientes e plataformas, ele no est focado em uma plataforma especfica ou em um produto, logo no pode se prender a requisitos complexos. Se voc trabalha com java ou .net est acostumado a criar uma conexo, criar um comando e executar, porem aqui na plataforma Android trabalhamos de forma diferente, construmos classes de apoio que sero utilizados durante a necessidade de desenvolvimento. A principal classe de apoio deve estender de SQLiteOpenHelper, dentro dessa classe podemos sobrescrever o mtodo onCreate() que nos permite criar tabelas, visto que no temos um cliente de SGBD para gerenciar o banco atravs de scripts.
0 public class DictionaryOpenHelper extends SQLiteOpenHelper { 1 2 private static final int DATABASE_VERSION = 2; 3 private static final String DICTIONARY_TABLE_NAME = "dictionary"; 4 private static final String DICTIONARY_TABLE_CREATE = "CREATE TABLE " + DICTIONARY_TABLE_NAME + " (id INTEGER, name TEXT);"; 5 6 DictionaryOpenHelper(Context context) { 7 super(context, DATABASE_NAME, null, DATABASE_VERSION); 8 } 9 10 @Override 11 public void onCreate(SQLiteDatabase db) { 12 db.execSQL(DICTIONARY_TABLE_CREATE); 13 } 14 } Durante a execuo da sua aplicao voc dever criar instancias da classe DictionaryOpenHelper, ao fazer isso sua classe dever chamar o construtor da super-classe (linha 7), na super-classe SQLiteOpenHelper (interno) ser chamado o mtodo onCreate() no qual a tabela ser criada se necessrio.
Para realizar a leitura ou escrita basta chamar resgatar o Database atravs dos mtodos getWritableDatabase() e getRedabeDatabase(), tais mtodos esto descritos abaixo: getWritebleDatabase(): Abre ou cria uma conexo com o database que ser usado para escrita, quando o banco aberto com sucesso, o banco de dados armazenado em cache, desta forma voc pode chamar este mtodo sempre que quiser escrever na base de dados. getReadableDatabase(): Da mesma forma que o getWritableDatabase() este mtodo abre a conexo com a fonte de dados porem prepara somente para a leitura. Para realizar operaes de consultas simples voc deve usar o mtodo query(), este mtodo aceita vrios parmetros que permitem as consultas simples, normalmente voc est acostumado a criar strings com clusulas SQLs e disparar contra um SGBD, ento a princpio o uso do mtodo query() possa ser um pouco estranho, mas voc logo ir se acostumar. Para consultas mais avanadas como por exemplo o uso de aliases vamos utilizar uma classe chamada SQLiteQueryBuilder para construir nossas consultas.
159
160
A1
Apndice 1 Habilitando Depurao
Configurar o device para aceitar depurao por USB.
Introduo
Ao entrar no Device, temos que configurar ele para permitir a depurao. Essa configurao habilita um Listener que permite aos componentes do Android SDK se comuniquem com o Device. A configurao simples: 1- No menu principal acesse os aplicativos (no device 2- Selecione o aplicativo Settings conforme Figura 183; 3- Agora acesse as configuraes dos Aplicativos (Figura 184); 4- Entre nas configuraes de Desenvolvimento (Figura 185); 5- E habilite a depurao por USB (Figura 186). ) na Figura 182;
161
Figura 182 rea principal
Figura 183 Settings
Figura 184 Acessando Configurao de Aplicativos
Figura 185 Configuraes de Desenvolvimento
Figura 186 Habilitando USB Debugging
162
A2
Apndice 2 Perspectiva no Eclipse
Introduo
163
A3
Apndice 3 Show View in Perspective
Introduo
164
165
166
167

Apostila Android

Enviado por

Dados do documento

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

Apostila Android

Enviado por

Direitos autorais:

Formatos disponíveis

ATENO: EST EM DESENVOLVIMENTO, TEM MUITOS ERROS

Qualquer coisa manda e-mail para: wellington@aied.com.br

Desenvolvendo Aplicaes com Java para Android

Desenvolvendo Aplicaes Mveis com SuperWaba

Desenvolvendo Aplicaes com Java para Android

Desenvolvendo Aplicaes com Java para Android

Desenvolvendo Aplicaes com Java para Android

Desenvolvendo Aplicaes com Java para Android

Desenvolvendo Aplicaes com Java para Android

Figura 3 - Android em um Notebook

Como est Estruturado o Livro

Desenvolvendo Aplicaes com Java para Android

JDK J2SE 6.0

Desenvolvendo Aplicaes com Java para Android

Desenvolvendo Aplicaes com Java para Android

Desenvolvendo Aplicaes com Java para Android

Desenvolvendo Aplicaes com Java para Android

Desenvolvendo Aplicaes com Java para Android

Figura 15 - cone na rea de trabalho

Instalando a SDK do Android

Desenvolvendo Aplicaes com Java para Android

Figura 18 - Java SE Development Kit no detectado

Desenvolvendo Aplicaes com Java para Android

Desenvolvendo Aplicaes com Java para Android

Desenvolvendo Aplicaes com Java para Android

Figura 26 - Lista de arquivos Atualizados Prximo passo configurar o Eclipse.

Desenvolvendo Aplicaes com Java para Android

Desenvolvendo Aplicaes com Java para Android

Desenvolvendo Aplicaes com Java para Android

Desenvolvendo Aplicaes com Java para Android

Desenvolvendo Aplicaes com Java para Android

Desenvolvendo Aplicaes com Java para Android

Desenvolvendo Aplicaes com Java para Android

Desenvolvendo Aplicaes com Java para Android

Desenvolvendo Aplicaes com Java para Android

Desenvolvendo Aplicaes com Java para Android

Figura 51 - Configurao do Emulador Device_2_2 Clique em Create AVD.

Desenvolvendo Aplicaes com Java para Android

Figura 52 - Lista de Emuladores Pronto, emulador criado.

Desenvolvendo Aplicaes com Java para Android

Desenvolvendo Aplicaes com Java para Android

Figura 58 - Aplicao HelloWorld executando

Desenvolvendo Aplicaes com Java para Android

Desenvolvendo Aplicaes com Java para Android

Figura 60 - Atualizando as APIs Clique em Install Selected, e aguarde.

Depurando uma Aplicao pelo Device

Desenvolvendo Aplicaes com Java para Android

Desenvolvendo Aplicaes com Java para Android

Desenvolvendo Aplicaes com Java para Android

Desenvolvendo Aplicaes com Java para Android

Desenvolvendo Aplicaes com Java para Android

Desenvolvendo Aplicaes com Java para Android

Desenvolvendo Aplicaes com Java para Android

Variveis, Operadores e Estruturas de Controle

Tipos de Dados Primitivos

Desenvolvendo Aplicaes com Java para Android

long 8 Tipos de Dados Inteiros

Desenvolvendo Aplicaes com Java para Android

float total; float preco;

Desenvolvendo Aplicaes com Java para Android

// comentrio de uma linha // tudo aps as duas barras considerado comentrio

/* comentrio de mltiplas linhas */

/** comentrio de documentao que tambm * podem ter mltiplas linhas */

Desenvolvendo Aplicaes com Java para Android

especificador_de_acesso lista_de_argumentos ) { /codigo / }