Curso de Java básico para Iniciantes Usando Eclipse

1

Curso de Java básico para Iniciantes Usando Eclipse

1. O que é o curso? 2. O que é Java e como funciona? 3. Instalando e Aprontando o Java 4. Instalando e Aprontando o Eclipse 5. Classe Pessoa (atributos e construtor) 6. Classe Pessoa (métodos get e set) 7. Usando o Scrapbook do Eclipse 8. JUnit no Eclipse - parte 1 9. JUnit no Eclipse - parte 2 10. "Test-First Development" no Eclipse 11. Classe Livro 12. Adicionando Pessoa à Classe Livro 13. Listas e ArrayList 14. Iniciando a Classe Biblioteca 15. Criando os primeiros métodos na Classe Biblioteca 16. Criando os métodos de Empréstimo e Devolução 17. Evoluindo os métodos de Empréstimo e Devolução 18. Finalizando a Classe Biblioteca 19. Criando o método main e o arquivo JAR

O que é o curso?

Características

O Curso Java para iniciantes (usando Eclipse) é para você que está se iniciando no mercado e precisa aprender Java de uma forma rápida e objetiva.

Para iniciar o curso, você precisa saber lógica de programação, pois não ensinamos isso aqui.

No mais, é simplesmente querer aprender e gostar de pesquisar.

Este curso não tem duração pré-determinada. Você define o seu ritmo e em consequência a duração do curso. O material está todo disponível aqui nestas páginas, portanto basta seguir os links e as instruções.

O material, como diz o título, é destinado a iniciantes, ensinamos o básico para que você fique confortável ao prosseguir nos estudos mais avançados.

Para incentivar a interatividade, foi criada uma lista de discussão. Os estudantes interessados, podem se inscrever e trocar informações entre si e com instrutores voluntários (assim que estes estiverem disponíveis).

Por que Java com Eclipse?

Existem muitas razões para se aprender a programar em Java. Mas por que usando Eplipse?

2

Não existem dados estatísticos sobre isso, mas na prática, podemos considerar o Eclipse e suas variações,como sendo a IDE padrão de mercado para Java.

Portanto, aprendendo a usar esta IDE, você já vai se preparando para um próximo ingresso no mercado de trabalho.

Seguem algumas das características do Eclipse que o tornaram um sucesso de mercado:

• O Eclipse provê uma série de facilidades que permitem escrever programas Java de forma muito mais rápida e simples do que usando um editor de texto comum. Isso significa que você pode usar mais do seu tempo aprendendo Java do que digitando e olhando a documentação.

• O debugger e o scrapbook permitem olhar "dentro" de um programa Java em execução. Isso permite que você "veja" os objetos e entenda como o Java funciona "por trás dos panos".

• O Eclipse provê suporte total para as práticas de desenvolvimento ágil, tais como: TDD (test-driven development) e refatoração. Isso permite que você aprenda estas técnicas enquanto aprende Java.

• Além de tudo isso, existem plugins que permitem disponibilizar facilidades ainda mais específicas que facilitam o desenvolvimento para plataformas diversas.

Assuntos abordados no Curso

• O Básico do Eclipse para desenvolvimento de aplicações Java. • O Básico do Java e Programação Orientada a Objetos. • O Básico do TDD (Test-driven development) e testes unitários no Eclipse.

Origens do Curso

Não, esta não é uma ideia original. Este curso foi baseado no trabalho original de Mark Dexter datada de 2007, chamada "Eclipse and Java for Total Beginners", disponível aqui.

Em 2008, o Ronaldo Caldas fez uma tradução dos screencasts para Português. Eles podem ser encontrados aqui.

A questão é que screencasts são mais difíceis de produzir e manter atualizados. Minha intenção com esta versão Web do curso composta por páginas estáticas em Português, seja mais fácil de incrementar e manter atualizada no futuro.

Espero que vocês gostem do curso e tirem proveito dele.

Tudo de bom!

MarcRic

3

Visão geral de Java

História

Tudo começou em Dezembro de 1990. O engenheiro Patrick Naughton, da Sun Microsystems, estava insatisfeito com as ferramentas e APIs do C++ da Sun, estando disposto a passar a usar a plataforma Next, a Sun ofereceu a ele a chance de trabalhar numa nova tecnologia, tendo início assim, o projeto "Stealth".

Em 1991, o projeto foi renomeado para "Green", tendo James Gosling e Mike Sheridan se juntado a Patrick e junto com outros engenheiros da Sun iniciaram os trabalhos. O objetivo deste projeto, era antecipar a "próxima onda" tecnológica do mundo digital. Eles acreditavam que em breve os equipamentos e eletrodomésticos de uso diário estariam interagindo mais e mais com os usuários, e para dar suporte a isso precisava ser criada uma plataforma de desenvolvimento inteiramente nova, e principalmente: orientada a objetos.

Para implementar esta nova plataforma, eles precisavam de uma linguagem de programação que atendesse a dois principais requisitos: ser compacta e ser confiável. Bill Joy, um dos fundadores da Sun, já havia proposto uma nova linguagem de programação, combinando as linguagens "Mesa" e "C", e chegou a sugerir que os engenheiros da Sun produzissem um ambiente orientado a objetos, baseado no C++.

Gosling, tentou modificar e estender o C++, mas acabou abandonando a ideia, em favor de uma linguagem inteiramente nova. Esta linguagem foi inicialmente batizada de Oak, que quer dizer carvalho, em alusão a uma árvore que Gosling podia observar quando olhava pela janela do seu escritório.

Durante meses, 16 pessoas trabalharam num escritório de Sand Hill Road, no Menlo Park, num protótipo para demonstrar a ideia na prática, e em Setembro de 1992, eles estavam prontos para demonstrar partes desta nova plataforma, incluindo o sistema operacional "Green", a linguagem Oak, as bibliotecas e o hardware. O protótipo se chamava *7 (leia-se "StarSeven"), um controle remoto com uma interface gráfica touchscreen para Televisões interativas.

4

A interface gráfica possuía um sistema de ajuda interativa apresentado por um personagem virtual, um mascote criado por Joe Palrang que hoje é amplamente conhecido no mundo Java, o Duke. O *7 tinha a habilidade de controlar diversos dispositivos e aplicações. Tudo isso foi criado usando a linguagem Oak. Infelizmente, apesar de todos os esforços, esta tecnologia acabou se mostrando muito avançada para a indústria de TV a cabo daquela época.

Por outro lado, a internet vinha se desenvolvendo paralelamente num ritmo muito acelerado.

No início de Julho de 1994, depois de três dias de brainstorming com John Gage, diretor de ciência da Sun, Gosling, Joy, Naughton, Wayne Rosing, e Eric Schmidt, resolveram redirecionar o projeto para a internet, ficando Gosling incumbido de liderar o projeto.

Eles vislumbraram que com o advento de navegadores com capacidade gráfica como o Mosaic, a internet estava no caminho para evoluir no mesmo caminho de mídia altamente interativo que eles haviam proposto para a industria de TV a cabo. A título de protótipo, Naughton escreveu um pequeno navegador chamado WebRunner (devido ao filme Blade Runner), mais tarde renomeado para HotJava.

A primeira demonstração pública do WebRunner foi feita por John Gage e James Gosling no evento "Technology Entertainment Design Conference" em Monterey, California no início de 1995.

Este evento pode ser considerado um marco, pois não havia nada de muito interessante numa nova linguagem apresentando uma página contendo um texto e imagens num clone do Mosaic. A apresentação se arrastava sem chamar a atenção da audiência. Porém dois demos fizeram a audiência vibrar:

Num deles, Gosling moveu o mouse sobre a imagem 3D de uma molécula fazendo com que ela se movesse nos 3 eixos, conquistada a atenção da plateia, Gosling foi além, apresentando um algoritmo animado de ordenação onde três conjuntos de linhas horizontais de tamanhos randômicos eram ordenados da menor para a maior simplesmente movendo as linhas para cima e para baixo. A plateia nunca tinha visto nada além de imagens estáticas num navegador. Aquilo era realmente revolucionário!

Mais tarde, no início de 1995, a linguagem foi rebatizada para Java, depois que uma pesquisa de patentes revelou que o nome Oak havia sido registrado pela empresa Oak Technology. A primeira versão pública do Java foi anunciada em Maio de 1995 no evento "SunWord". Era o Java 1.0a2 com o navegador HotJava.

5

No mesmo evento a Netscape anunciou que os seus navegadores iriam incluir suporte a Java. Em Janeiro de 1996 a Sun criou o grupo JavaSoft para desenvolver a tecnologia Java.

Nesta nova versão da linguagem, Gosling, procurou implementar uma máquina virtual e uma linguagem usando notações semelhantes a linguagem C/C++. Com a promessa de se escrever uma vez e executar em qualquer lugar - "Write Once, Run Anywhere" (WORA) - gerando executáveis sem custo para as plataformas mais populares.

Rapidamente, a maioria dos navegadores Web incorporaram a habilidade de executar applets Java nas páginas Web, fazendo com que Java se tornasse popular ainda mais rápido. Com o advento do Java 2 (lançado inicialmente como J2SE 1.2 no início de 1999), versões diferentes e customizadas começaram a surgir (J2EE, J2ME), em 2006 por questões de marketing a Sun renomeou as versões mais novas de J2 para: Java EE, Java ME e Java SE respectivamente.

Em novembro de 2006, a Sun começou a liberar a maior parte do Java como software de código aberto "open source", sob os termos da licença pública GNU. Este processo terminou em Maio de 2007, tendo ficado toda a parte essencial do Java disponível nos termos de software livre e código aberto, exceto uma pequena parte sobre a qual a Sun não detém o copyright.

Logo após a aquisição da Sun pela Oracle em 2010, a Oracle se auto proclamou como sendo a "Guardiã da tecnologia Java" com um compromisso incansável de promover uma comunidade participativa e transparente.

Características

A linguagem Java, é apenas um dos componentes da plataforma Java.

O termo "Java" na verdade se refere a um grupo de produtos e especificações da Sun Microsystems, atualmente uma subsidiária da Oracle, que juntos constituem uma plataforma de desenvolvimento de software e que permitem a instalação e uso destes softwares em vários ambientes (Sistemas Operacionais e Hardwares) diferentes.

6

Java é usado num espectro muito amplo de plataformas: desde dispositivos dedicados e telefones celulares, passando por computadores pessoais, indo até servidores Web e Aplicações Corporativas.

A Linguagem Java, é uma mistura de muitas outras, tais como: C, C++, LISP, Objective-C, MESA, Modula3, entre outras. Sintaticamente, ela se assemelha muito a C e C++, porém é muito mais simples que estas, devido ao fato de ser fortemente tipada. Abaixo, citamos algumas outras características da linguagem Java que seus desenvolvedores buscavam quando do seu desenvolvimento.

• Simples • Portável • Orientada a Objetos • Interpretada • Distribuída • Alta Performance • Robusta • Multi Tarefa • Segura • Dinâmica • De Arquitetura Neutra

Como Funciona?

A execução de um programa java se dá em três ações distintas:

1. Crie um programa fonte em Java. Um programa fonte, contém texto escrito na linguagem de programação Java. Um programa Java, pode ser entendido por você e outros programadores. Qualquer editor de texto pode ser usado para criar e editar programas fonte.

2. Compile o programa fonte em um arquivo "bytecode". O compilador Java "javac"", traduz o seu programa fonte em instruções que a Máquina Virtual Java (JVM)) pode entender. O compilador armazena estas instruções num arquivo "bytecode".

3. Execute o programa contido no arquivo "bytecode". A Máquina Virtual Java, implementa o interpretador Java "java", Este interpretador, processa o arquivo "bytecode" gerando instruções equivalentes de forma que a plataforma em uso (Sistema Operacional e Hardware) consiga entender e executar estas instruções.

7

Instalando e Aprontando o Java

Primeiros passos:

Em primeiro lugar precisamos ter disponível a plataforma de desenvolvimento Java.

Para tal, devemos acessar o site da Oracle que disponibiliza as várias opções para Download aqui.

No caso de desenvolvimento em Java, o recomendado é o JDK Se você não tiver problemas de espaço nem de performance, opte pelo Java EE que é o que se encontra em ambientes corporativos. Se tiver algum tipo de limitação, opte pelo Java puro, que é menor e mais simples.

Instalando o Java 7

Vamos escolher o Java EE, e na página seguinte escolher aquele apropriado para a nossa plataforma de trabalho.

Marcar o botão de aceite do acordo de licença.

E efetuar o download.

8

O processo de instalação é bem simples, mas se precisar de detalhes, acesse aqui.

Agora você tem não só o JDK instalado, como também o GlassFish, um "Servidor de Aplicações" compatível com Java EE 6.

O próximo passo, é verificar se a instalação está correta. No meu caso, como já havia uma versão anterior de JDK instalada, o uso do comando "set java", permite verificar para onde a variável de ambiente "JAVA_HOME" aponta.

Após a instalação, devemos portanto, atualizar (ou criar se você nunca tiver instalado um JDK antes) a variável de ambiente "JAVA_HOME".

9

Uma forma simples de testar se está tudo certo com a instalação, é tentar obter a versão do compilador Java disponível com o comando "javac -version".

Tudo certo? Então podemos prosseguir...

10

Instalando e Aprontando o Eclipse

O que é o Eclipse?

O Eclipse na verdade é muito mais que uma IDE. Pode-se dizer que é uma plataforma de desenvolvimento, não só atendendo várias linguagens de programação, como também vários objetivos, totalmente configurável e customizável.

O Eclipse é composto por um ambiente integrado de desenvolvimento (IDE) e um sistema de plugins que pode ser estendido pelos usuários. Ele foi quase totalmente escrito em Java, porém o seu sucesso se deve em boa parte ao fato de ser genérico o suficiente para atender várias outras linguagens tais como: Ada, C, C++, COBOL, Perl, PHP, Python, R, Ruby (incluindo a framework Ruby on Rails), Scala, Clojure, Groovy e Scheme.

Um pouco de História:

As origens do Eclipse remontam ao VisualAge da IBM (uma IDE da década de 80), escrita em Smalltalk. Na década de 90, o VisualAge se tornou a IDE padrão para os ambientes de desenvolvimento da IBM.

No início dos anos 2000 surge o VisualAge for Java, e logo depois o VisualAge Micro Edition, que suportava o desenvolvimento de aplicações Java multi plataformas. Foi na verdade a reimplementação desta IDE em Java. Esta versão do VisualAge evoluiu para a plataforma de desenvolvimento Eclipse que conhecemos hoje.

Em Novembro de 2001, foi formado um consórcio para o futuro desenvolvimento do Eclipse como um projeto de código aberto. Em Janeiro de 2004 a Eclipse Foundation foi criada.

Em Junho de 2004, a primeira versão oficial do Eclipse (a 3.0), foi lançada, e desde então, sempre no final de Junho de cada ano novas versões dos projetos da plataforma Eclipse são lançadas:

11

Release Data Versão Projetos

Juno 27 de Junho 2012 4.2 Juno projects

Indigo 22 de Junho 2011 3.7 Indigo projects

Helios 23 de Junho 2010 3.6 Helios projects

Galileo 24 de Junho 2009 3.5 Galileo projects

Ganymede 25 de Junho 2008 3.4 Ganymede projects

Europa 29 de Junho 2007 3.3 Europa projects

Callisto 30 de Junho 2006 3.2 Callisto projects

Eclipse 3.1 28 de Junho 2005 3.1

Eclipse 3.0 21 de Junho 2004 3.0

Primeiros passos:

Agora que já temos o JDK instalado, vamos instalar a nossa IDE de trabalho, o Eclipse.

Aqui também, se você não tiver problemas de espaço nem de performance, opte pelo Eclipse for Java EE que é o que se encontra em ambientes corporativos. Se tiver algum tipo de limitação, opte pelo Eclipse Clássico, que é menor e mais simples.

A versão mais recente do Eclipse quando da criação desta página é a Indigo.

Instalando o Eclipse Indigo 3.7

Vamos escolher o Eclipse for Java EE, na página seguinte escolher aquele apropriado para a nossa plataforma de trabalho, e efetuar o download.

12

O processo de instalação é extremamente simples, basta descompactar o arquivo baixado e criar um atalho na sua área de trabalho para o executável "eclipse.exe".

O diretório padrão criado ao descompactar o arquivo ZIP é o "eclipse" se você já tiver outra versão do Eclipse instalada (que foi o meu caso), basta renomear o diretório para "eclipseEE" por exemplo:

Ao tentar acionar o Eclipse pela primeira vez, provavelmente você vai receber uma mensagem de erro, acusando uma falha ao tentar criar a máquina virtual.

Isso se deve ao fato de o arquivo de configuração padrão não vir com a localização da máquina virtual Java especificada.

Para defini-la, basta editar o arquivo "eclipse.ini", e adicionar as seguintes linhas:

-vm D:\glassfish3\jdk7\bin\javaw.exe

Sendo a segunda, é claro, adaptada para a localização da JDK na dua máquina.

O arquivo "eclipse.ini", possui várias outras configurações. Depois do tratamento, ele deve ter aproximadamente este conteúdo:

-startup plugins/org.eclipse.equinox.launcher_1.2.0.v2 0110502.jar --launcher.library plugins/org.eclipse.equinox.launcher.win32.wi n32.x86_1.1.100.v20110502 -product org.eclipse.epp.package.jee.product --launcher.defaultAction openFile --launcher.XXMaxPermSize 256M -vm D:\glassfish3\jdk7\bin\javaw.exe

13

-showsplash org.eclipse.platform --launcher.XXMaxPermSize 256m --launcher.defaultAction openFile -vmargs -Dosgi.requiredJavaVersion=1.5 -Xms40m -Xmx512m

Agora sim, ao chamar o Eclipse, a tela de carga deve surgir e logo em seguida, uma janela solicitando a escolha de um diretório para a área de trabalho (onde os seus projetos vão ser armazenados). Você pode aceitar a sugestão padrão ou escolher uma outra localização ao seu gosto.

Depois disso, a tela de carga exibe o restante do processo de inicialização do Eclipse.

E na sequência, você deve visualizar a tela de "Bem Vindo" do Eclipse.

Você pode fechar esta tela, e a qualquer momento, abri-la novamente usando: Help » Welcome, e explorar todo o seu conteúdo com calma.

14


15

Aula 01 - Objetos e Classes Java

Objetos

Objetos no mundo real são facilmente identificáveis: conceitualmente falando, pessoas, carros, bicicletas, gatos, são todos objetos, com características diferentes. No universo da programação, objetos são uma coleção de peças de software que possuem estado e comportamento relacionados. Neste contexto, Classes são plantas baixas ou protótipos, a partir das quais, os objetos são criados.

Classes Java

Uma Classe Java que pode servir de base para criar e atuar em objetos do tipo "bicicleta".

public class Bicicleta { // A Classe Bicicleta possui tres atributos public int cadencia; public int marcha; public int velocidade; // A Classe Bicicleta possui um construtor public Bicicleta(int cadenciaInicial, int veloc idadeInicial, int marchaInicial) { marcha = marchaInicial; cadencia = cadenciaInicial; velocidade = velocidadeInicial; } // A Classe Bicicleta possui quatro metodos public void setCadencia(int novoValor) { cadencia = novoValor; } public void setMarcha(int novoValor) { marcha = novoValor; } public void acionaFreio(int diminui) { velocidade -= diminui; } public void aumentaVelocidade(int aumenta) { velocidade += aumenta; } }

O que é um projeto Java?

Mas em bom Português, o que é um projeto Java? Podemos dizer a grosso modo, que um projeto Java, nada mais é do que uma estrutura de diretórios, onde são armazenados os códigos fonte na linguagem Java (envolvendo as funcionalidades propriamente ditas e os seus testes) e os bytecodes resultantes do processo de compilação.

Ao final do processo de desenvolvimento de uma aplicação Java, esta estrutura de diretórios é empacotada num arquivo ZIP (podem ter extensões diferentes, mas são arquivos no formato ZIP). Este pacote é então copiado para um diretório específico do servidor de aplicações, e lá é

16

descompactado, sendo os bytecodes direcionados para pastas específicas do servidor, ficando então a aplicação Java disponível para uso. Este é o processo conhecido como "deploy de uma aplicação".

A estrutura de um projeto Java, vai depender da Framework de desenvolvimento adotada e da complexidade do Projeto. Existem vários exemplos de acordo com diferentes objetivos e níveis de complexidade aqui. Mas para a grande maioria dos casos, mesmo em empresas de grande porte, uma estrutura simples de projeto, contemplando uma única aplicação com várias funcionalidades é suficiente. Para as nossas necessidades durante o curso, vamos adotar uma estrutura mais simples, assim:

src/ Contendo os códigos fonte e demais recursos necessários a Aplicação

test/ Contendo os códigos fonte e demais recursos necessários aos Testes da Aplicação

O que é um pacote dentro de um projeto Java?

Os nossos arquivos fonte, estarão portanto localizados em algum lugar nesta estrutura de diretórios, agrupados por tipo e funcionalidade. Os vários tipos de arquivos Java que compõem um projeto se relacionam. Para que estes arquivos se localizem uns aos outros, existe uma estrutura de nomenclatura que associa nomes qualificados à localização física dos arquivos. Então, o diretório que agrupa arquivos de um determinado tipo ou funcionalidade num projeto Java, é chamado de "pacote" (package).

Então, por exemplo: um programador, criando uma funcionalidade chamada "tutorial" para um domínio chamado "java.iniciantes.com", deverá identificar o diretório onde estão localizados os arquivos que compõem a aplicação com o seguinte nome de pacote: "com.iniciantes.java.tutorial"

Este nome de pacote, se traduz fisicamente na seguinte estrutura de diretórios: "src\com\iniciantes\java\tutorial"

Considerando o que foi visto acima, segue um exemplo de uso de um objeto da classe Bicicleta:

package com.iniciantes.java.tutorial; public class Controle { public void movimentaMagrela() { Bicicleta magrela = new Bicicleta(10,10,10) ; magrela.aumentaVelocidade(15); magrela.setMarcha(4); magrela.acionaFreio(20); magrela.setMarcha(2); magrela.setCadencia(5); } }

17

A nossa Aplicação

Durante o curso, estaremos desenvolvendo uma aplicação simples para controle de empréstimo de livros de uma "biblioteca entre amigos". A aplicação vai registrar livros, amigos e quais amigos pediram emprestado quais livros.

Para tal, vamos usar 3 classes:

• Pessoa: nome e numero máximo de livros que esta pessoa pode pedir emprestado. • Livro : título, autor, pessoa com quem está emprestado. • Biblioteca: lista de livros e lista de pessoas que podem emprestar livros.

Criando um projeto Java no Eclipse

Para o nosso curso, vamos criar um projeto chamado: JavaParaIniciantes.

Passo a passo:

Após abrir o Eclipse, vamos usar: File » New » Java Project

Repare que se você, assim como eu, instalou e configurou a versão mais atual do JDK, pode ocorrer algum tipo de incompatibilidade.

18

Se for este o caso, escolha uma versão mais antiga que seja compatível.

Agora, vamos aceitar as opções default e finalizar.

Pronto! O seu projeto Java deve estar criado.

Mas repare entretanto, que há um problema reportado na aba "Problems", na parte de baixo da tela

19

Podemos sempre tentar resolver os problemas usando: Botão direito do mouse sobre a linha do problema » Quick Fix

Mas neste caso, isto não vai ser suficiente.

Vamos fazer da seguinte forma: Botão direito do mouse sobre o projeto » Properties

20

Na opção "Java Build Path", na aba "Libraries", vamos selecionar a JRE disponível e acionar o botão "Edit"

Vamos escolher a versão adequada do ambiente de execução.

E acionar o botão "OK"

Com isso o problema reportado deve desaparecer.

A estrutura de diretórios que dá suporte ao nosso projeto neste momento é a seguinte:

21

Criando um pacote no Eclipse

Com o projeto criado, devemos agora criar o pacote que irá agrupar seus componentes.

Passo a passo:

Vamos selecionar a pasta "src" e usar: Botão direito do mouse » New » Package

Seguindo o padrão de nomenclatura anteriormente citado, vamos criar o pacote com o seguinte nome:

"com.iniciantes.java.tutorial"

22

Agora nós temos o pacote criado:

Criando uma Classe no Eclipse

Vamos agora criar a primeira Classe do nosso pacote.

Passo a passo:

Vamos selecionar o pacote "com.iniciantes.java.tutorial" e usar: Botão direito do mouse » New » Class

Seguindo a descrição da nossa aplicação, vamos começar pela Classe Pessoa.

23

Agora nós temos a Classe criada:

A linha identificada com o número 1 registra o nome do pacote onde a classe está localizada. A linha identificada com o número 2 registra a assinatura da Classe.

A estrutura de diretórios que dá suporte ao nosso projeto neste momento é a seguinte:

Com a classe pessoa criada, o próximo passo é: definir os atributos que vão caracterizar os objetos pertencentes a esta Classe.

Repare o asterisco antes do nome do arquivo. Ele indica que o arquivo foi alterado e ainda não foi salvo. A linha identificada com o número 1 é um comentário simples (uma única linha). As linhas identificadas com os números 2 e 4 são as definições dos atributos propriamente ditos. O grupo de linhas identificado com o número 3 é um comentário composto de várias linhas.

24

Tipos de dados primitivos do Java:

Tipo Descrição boolean Pode assumir o valor true ou o valor false

char Caractere em notação Unicode de 16 bits. Serve para a armazenagem de dados alfanuméricos. Também pode ser usado como um dado inteiro com valores na faixa entre 0 e 65535.

byte Inteiro de 8 bits em notação de complemento de dois. Pode assumir valores entre -27=-128 e 27-1=127.

short Inteiro de 16 bits em notação de complemento de dois. Os valores possíveis cobrem a faixa de -2-15=-32.768 a 215-1=32.767

int Inteiro de 32 bits em notação de complemento de dois. Pode assumir valores entre -231=2.147.483.648 e 231-1=2.147.483.647.

long Inteiro de 64 bits em notação de complemento de dois. Pode assumir valores entre -263 e 263-1.

float Representa números em notação de ponto flutuante normalizada em precisão simples de 32 bits em conformidade com a norma IEEE 754-1985. O menor valor positivo representável por esse tipo é 1.40239846e-46 e o maior é 3.40282347e+38

double Representa números em notação de ponto flutuante normalizada em precisão dupla de 64 bits em conformidade com a norma IEEE 754-1985. O menor valor positivo representável é 4.94065645841246544e-324 e o maior é 1.7976931348623157e+308

A Classe String:

java.lang.String Representa Strings de caracteres.

Uma das vantagens do uso do Eclipse, é que ele avalia o que é digitado dinamicamente, e quando o arquivo é salvo ele exibe erros e alertas na aba "Problems".

Neste caso, repare que as palavras em Português estão sublinhadas em vermelho. Isto ocorre porque o dicionário padrão é em Inglês. Além disso, existem dois alertas sobre a criação de variáveis que não estão sendo utilizadas.

Sobre os alertas, eles desaparecerão na sequência, quando forem criados métodos que usam as variáveis criadas.

Já sobre o dicionário, vamos aprender a configurá-lo para Português.

Para isso, o primeiro passo é conseguir um dicionário em Português no formato adequado. Na verdade, é simples, um arquivo texto com uma palavra por linha. Eu tenho uma versão deste arquivo que você pode baixar daqui.

25

Descompacte o arquivo e coloque-o no diretório onde o Eclipse foi instalado.

Agora use: Window » Preferences

Na tela seguinte, selecione: General » Editors » Text Editors » Spelling

Altere "Platform dictionary" para "none". E em "User defined dictionary" localize e selecione o arquivo que você baixou.

Com isso, basta fechar e abrir novamente o arquivo, que a maioria das palavras será reconhecida. Aquelas que não forem, devem ser incluídas no dicionário, assim:

26

Continuando com a nossa Classe, é hora de criar o método construtor.

O método construtor de uma Classe é chamado sempre que uma nova instância de objeto daquela classe é criada. Um método construtor é igual a qualquer método público, exceto que ele usa o mesmo nome da Classe e não pode retornar nenhum valor. Usando uma outra Classe Pessoa como exemplo, um método Construtor ficaria assim:

public class Pessoa { private String primeiroNome; private String ultimoNome; private String endereco; private String nomeDeUsuario; // O metodo construtor public Pessoa() { } }

Neste exemplo, o método construtor não faz nada, mas no nosso caso, vamos usá-lo para inicializar os objetos do tipo "Pessoa" criados com valores default.

Outra vantagem do uso do Eclipse, é que ele pode completar o código que digitamos. Por exemplo: se digitamos um abre chaves "{" e teclamos "Enter", ele cria e identa um fecha chaves "}" automaticamente.

Outra forma de completar o código no Eclipse, é digitar parte de um nome definido e usar: "CTRL" + "Espaço". Esta ação apresenta uma lista de nomes definidos que começam com a parte digitada. Bastando escolher da lista o item desejado e teclar "Enter".

27

Isso completa a nossa primeira aula. Tendo criado a Classe Pessoa, com seus atributos e método Construtor. Os alertas serão resolvidos na próxima aula quando os métodos get e set para os atributos da Classe forem criados.


28

Aula 02 - Classes e Métodos Java

Sobre a interface do Eclipse

Vamos começar esta segunda aula conhecendo um pouco mais sobre a interface do Eclipse.

A referência oficial para a Interface com o usuário do Eclipse está aqui.

De volta ao Eclipse, a primeira coisa que notamos é que ele tem memória! Abre exatamente da forma que o deixamos da última vez.

Quando o Eclipse é carregado, ele nos apresenta uma espécie de bancada de trabalho (Workbench), Esta bancada é composta de algumas áreas que vamos explorar um pouco na sequência, mas a principal delas, claro, é a do Editor.

Um duplo click na aba do arquivo sendo editado, maximiza a janela do Editor fazendo-a ocupar toda a área da bancada de trabalho. Vamos fazer isso, e comentar um pouco mais sobre as facilidades que o editor de código do Eclipse oferece.

29

Além daquelas mais básicas como colorir o código, separando as palavras chave da linguagem do restante do código, identificando os comentários, os símbolos e outras partes do código, edentação e formatação automática. Existem vários auxílios visuais, como por exemplo: indicador de que o arquivo foi alterado mas não foi salvo, indicadores de erros e alertas, indicadores de fechamento de blocos, e muitos outros.

Para mudar as configurações do Eclipse em geral, normalmente existe mais de uma opção. Como exemplo, vamos alterar uma característica do editor que vai ser necessária, principalmente quando for necessário usar o modo de debug. Exibir o número das linhas do código.

Para isso, temos duas opções:

1. Da barra de Menu, "Window" » "Preferences..." 2. Na opção "General" » "Editors" » "Text Editors", marque o checkbox "Show line

numbers".

1. CTRL+3 2. Digite: "line numbers" 3. ENTER

Usando esta última opção, temos:

30

E como resultado:

Áreas de trabalho da bancada do Eclipse

Vamos agora explorar um pouco as demais áreas do Workbench do Eclipse.

A primeira informação importante a respeito destas áreas, é que o conteúdo, formato e localização delas, não é fixo. Você pode customizar tudo ao seu gosto.

Vamos elencá-las aqui, usando a configuração default.

1. Área de topo 1 - Barra de Menu 2. Área de topo 2 - Barra de Ferramentas 3. Área esquerda com o "Visualizador de Projeto ou Pacote" 4. Área direita com ao "Lista de tarefas e a Visão macro da Classe" 5. Área de baixo com vária abas informativas 6. Área de rodapé com informações complementares

Cada uma destas áreas pode ser configurada para exibir uma ou mais Visões (Views), a distribuição destas áreas e os seus respectivos conteúdos, vão compor uma Perspectiva

31

(Perspective) do Eclipse para uma tarefa específica. A perspectiva Java por exemplo, visa facilitar o processo de codificação. Uma outra grande vantagem do Eclipse, é que você pode criar e salvar novas perspectivas totalmente personalizadas.

A título de exemplo, vamos abrir a perspectiva "Java Browsing" e observar como são distribuídas as views que a compõem pela área de trabalho do Eclipse.

Minha sugestão é que você procure alterar esta perspectiva de forma semelhante (não necessariamente igual), ao exemplo abaixo, e salvá-la com o seu nome para uso futuro.

32

De volta ao Java

Convém falar sobre alguns símbolos especiais da linguagem Java.

• ; - delimitador de comando • { e } - delimitadores de bloco • ( e ) - delimitadores de parâmetros de métodos • // - início de comentário • /* e */ - delimitadores de bloco de comentário • = - operador de atribuição

Métodos Java

Falando em termos de orientação a Objetos, um método representa uma operação num objeto em particular. Sendo um objeto uma instância de uma Classe, quando definimos uma Classe, definimos os seus atributos através de variáveis e seu comportamento através de métodos.

Aqui está um exemplo de uma típica declaração de método em Java:

public double calculaVoo(double envergadura, in t motores, double tamanho, double tonelagem) { // faz o calculo complicado aqui. return 10L; }

Para declarar um método, os únicos elementos necessários são: o tipo de retorno, o nome do método, um par de parênteses e um corpo delimitado por chaves.

De maneira mais formal, seguem todos os elementos que podem vir a compor a declaração de um método em Java:

1. Modificadores tais como: public , private , e outros que você verá no futuro. 2. O tipo de dado retornado pelo método, ou void se o método não retornar um valor. 3. O nome do método seguindo as regras de nomes de campos, mas com uma convenção

um pouco diferente. 4. A lista de parâmetros separados por vírgula, precedidos dos seus respectivos tipos de

dado, delimitados por parênteses, () . Se não houver parâmetros, deve-se usar, os parenteses vazios.

5. Uma lista de possíveis exceções, que você também verá no futuro.

33

6. O corpo do método, com todo o seu código delimitado por chaves, incluindo a declaração de variáveis locais ao método.

De volta ao nosso projeto

Voltando à nossa Classe Pessoa, já havíamos criado um método construtor para inicializar as instâncias do objeto Pessoa com valores default. Vamos agora tratar dos métodos "getter" e "setter" responsáveis por expor as características do objeto instanciado. Não vamos discutir aqui a questão de expor a implementação de um objeto para outras Classes em relação aos princípios de Orientação a Objetos.

Métodos "getter" e "setter" são usados para recuperar e manipular variáveis privadas de uma Classe diferente. Um método "getter", como o nome sugere, recupera o atributo de mesmo nome. Um método "setter" permite atribuir um valor ao atributo de mesmo nome.

Vamos começar pelo método "getNome", assim:

Repare que imediatamente após salvar o código alterado, os conteúdos das Views "Package Explorer" e "Problems" são alterados de acordo. Na primeira, a referência ao novo método surge. E na segunda, a referência ao alerta de falta de uso do atributo "nome" desaparece, enquanto a referência ao mesmo tipo de alerta para o atributo "maxLivros" permanece.

Para criar o próximo método, vamos usar a facilidade de "completar o código" que o Eclipse nos dá, assim:

34

Com esta combinação, o Eclipse nos dá uma matriz para a criação de um método público. Na sequência, usando a tecla TAB, vamos alterando os próximos elementos da matriz fornecida, assim:

Então depois de preencher: o tipo de retorno, o nome, o parâmetro e teclar TAB mais uma vez, estamos prontos para digitar o código que vai compor o método.

Neste caso, uma simples atribuição.

Apesar de ter sido usada a facilidade de "completar código" do Eclipse, estes dois primeiros métodos foram criados praticamente de forma manual. No entanto, O Eclipse possui uma facilidade ainda maior neste sentido, podendo gerar os métodos "getters" e "setters" automaticamente para nós. Vamos fazer uso desta facilidade para gerar os métodos para o atributo "maxLivros", assim:

35

Na Janela apresentada, selecionamos os campos para os quais queremos gerar os métodos e acionamos o botão "OK".

E o Eclipse gera os métodos para nós, assim:

36

Existem algumas diferenças entre os métodos get e set que nós criamos e estes últimos criados automaticamente pelo Eclipse: a primeira é o tipo de dado sendo tratado. A segunda é o uso do qualificador "this", que indica a instância corrente do objeto, que é um comportamento padrão, por isso não o usamos anteriormente. Outro detalhe é que o eclipse usa como nome da variável do parâmetro do método "set", o mesmo nome da variável da classe, assim:

Revisando, uma Classe Java deve conter Atributos e Métodos, definindo suas Características e seu Comportamento:

1. Campos de dados 2. Métodos Construtores para criar objetos 3. Métodos getters e setters para trabalhar as características do objeto 4. Métodos de comportamento. A lógica de negócio propriamente dita

O Eclipse nos ajuda

O Package Explorer do Eclipse, permite uma visão esquemática da Classe, com seus elementos.

Reparem que se for retirado o qualificador "this" na instrução de atribuição do método "setMaxLivros", um alerta é exibido.

37

Isto se deve ao fato de o Java não saber mais se se trata de um atributo da classe ou uma variável local. Para evitar este problema, podemos manter o nome da variável do parâmetro igual ao do atributo retornando o qualificador "this", ou mudar o nome da variável do parâmetro.

Para manter o padrão usado no atributo "nome", vamos usar esta segunda opção.

A esta altura, você deve ter a classe construída desta forma:

package com.iniciantes.java.tutorial; public class Pessoa { // Atributos private String nome; // nome da pessoa /* Número máximo de Livros que * uma pessoa pode pedir emprestado */ private int maxLivros; // Construtor public Pessoa() { nome = "Nome Desconhecido"; maxLivros = 3; } // Métodos public String getNome() { return nome; }

38

public void setNome(String outroNome) { nome = outroNome; } public int getMaxLivros() { return maxLivros; } public void setMaxLivros(int outroValor) { maxLivros = outroValor; } } view raw pessoa01.java This Gist brought to you by GitHub .

Caso exista alguma diferença, volte e faça uma revisão nas duas primeiras aulas.


39

Aula 03 - Usando o Scrapbook do Eclipse

O que é o Scrapbook?

Nesta aula, vamos explorar um pouco as características da Classe Pessoa usando o Scrapbook do Eclipse. O Scrapbook é uma "joia" escondida no Eclipse, principalmente para os iniciantes em Java, pois permite explorar as instruções Java de forma interativa e ver o que cada uma delas faz internamente.

Usando o Scrapbook

Para usar o Scrapbook, devemos criar uma página de Scrapbook, que permite executar comandos e expressões Java sem precisar criar um programa para isso.

Para criar uma página de Scrapbook, vamos fazer assim: Botão direito do mouse sobre o projeto » New » Other.

Na janela de "Wizards" que é apresentada, selecione: Java » Java Run/Debug » Scrapbook Page » Next.

40

Especifique um nome para a página e acione o botão Finish.

Com isso, devemos ter a nova página de Scrapbook aberta, assim:

Codificando e Inspecionando

Vamos começar é claro, com algo bem simples:

Temos algumas alternativas para inspecionar o resultado de expressões como esta. Vamos começar, usando o menu da seguinte forma: Selecione o texto da expressão desejada:

41

Em seguida: » Run » Inspect.

Que deve apresentar o seguinte resultado:

Os espaços entre os argumentos e operadores nas expressões Java, não tem significado para o compilador, portanto, "2+2" e "2 + 2", são tratados exatamente da mesma forma.

Vamos ver agora um trecho de código sendo inspecionado:

42


Ocorre que eu esqueci de encerrar o comando "a = a * 10" com um ";". Vamos corrigir isso e tentar novamente.

Uma outra forma de verificar o resultado de expressões é: » Run » Display.


43

Vamos agora inspecionar uma expressão Java para criar um objeto do tipo Date "new java.util.Date()", assim:

Reparem que: na janela de inspeção, temos acesso a todos os atributos do objeto criado.

Já para avaliar trechos de código Java, devemos usar a opção Run » Execute, ou então:

O resultado da execução do comando ou comandos, é exibido na aba "Console".

Nota: Certifique-se de deixar a instrução que você deseja inspecionar sem o ";" no final.

44

Experiências com a classe Pessoa

Já sabendo como usar o Scrapbook, precisamos agora usá-lo com a classe Pessoa criada anteriormente. Observando o Package Explorer, podemos ver que a página do nosso Scrapbook, está fora do pacote da Classe Pessoa.

Existem vários pacotes criados por terceiros disponíveis para uma aplicação Java. Sendo assim, nada impede de alguém ter criado uma outra Classe chamada Pessoa com características e comportamentos diferentes dos da Classe que nós criamos. A criação e uso de pacotes facilita a identificação de classe de mesmo nome mas com características diferentes.

No nosso caso, quando mencionamos no nosso projeto a Classe "Pessoa", o compilador entende: "com.iniciantes.java.tutorial.Pessoa".

Para que possamos portanto, fazer experiências com a Classe Pessoa no nosso Scrapbook, devemos importar o pacote onde está localizada a Classe.

Vamos aproveitar e conhecer os botões da barra de ferramentas usados nas operações do Scrapbook:

Usando o botão de configuração dos imports, vamos importar para o nosso Scrapbook o pacote da classe Pessoa.

45

Agora, o nosso Scrapbook entende que: quando mencionamos a Classe "Pessoa", estamos na verdade nos referindo a: "com.iniciantes.java.tutorial.Pessoa".

Isso feito, podemos começar nossas experiências com a Classe Pessoa.

Vamos começar, criando um objeto (instância da Classe) do tipo "Pessoa", com a seguinte instrução:

Pessoa p = new Pessoa();

Sendo:

• "Pessoa": o tipo do objeto que está sendo criado (a Classe do objeto). • "p" : a variável que vai representar o objeto (instância da Classe) que está sendo criado. • "new" : palavra reservada de Java que instrui o compilador a criar um novo objeto do

tipo desejado. • "Pessoa()": método construtor da Classe, a ser usado na criação do objeto.

Para permitir a inspeção desta instrução, precisamos complementar este trecho de código com a simples menção da variável "p", para que observemos o seu conteúdo, assim:

46

Podemos observar que: uma vez criado, o objeto assume as características definidas no método construtor padrão da Classe Pessoa, ou seja:

• maxLivros = 3 • nome = "Nome Desconhecido"

Agora, se digitamos um ponto ao lado da variável "p", que no momento representa um objeto do tipo Pessoa, podemos ver todos os métodos definidos para este objeto, assim:

Alguns destes métodos, foram criados por nós, como se pode ver no exemplo. Mas por outro lado, podemos ver vários outros que não foram criados por nós. De onde eles surgiram?

Na verdade, aqui podemos observar pela primeira vez um exemplo de "herança" em Java. Todas as Classes Java, são subclasses da Classe "Object", portanto, todas as Classes Java, herdam os métodos da Classe "Object". A Classe "Object" pode ser considerada o "Poderoso Chefão" das Classes, ou "a Classe de todas as Classes".

A forma de chamar um método de um objeto em Java, é usando o ".", logo depois do nome da variável que representa o objeto. Quando usamos o "." no Eclipse, ele nos abre uma lista dos métodos conhecidos daquele objeto para que possamos escolher o que desejamos usar no momento.

Vamos começar nossas experiências, mudando o nome padrão do objeto pessoa que acabamos de criar, assim:

Reparem que o Eclipse possui um sistema de ajuda instantâneo, e já indica o tipo de dado que precisa ser passado para o método.

Prosseguindo temos o seguinte:

47

Inspecionando...

Vamos prosseguir, alterando o número máximo de Livros para 9, assim:

A título de aprendizado, vamos ver uma outra forma de exibir o resultado, usando um método "get" e usando a opção de "Exibir o Resultado da Avaliação", assim:

Ainda a título de aprendizado, vamos simular um erro e observar como o Eclipse lida com isso.

Vamos supor que ao tentar verificar o resultado da aplicação do método "getMaxLivros()", tenhamos esquecido de digitar o "()", assim:

48

O Eclipse nos ajuda com mensagens de erro bem claras, assim:

Neste caso, informando que: devido à ausência do (), o nome "getMaxLivros", foi entendido como sendo um possível nome de variável, e como não existe nenhuma variável definida com este nome, o compilador simplesmente não consegue "resolver" este nome.

O Eclipse portanto, não só ajuda evitando que você precise digitar muita coisa, mas também ajuda quando ocorrem erros de digitação, como no exemplo acima.


49

Aula 04 - JUnit no Eclipse - parte 1

Testes de software

O assunto desta aula é sobre testes. Teste de software é um dos assuntos mais ricos e controversos que temos na área de de desenvolvimento de software e até no gerenciamento de projetos de software. Sendo assim, acabei por criar uma página específica para tratar deste assunto, de forma mais abrangente, indo além de Java e JUnit. Esta página, pode ser acessada aqui.

O que é o JUnit?

O JUnit é um framework de suporte a testes automatizados para a linguagem de programação Java. Ela tem sido importante na popularização do Test Driven Development (TDD) ou "Desenvolvimento Orientado a Testes".

Como funciona o JUnit?

Em termos de funcionamento, o JUnit é um programa usado para executar testes unitários em virtualmente qualquer aplicação. Os testes com JUnit são efetuados escrevendo "casos de teste" em Java, compilando estes casos de testes e executando as classes resultantes com o "JUnit Test Runner".

Obtendo o JUnit

O JUnit, pode ser obtido no site da JUnit.org. Mas na prática, no caso dos usuários do Eclipse, ele já vem disponível como um plugin, possuindo sua própria View, a qual podemos exibir usando: Window » Show View » Other, e na janela que se abre, selecionar Java » JUnit.

50

Mas o que são testes unitários afinal?

Testes Unitários constituem um processo de desenvolvimento de software onde a menor porção "testável" de uma aplicação, chamada unidade, é individual e independentemente verificada em relação ao comportamento dela esperado. Testes Unitários são em geral automatizados, mas podem ser feitos manualmente.

Testes Unitários envolvem apenas as características essenciais da unidade sob teste. Isso encoraja o desenvolvedor a poder alterar livremente a implementação de uma unidade buscando uma melhor performance por exemplo, sem se preocupar com uma possível interferência em outras unidades ou na aplicação como um todo.

Uma vez que todas as unidades de uma aplicação estiverem funcionando de forma satisfatória e sem erros, porções maiores da aplicação poderão ser avaliados na forma de testes integrados, depois com testes do sistema e finalmente com testes de aceitação. Os testes unitários são a base de todo o processo de testes.

Preparando o ambiente de Testes

O primeiro passo é definir onde no projeto vão ficar os nossos testes. A não ser que exista orientação do cliente em contrário, o normal, é que não desejamos incluir os nossos testes no pacote a ser entregue para deploy. Sendo assim, faz sentido armazenar as Classes de teste numa pasta diferente da usada para armazenar as Classes com o código da aplicação propriamente dito.

Observando a janela do "Package Explorer", podemos ver a localização da nossa Classe de negócio (Classe Pessoa).

Vamos então criar uma pasta no mesmo nível da pasta "src", com o nome "test". Vamos fazer da seguinte forma: Botão direito do mouse sobre o projeto » New » Source Folder

51

Na janela que se abre, digitar o nome da pasta ("test" neste caso) e acionar o botão "Finish".

Com isso, temos agora a seguinte estrutura:

Para manter a organização, vamos querer que as nossas Classes de teste fiquem sob os mesmos pacotes que as Classes sendo testadas. Sendo assim, vamos criar o mesmo pacote sob a pasta "test" que acabamos de criar.

Para isso, vamos selecionar a pasta "test".

Usar na barra de menu: File » New » Package, assim:

52

E na janela que se abre, digitar o mesmo nome de pacote usado na pasta "src", assim:

Obtendo:

Sobre o uso de Menus no Eclipse

Na maior parte das ações que efetuamos sobre itens de um projeto, podemos optar por usar...

A barra de menus sobre um item selecionado:

53

O menu flutuante, usando o botão direito do mouse, também sobre um item selecionado:

O nosso primeiro código de teste

Agora, estamos prontos para criar o nosso primeiro teste usando JUnit.

Para isso, vamos contar com a ajuda de uma facilidade do Eclipse. O Eclipse possui modelos de ajuda prontos (Wizards) para efetuar várias tarefas. Criar testes usando JUnit, é uma delas.

Usando o menu flutuante, vamos marcar o package que acabamos de criar e selecionar o Wizard: New » JUnit Test Case, assim:

54

Na janela que se abre, vamos digitar um nome para a nossa Classe de teste. Um padrão que pode e deve ser seguido aqui é: usar para o nome da Classe de teste, o nome da Classe sendo testada, seguido do sufixo "Test". Além disso, é necessário digitar o nome da Classe sendo testada. Teremos portanto, a tela assim:

A tela não exibe nenhum erro ou alerta. Tudo está certo, pois o JUnit 4 já está disponível nesta instalação. A título de aprendizado, vamos alterar a versão do JUnit para 3 e observar o que acontece:

55

Reparem que agora surge um alerta indicando que a Super Classe "TestCase" do JUnit não existe. Isso se deve ao fato de o pacote (JAR) do Junit 3 não estar configurado no "caminho de construção" (build path) do projeto. O "build path" indica a localização de todas as bibliotecas externas necessárias à compilação da aplicação. O JUnit é uma dessas bibliotecas externas, daí a necessidade de uma referência a ela constar no "build path".

Vamos ignorar isso no momento e seguir adiante com o botão "Next".

Na tela que se segue, podemos escolher os métodos para os quais vamos gerar código de teste. Não só métodos da Classe Pessoa, como também os métodos da Classe Object, da qual a Classe Pessoa herda. Vamos escolher no momento, o método construtor da Classe Pessoa e também os métodos "set", assim:

56

Ao acionar o botão "Finish", o eclipse abre uma outra janela, dando chance de resolver o problema detectado anteriormente, adicionado o JUnit 3 no "buid path". Vamos, mais uma vez, ignorar este problema selecionando a opção "Not now" e acionado o botão "OK".

O que nos leva a seguinte situação:

Como era de se esperar, a nossa classe de teste foi criada, porém surgem várias indicações de erro. Vamos analisar cada uma destas indicações:

1. No Package Explorer, podemos ver que o projeto como um todo, está marcado com erro, porque alguma parte dele está com erro. Neste caso, a classe "PessoaTest" dentro do pacote "com.iniciantes.java.tutorial" dentro da pasta "test".

2. Na janela de código, podemos ver a nossa Classe de teste com indicações de erro em toda linha que menciona recursos do JUnit, inclusive no "import".

3. Na aba de "Outline", podemos ver de forma esquemática onde ocorrem os erros no nosso código.

4. Na aba "Problems", temos acesso individualizado a cada linha de código causando problema, indicando sua localização exata.

Vamos então usar esta última área para aprender como resolver problemas no nosso código com a ajuda do Eclipse.

57

Começando pelo problema indicado da linha 3 (o import), vamos acionar a opção "Quick Fix", usando o botão direito do mouse sobre ele, assim:

Na janela que surge, selecionamos: "Fix project setup..."

E na janela seguinte: "Add JUnit 3 library to the build path"

O que faz com que os erros desapareçam, assim:

58

Reparem que o pacote JUnit 3 foi adicionado ao nosso projeto.

A opção "Quick Fix" do Eclipse oferece:

• Sugestões para corrigir erros de compilação • Implementa os ajustes selecionados automaticamente • Pode-se usar o botão direito do mouse ou o atalho CTRL-1 • O Quick Fix do Eclipse é o melhor amigo do desenvolvedor.

Para entender um pouco mais do que o Eclipse fez para corrigir o erro, vamos verificar o "buid path" do nosso projeto. Poderiamos usar: botão direito do mouse sobre o projeto » Properties. Mas desta vez, vamos usar um atalho: Selecione o projeto e use: Alt + Enter.

Na janela que se abre, selecionar: "Java Buid Path" e a aba "Libraries"

59

Podemos ver que o pacote do JUnit 3 foi adicionado ao "buid path".

Nós poderíamos obter o mesmo efeito, usando o botão "Add Library", localizando o pacote do JUnit 3 no nosso sistema de arquivos e selecionando-o.

Vamos examinar o código gerado linha a linha, e entendê-lo.

• 1 - Identificação do pacote da nossa Classe de teste • 3 - Import do pacote do JUnit para a Classe "TestCase" • 5 - Declaração da nossa Classe de teste "PessoaTest" estendendo a Classe "TestCase" do

JUnit • 7 - Declaração do método de teste para o método Construtor da Classe Pessoa • 11 - Declaração do método de teste para o método setNome da Classe Pessoa • 15 - Declaração do método de teste para o método setMaxLivros da Classe Pessoa

Sendo a nossa Classe "PessoaTest" uma Subclasse de "TestCase", podemos usar os métodos herdados desta última. No momento, todos os métodos de teste estão usando o método "fail", apenas para gerar um resultado padrão dizendo que o teste ainda não foi implementado.

Vamos executar os métodos de teste da forma que estão e ver o que acontece, assim:

60

Podemos observar na área inferior, na aba JUnit, o resultado da execução de todos os métodos de teste. Para cada um deles a mensagem já esperada de "Not yet implemented" é exibida.

O próximo passo, é modificar os métodos que foram criados automaticamente para efetivamente testar os métodos implementados na Classe Pessoa.


61

Aula 05 - JUnit no Eclipse - parte 2

JUnit Básico

Neste tópico vamos começar com um exemplo simples para ilustrar os conceitos básicos envolvidos nos testes com JUnit.

package com.iniciantes.java.tutorial; import junit.framework.TestCase; public class SimpleTest extends TestCase { public SimpleTest(String name) { super(name); } public void testSimpleTest() { int answer = 2; assertEquals((1+1), answer); } } view raw SimpleTest.java This Gist brought to you by GitHub .

Vamos analisar este exemplo linha a linha:

import junit.framework.*;

Como nós estamos usando recursos criados pela equipe do JUnit, precisamos importar as classes que desejarmos usar. A maioria reside no subdiretório "framework", daí a necessidade do comando import.

public class SimpleTest extends TestCase {

A nossa Classe de teste precisa definir seus próprios métodos para ter qualquer utilidade para nós. Sendo assim, ela estende a Classe "TestCase" a qual vai nos permitir criar nossos próprios métodos de teste.

public SimpleTest(String name) { super(name); }

Todo teste, recebe um nome para que quando observamos o resultado geral de todos os testes possamos distinguir qual teste gerou o erro se for o caso. O método construtor provê esta funcionalidade passando o parâmetro recebido para a Classe pai.

public void testSimpleTest() { int answer = 2; assertEquals((1+1), answer); }

Este é no momento o único teste constante do nosso "TestCase". Poderiam haver mais, tantos quantos você quisesse. Você pode ver que podemos definir variáveis e efetuar cálculos como qualquer outro programa Java.

62

public void testSimpleTest() { int answer = 2; assertEquals((1+1), answer); }

Vamos ver o resultado da execução deste teste, usando: botão direito do mouse sobre a Classe de teste » Run As » JUnit Test

Se alterarmos o valor da variável "answer" para algo diferente de "2" e executarmos o teste novamente, vamos obter um erro, assim:

Este teste simples, testa se 1+1 é igual ao valor de answer. Este é apenas um exemplo de teste extremamente simples.

63

Normalmente, o que desejamos é testar o resultado de algum método. Por exemplo, um método que remova todos os caracteres "a", de um String. Você pode testá-lo assim:

public void testStringStripFunction() { String expected = "bb" StringStripper stripper = new StringStripp er(); assertEquals(expected, stripper.stringStri p("aabaaaba")); }

O que pode fazer o "assertEquals" falhar se o método StringStripper não se comportar como esperado. Assim, podemos tentar corrigir o método e executar o teste novamente até que ele tenha sucesso.

De volta aos nossos testes

Voltando aos nossos testes, vamos começar, implementando um teste real para garantir que o método Construtor da Classe Pessoa esteja fazendo o que dele se espera. Vejamos o método Construtor:

public Pessoa() { nome = "Nome Desconhecido"; maxLivros = 3; }

Ele deve inicializar uma nova instância da Classe Pessoa com "Nome Desconhecido" para o atributo "nome" e "3" para o atributo "maxLivros". O que precisamos fazer é criar um método de teste que verifique se estes valores estão corretos.

Vamos usar alguns assistentes do Eclipse para nos ajudar a criar este teste, assim:

No método "testPessoa()" retiramos a chamada do método "fail" e digitamos a instrução "new" + CTRL + Espaço, o que nos apresenta o seguinte:

Selecionar a opção "create new object", o que leva ao seguinte:

Vamos agora alterar cada um dos parâmetros, usando a tecla TAB para navegar entre eles, o que nos leva ao seguinte:

64

Agora, temos definida uma instância "p1" da Classe Pessoa. Reparem no alerta à esquerda da linha 8. Ele indica que a variável "p1" não está sendo usada.

Se uma nova instância da Classe Pessoa foi criada, o seu método Construtor foi executado. Vamos agora complementar o nosso teste verificando se os valores dos atributos estão com os valores esperados, usando o método "assertEquals" do JUnit, assim:

E preenchendo os parâmetros, assim:

O que nos leva ao seguinte:

Para completar, vamos corrigir o erro indicado colocando o ";" ao final da linha, e adotar o mesmo procedimento para o atributo "maxLivros". O que nos leva ao seguinte:

O que estamos fazendo aqui é: verificando com o método "assertEquals" se os atributos estão com os valores esperados depois que o método Construtor da Classe Pessoa foi executado.

65

Mas de onde vem o método "assertEquals" ? Ele vem da Classe "TestCase" que é a Super Classe da nossa Classe "PessoaTest". E por que este método não pode ser chamado da seguinte forma:

PessoaTest pt = new PessoaTest(); pt.assertEquals(...);

A resposta é que o método "assertEquals" é um método estático (cuja declaração deve conter o modificador static). Um método estático, não pertence a nenhuma instância de uma Classe, e sim à Classe como um todo.

A sintaxe de uso de um método estático, é a seguinte: <Classe>.<método>, o que nos levaria ao seguinte: PessoaTest.assertEquals(...), sendo que o nome da Classe é opcional dentro da mesma Classe. O Eclipse nos ajuda a diferenciar os métodos estáticos, exibindo-os em itálico.

Vamos agora executar os testes novamente, usando o botão "Rerun Test":

E ver o que acontece... O que vai nos levar ao seguinte:

Reparem que foram executados 3 de 3 testes. Destes, 2 falharam e um foi bem sucedido. Aquele sobre o método Construtor que acabamos de implementar. Ele foi bem sucedido, pois os valores dos atributos da instância "p1" da Classe Pessoa, foram atribuídos pelo método Construtor conforme o esperado.

Usando os mesmos passos, vamos implementar o método de teste para o método "setNome" da nossa Classe Pessoa, obtendo o seguinte:

Executando os testes novamente, vamos obter o seguinte:

66

Agora, 2 dos testes foram bem sucedidos (os que implementamos), apenas um continua falhando. Vamos cuidar dele em seguida.

Mais uma vez, usando os mesmos passos, vamos implementar o método de teste para o método "setMaxLivros" da nossa Classe Pessoa. A título de aprendizado, vamos forçar um erro, usando um nome de variável não definido. Teremos o seguinte:

Como a variável não existe, o assistente do Eclipse não consegue nos ajudar.

Vamos agora corrigir o erro, obtendo o seguinte:

Executando os testes novamente, vamos ter:

Mais uma vez, a título de aprendizado, vamos forçar um erro no teste do método "setNome", e ver o que acontece:

E executando os testes novamente...

67

Reparem no botão "Compare Actual With Expected Test Result" à direita. Se acionado, ele exibe uma janela com as diferenças entre o que era esperado pelo seu teste e o que foi obtido do método sendo testado, assim:

Agora, basta voltar o teste à sua condição anterior, onde todos os métodos passam.


68

Aula 06 - "Test-First Development" no Eclipse

TFD ? TDD ? BDD ?

• TFD - Test-First Development • TDD - Test-Driven Development • BDD - Behavior-Driven Development

Qualquer destas siglas, representa basicamente a metodologia de começar o desenvolvimento, não pelo código da funcionalidade propriamente dito, mas sim pela codificação dos testes (ou comportamentos) que vão garantir que a funcionalidade codificada faz o que dela se espera.

É como se a codificação dos testes (ou comportamentos) representasse a especificação em código da funcionalidade. E a codificação da funcionalidade vai então atender exatamente a especificação. Simples assim!

No nosso caso, vamos escrever nosso método de teste unitário antes de escrever o método sendo testado. O Eclipse possui um excelente suporte ao uso de TDD.

O método toString()

Nossa próxima tarefa vai ser sobrepor o método "toString". Vamos revisar algumas de suas características:

• Ele é herdado da Classe Object • Ele retorna a representação em String de um Objeto • Ele é normalmente criado para todas as Classes

Vamos voltar à nossa página de Scrapbook e ver o que este método faz:

Preparando o código assim:

69

Que uma vez inspecionado, nos apresenta o seguinte:

Reparem que a nossa Classe Pessoa, está ali identificada (id=47). Mas de forma geral, estas informações não são muito úteis. Isso se dá, porque este método é herdado da Classe Object, e a Classe Object não "conhece" nada sobre a nossa Classe Pessoa.

Em geral, quando criamos uma nova Classe, gostaríamos de modificar o método "toString" para melhor representar os objetos da nossa Classe.

O que vamos fazer, é chamado de "Override" de método, ou seja, vamos "escrever por cima" de um método já existente. Não estaremos criando um método novo, mas sim aplicando um novo comportamento à um método já existente que a nossa Classe está herdando de Outra.

Aplicando o TDD

Neste ponto, poderíamos simplesmente abrir a nossa Classe Pessoa e começar a escrever código novo. No entanto, vamos aplicar a metodologia de TDD, e para isso, vamos recapitular o que esta metodologia propõe:

1. Pense sobre o que o método deve fazer. 2. Escreva um caso de teste que vai testar este método. 3. Escreva o novo método. 4. Teste o novo método. 5. Quando o teste passar, teremos concluído.

De volta à nossa Classe de teste, vamos escrever um método para testar a nossa versão do método "toString". Mas cumprindo o item 1 da metodologia, vamos pensar em: qual o comportamento desejado para "o nosso" método "toString" ?

1 - Um objetivo prático, seria que o nosso método "toString" retornasse o nome e o número de livros de uma determinada pessoa da seguinte forma:

Romer Simpson (9 livros)

2 - Vamos escrever um caso de teste para isso na Classe "PessoaTest". Estaremos usando as facilidades já vistas anteriormente, obtendo o seguinte resultado:

70

Este método por si só, serve como documentação do nosso método "toString". Se alguém alterar o comportamento do nosso método "toString" e esquecer de alterar este teste, ele vai falhar, indicando que a documentação não está mais em conformidade com a implementação.

3 - Vamos agora escrever a nossa versão do método "toString"na Classe "Pessoa". Estaremos mais uma vez usando as facilidades já vistas anteriormente, obtendo o seguinte resultado:

Ao salvar as alterações, é exibida uma tela de alerta indicando que uma parte do código em memória não pode ser atualizado, assim:

Isso ocorre porque o Scrapbook usa o modo Debug do Eclipse, e neste modo as alterações feitas no código quando salvas, não substituem automaticamente o que está em memória.

4 - O próximo passo, é executar os testes e ver o que acontece.

Acionando o botão de comparação dos resultados, podemos ver o seguinte:

71

Fica claro que não definimos corretamente o retorno do método.

5 - A última etapa é na verdade, um ciclo, onde refatoramos o método até que o teste passe. Vamos corrigir o retorno do método, ficando assim:

Testando novamente, teremos o seguinte:

Todos os testes passaram, e era isso que pretendíamos. Observem que existe um alerta na Classe Pessoa, indicando que o nosso método "toString" se sobrepõe ao método original, assim:

Fazer uso diretamente dos nomes dos atributos no lugar dos respectivos métodos get, desta forma:

Pode nos causar restrições no futuro. Imaginem a seguinte situação: alguém resolve separar o atributo nome nos atributos primeiroNome e sobreNome.

Da forma que fizemos, isso iria requerer uma alteração no nosso método toString da Classe Pessoa. Já se tivéssemos usado os métodos get desta forma:

72

Bastaria alterar o método "getNome" para:

return primeiroNome + " " + sobreNome;

Mantendo nosso método toString livre de alterações.

Vamos portanto, preferir sempre o uso dos métodos get evitando alterações desnecessárias em métodos que façam uso direto dos nomes dos atributos.


73

Aula 07 - Criando a Classe Livro

Um pouco mais de TDD

Nesta aula continuaremos a usar a metodologia TDD. Portanto, iniciaremos criando a Classe de teste para a Classe Livro, e em seguida vamos usar as ferramentas de ajuda instantânea do Eclipse para nos ajudar a criar a Classe Livro propriamente dita.

Recapitulando os objetivos da nossa aplicação:

• Manter uma lista dos nossos Livros • Manter uma lista das Pessoas para as quais emprestamos livros • Ser possível ver quem pegou emprestado qual livro

Neste ponto, nós já temos uma Classe Pessoa capaz de tratar as pessoas para as quais nós emprestamos Livros. Agora nós precisamos da Classe Livro, para tratar dos Livros que possuímos.

Então, vamos criar a Classe de teste para ela, assim:

Na janela que é apresentada, vamos informar o nome da nossa Classe de teste, deixando o nome da Classe sendo testada vazio, pois ele ainda não existe, claro.

74

O que vai nos levar a isso:

Vamos falar rapidamente sobre a Classe Livro. Quais são os atributos necessários à nossa Classe Livro?

• título. (por exemplo: "Menino Maluquinho") • autor. (por exemplo: "Ziraldo") • Pessoa que possui o Livro. (objeto do tipo Pessoa)

Vamos mais uma vez usar as facilidades do Eclipse para nos ajudar neste processo.

Primeiro, vamos criar o método testLivro para testar o método Construtor. Lembre-se: basta começar a digitar o modificador "public" e CTRL+Espaço, assim:

75

Preenchendo os espaços adequadamente, teremos:

Vamos seguir adiante usando as facilidades do Eclipse para criar uma instância da Classe Livro. Para isso, basta digitar "new" e CTRL+Espaço, assim:

O que nos apresenta o seguinte resultado:

Mais uma vez, preenchendo os espaços adequadamente, teremos:

76

Reparem que: desta vez o nosso método construtor recebe como parâmetro o nome do Livro.

Completando com os métodos de teste propriamente ditos, teremos:

Reparem que a Classe de teste apresenta um erro de compilação. Claro, pois a Classe Livro, ainda não existe. Mas mesmo assim, o Eclipse nos permite executar os testes, então vamos fazer isso e ver o que acontece, assim:

O Eclipse nos alerta do erro, mas permite prosseguir:

Resultando no seguinte:

Como era de se esperar, lá estão os erros indicando a não existência da Classe Livro.

Vamos ver agora, como o Eclipse pode nos ajudar a criar a Classe Livro e todos os seus elementos de sustentação.

77

Começaremos usando o botão direito do mouse sobre o nome da classe com erro, e solicitar a sua criação, assim:

Na janela que é apresentada, precisamos alterar a pasta onde a Classe vai ficar localizada, pois o valor default usado é o mesmo local da Classe de teste, e não é isso que desejamos.

78

Vamos selecionar a pasta padrão do nosso projeto, ficando assim:

Gerando o seguinte:

Vamos voltar à Classe de teste e cuidar do próximo erro:

Selecionado a opção de criar o método Construtor, teremos:

79

Salvando a Classe Livro alterada, podemos cuidar do próximo erro:

Gerando o seguinte:

Mais uma vez, salvando a Classe Livro alterada, podemos cuidar do próximo erro:

E mais uma vez, selecionado a opção de criar o método Construtor, teremos:

80

E agora, salvando a Classe Livro alterada, os erros se foram:

Agora que a nossa Classe de teste não tem mais erros de compilação, podemos voltar nossa atenção para a Classe Livro propriamente dita, e escrever o nosso método Construtor.

Mas reparem, que ao gerar o nosso método Construtor de forma automática, o Eclipse colocou lá um comentário especial, começando pela palavra chave "TODO", que indica uma tarefa pendente.

Mais uma facilidade do Eclipse, é uma view que exibe todas as tarefas pendentes. Vamos acioná-la, assim:

O que nos apresenta o seguinte:

81

Vamos então executar a tarefa pendente e implementar o nosso método Construtor da Classe Livro, assim:

Executando o teste novamente, teremos o seguinte resultado:

Reparem que o nome do autor não é o esperado, pois esperávamos por "Ziraldo", mas o método construtor gera "Autor Desconhecido" por default.

Para corrigir esta situação, devemos poder definir o nome do autor, vamos então implementar os métodos get e set que vão nos permitir manipular os atributos da Classe Livro.

Para isso, vamos mais uma vez, usar as facilidades que o Eclipse nos dá, assim:

Na janela que se abre, vamos selecionar os métodos get e set para o atributo autor, já para o atributo título, apenas o get, visto que podemos definir o título diretamente no método Construtor, assim:

82

Gerando o seguinte resultado final:

De volta ao nosso método de teste, podemos definir o nome do autor correto, assim:

Executando o teste mais uma vez, teremos:

83

Portanto, vamos revisar como foi criada a Classe Livro usando TDD:

1. Criar a classe LivroTest 2. Criar o método testLivro() para testar o construtor 3. Usar os facilitadores do Eclipse para criar a Classe Livro 4. Usar os facilitadores do Eclipse para criar os métodos get e set 5. Alterar o teste para definir o valor correto ao atributo autor 6. Executar com sucesso o método de teste


84

Aula 08 - Adicionar Pessoa à Classe Livro

Uso contínuo de TDD

Objetivos desta aula:

• Neste momento temos as Classes Pessoa e Livro • Precisamos mostrar qual Pessoa possui um determinado Livro emprestado com alguém • Vamos portanto, criar um relacionamento entre Livro e Pessoa

Vamos continuar a usar a metodologia TDD. Para isso, executaremos os seguintes passos:

1. Criar um método de teste do relacionamento (testGetPessoa) na Classe de teste da Classe Livro (LivroTest)

2. Implementar o método de relacionamento (getPessoa) na Classe Livro 3. Executar o teste

Nós já temos uma Classe Pessoa capaz de tratar as Pessoas para as quais emprestamos Livros. Como já foi explicado, vamos começar na Classe de teste da Classe Livro (LivroTest). Nela, vamos criar o método "testGetPessoa" da maneira com a qual já estamos acostumados (usando os facilitadores do Eclipse), assim:

Neste método, vamos criar um objeto do tipo Livro e outro do tipo Pessoa, assim:

Em seguida, usamos um novo método para definir para quem o Livro vai ser emprestado, e preparamos o teste do mesmo, da seguinte forma:

85

Reparem nos indicativos de erro em relação ao fato de o método "setPessoa" ainda não existir.

Como estamos lidando com um treinamento aqui, e considerando que comparar objetos em Java é um tanto mais complicado. Ao invés de verificar se o objeto Pessoa retornado pelo método "getPessoa" é igual ao objeto p2 definido anteriormente, vamos comparar apenas os nomes, assumindo que cada Pessoa tem um nome único.

Na sequencia, vamos usar o "Quick Fix" do Eclipse para criar estes métodos, posicionando o mouse sobre o erro e selecionando a opção "Create method":

Obtendo o seguinte resultado:

Seguindo o mesmo procedimento para o método "get" teremos o seguinte:

86

Salvando todo o trabalho, a nossa Classe de teste não terá mais erros:

Vamos agora completar o conteúdo real dos métodos criados. Primeiro o método set:

Reparem que o Eclipse alerta de que o campo "pessoa" não está definido na Classe Livro.

Mais uma vez, vamos usar o "Quick Fix" do Eclipse para corrigir isso, selecionando a opção "Create field", obtendo o seguinte:

O que indica ter sido criado o campo "pessoa" do tipo (Classe) "Pessoa". A diferença é sutil, apenas uma letra maiúscula ou minúscula distingue o nome de um campo do nome de uma Classe.

Notem também que o Eclipse criou o campo "pessoa" usando a palavra "private" no início de definição.

As palavras "private", assim como "public", neste contexto, são chamados "modificadores de acesso", indicando o escopo de abrangência do objeto sendo definido.

No caso, o nosso campo "pessoa" vai ser "visível" apenas dentro do escopo desta Classe onde ele está sendo criado.

87

Modificadores de Acesso

Em Java existem 4 modificadores de acesso:

1. public - o objeto é acessado de qualquer Classe ou Subclasse 2. private - o objeto é acessado apenas na Classe em que foi criado 3. sem modificador - o objeto é acessado apenas por Classes dentro do "pacote" em que foi

criado 4. protected - o objeto é acessado de qualquer Classe ou Subclasse dentro do "pacote" em

que foi criado

Sabendo disso, e se queremos que estes campos estejam disponíveis para outras Classes deste "pacote" vamos retirar os modificadores de acesso, ficando assim:

Vamos agora completar o método get, retornando o objeto do tipo Pessoa já definido para a Classe Livro:

Salvando tudo que foi feito até aqui, estamos prontos para executar o nosso teste.

Desta vez, podemos experimentar a combinação de teclas de atalho do Eclipse para este fim. Você pode estar com outra Classe aberta na área de edição, contanto que a Classe cujos testes você deseja executar esteja selecionada no "Package Explorer", assim:

Usando a combinação de teclas: Alt + Shift + X, T , os testes de JUnit serão executados sobre a Classe que estiver selecionada no "Package Explorer".

O que neste caso, vai nos dar o seguinte resultado:

88

Recapitulando o que vimos até agora:

• As Classes Pessoa e Livro, estão relacionadas • A Classe Livro depende da Classe Pessoa • Este relacionamento é de "Um para Um" (um livro só pode ter um leitor por vez)

Refatoração

Vamos aproveitar para falar um pouco sobre "refactoring". Pois não podemos esquecer ele, é um dos passos da metodologia TDD que estamos aplicando aqui.

É comum a todo artista durante o desenvolvimento da sua obra, tentar melhorar o resultado final. Reescrever um código que já funciona com o intuito de melhorá-lo faz parte da "arte de programar". Desculpem-me alguns gerentes de projeto, mas prefiro tratar os bons desenvolvedores como "artistas" do que como "operários".

Podemos dar aqui um exemplo bem simples de refatoração. Voltando à nossa Classe LivroTest, reparem no seguinte trecho de código:

Ele possui algumas deficiências tais como: Uso de variáveis desnecessárias e nomes não representativos (quem está com o livro não é necessariamente o seu dono).

Primeiro vamos comentar o código atual que vamos refatorar usando o atalho: CTRL + Shift + C, lembrando que ele é do tipo on/off, ou seja, cada vez que é acionado, comenta ou descomenta o trecho de código selecionado:

89

Vamos refazer este trecho da seguinte forma:

Salvando tudo e executando os testes novamente, devemos ter o mesmo resultado de sucesso de antes.

E assim sendo, podemos remover o código anterior que foi comentado, ficando assim:

Vamos entender um pouco mais sobre a linha de código que acabamos de implementar:

String quemPegouLivro = l2.getPessoa().getNom e();

Nela, estamos atribuindo à variável do tipo String "quemPegouLivro", o nome da Pessoa. Mas como?

• Primeiro, usamos o método "getPessoa" para obter uma instância do objeto do tipo Pessoa a qual o livro está vinculado.

• Depois, sobre a pessoa recuperada, aplicamos o método "getNome", para obter o nome da pessoa

Neste momento, nós temos duas Classes de teste: PessoaTest e LivroTest, e vamos criar mais. Seria conveniente ter uma forma de executar todos os testes de uma só vez. Podemos obter isso criando uma nova Classe de teste que agregue as demais.

Suite de testes

Podemos agregar várias Classes de teste, criando uma "Suite" de testes, da seguinte forma:

Botão direito do mouse sobre o nosso pacote de testes » New » Other.

90

E na janela que se abre, vamos selecionar agora "JUnit Test Suite":

A próxima janela, nos permite especificar as características da nossa Suite de testes. Já são exibidos valores default, e entre eles podemos ver que as Classes de teste já existentes, estão selecionadas. Vamos aceitar estes valores default e finalizar:

91

Obtendo o seguinte:

Sem entrar em maiores detalhes aqui, fica claro que à medida que novas Classes de teste forem criadas, basta incluir novas linhas relativas a elas na nossa Suite de teste.

Mais uma vez, estando com a Classe da nossa Suite de testes selecionada no "Package Explorer", vamos usar a combinação de teclas: Alt + Shift + X, T .

Obtendo agora o seguinte resultado:

Reparem que agora, executando os testes a partir da nossa Suite de testes, todos os métodos de teste de todas as nossas Classes de teste são executados de uma só vez.


92

Aula 09 - Listas e ArrayList

Listas na nossa aplicação

O que temos até agora?

• Nós criamos a Classe Pessoa • Nós criamos a Classe Livro • Nós estabelecemos uma ligação entre estas Classes criando um campo pessoa na Classe

Livro

Agora vamos juntar tudo isso e começar a pensar na nossa Classe Biblioteca.

Mas o que gostaríamos que a Classe Biblioteca fizesse?

• Listar os livros que possuímos • Listar as pessoas que pegaram nossos livros emprestados • Listar quantos livros e pessoas existem no nosso grupo?

Num primeiro momento podemos estimar a nossa Biblioteca comunitária em cerca de 50 pessoas e 100 livros. Mas é difícil de garantir. Vamos supor que um amigo entre no grupo e que apenas ele disponha de 200 livros. Lá se vai a nossa média por água a baixo.

O ideal portanto, é que o nosso programa possa lidar com um número ilimitado de livros e pessoas.

Não por acaso, a linguagem Java possui algumas Classes criadas para lidar com listas. Nós vamos usar uma delas chamada: ArrayList .

Características de um ArrayList

• Pode lidar com um número qualquer de Objetos numa lista • Possui métodos já construídos para gerenciar a lista

Vamos voltar a usar o Scrapbook para nos familiarizar com a Classe ArrayList.

Abrindo o Scrapbook, se existir algum código anterior, podemos excluí-lo:

93

A Classe ArrayList está no pacote "java.util". Portanto, a primeira coisa a fazer é: importar este pacote para o Scrapbook:

Na janela que se abre...

Em seguida:

E na sequência:

O fato de importar o pacote "java.util", significa que podemos digitar simplesmente "ArrayList" em vez de "java.util.ArrayList" no nosso código.

94

O nosso próximo passo, vai ser criar um ArrayList. Fazemos isso usando o comando "new" que a essa altura já conhecemos. sempre usando os facilitadores do Eclipse.

Sobre este assunto, cabe aqui uma dica. Aparentemente, nas versões mais recentes do Eclipse, o assistente de código não está funcionando para o comando "new" no Scrapbook. Para solucionar este problema, siga os seguintes passos: Window » Preferences » Java » Editor » Templates. Localize o item "new", assim:

Edite este template e altere o contexto de "Java statements" para "java".

Clique "OK".

95

E "OK" novamente.

Isso deve fazer funcionar o "code complete" para o comando new no Scrapbook.

Começamos criando uma lista vazia, assim:

96

Onde o construtor "<String>", define para o compilador que a nossa lista só vai poder conter Objetos do ipo String. Se tentarmos colocar qualquer outro tipo de Objeto na lista, vamos receber um erro de compilação. Caso não especificado este construtor, a lista dará suporte a qualquer tipo de Objeto Java. Mas esta não é a forma mais comum de uso.

Vamos agora adicionar elementos na nossa lista usando o método "add", assim:

E verificar o resultado com o "Inspect", assim:

Convém ressaltar que os índices das listas em Java começam com 0 (zero).

A título de aprendizado, vamos tentar adicionar um Objeto do tipo inteiro à nossa lista.

Resultando em um erro, assim:

97

Aplicando a Classe ArrayList

Agora que já estamos familiarizados com a Classe ArrayList, vamos usá-la tratar os nossos livros e pessoas.

Vamos começar com a Classe Livro, assim:

Inspecionando, vamos ver os livros na nossa lista:

Seguindo adiante, vamos criar uma pessoa e associar esta pessoa a um dos livros:

98

Mais uma vez, inspecionando vemos que agora existe uma pessoa associada ao livro l1:

Podemos observar aqui, a hierarquia dos Objetos envolvidos: A nossa lista (ArrayList), contém l1 (Livro) que por sua vez contém p1 (Pessoa).

Agora, vamos ver mais detalhadamente alguns outros métodos da Classe ArrayList.

Localizando um elemento (o primeiro) da lista:

Inspecionando, vamos obter o Objeto livro esperado:

99

Usando a hierarquia vista anteriormente, podemos obter a pessoa associada diretamente do Objeto livro recuperado:

E assim:

Seguindo usando o mesmo princípio, já que obtivemos um Objeto do tipo Pessoa, podemos recuperar o nome da pessoa diretamente dele, assim:

Inspecionando, teremos um String com o nome da pessoa:

100

Portanto, nesta linha de código:

lista.get(0).getPessoa().getNome()

• lista.get(0) - retorna o livro l1 • getPessoa() - retorna a pessoa p1 • getNome() - retorna o String com o nome da pessoa p1

Vamos agora localizar um determinado livro na lista, usando o método "indexOf":

O que vai nos retornar a localização do Objeto l2 na lista:

Sendo ele o segundo elemento da lista (índice igual a 1), lembrando que o primeiro elemento da lista possui índice igual a 0 (zero).

Resumindo: se sabemos o índice, podemos obter o Objeto. Se sabemos o Objeto, podemos obter o índice.

Isso também se aplica ao uso do método "remove".

101

Vamos usá-lo para remover o Objeto l1 da lista:

Inspecionando, podemos ver que a nossa lista agora possui apenas um Objeto do tipo Livro, e que ele não é l1 e sim o l2, pois o l1 acabou de ser removido:

Agora que sabemos como inserir, localizar e excluir elementos de uma lista, podemos começar a usar estas listas nas nossas aplicações. É o que vamos fazer na próxima aula.


102

Aula 10 - Classe Biblioteca

Library e Biblioteca

A palavra "Library" no mundo Java define um conjunto de pacotes. Poderia haver alguma confusão de nomes se estivéssemos trabalhando em Inglês, pois Classe que vai representar os Livros que temos e as Pessoas que podem pegar os livros emprestados, deveria também se chamar "Library". Mas, como aqui, estamos usando nomes em Português, não há nenhum problema de confusão entre "Library" e "Biblioteca", que vai ser o nome da nossa Classe.

Vamos continuar a usar a metodologia TDD. Portanto:

O nome da nossa Classe de Teste vai ser "BibliotecaTest". E vamos deixar o nome da Classe sendo testada em branco, pois ela ainda não existe.

Obtendo o seguinte:

103

Vamos primeiramente criar o método de teste do Construtor da Classe. Sempre usando os facilitadores do Eclipse:

Aqui vamos usar um novo tipo de teste. É o "assertTrue". O objetivo aqui, vai ser verificar se a nossa instância da Classe Biblioteca, possui um ArrayList contendo Livros e outro contendo Pessoas. Dessa forma:

Desta forma, sabemos que o nosso método Construtor da Classe Biblioteca, além de criar a instância da nossa Biblioteca, vai precisar também adicionar a ela uma lista de Livros e outra de Pessoas.

Vamos prosseguir usando o "Quick Fix" do Eclipse para nos ajudar a criar a Classe para atender a este Teste. Posicionando o mouse sobre o erro, temos:

104

Escolhendo a opção de Criação da Classe...

Na janela que se apresenta, precisamos lembrar de alterar o nome da pasta onde a Classe será criada para "src" .

Feito isso, teremos o seguinte:

A seguir, ainda usando o "Quick Fix" do Eclipse, vamos criar o Construtor da Classe:

105

Gerando o seguinte:

Vamos prosseguir usando o "Quick Fix" do Eclipse para solucionar os problemas apontados na nossa Classe de teste, e ao mesmo tempo ir completando a nossa Classe Biblioteca.

Primeiro o campo "nome".

106

Em seguida, devemos nos preocupar com os campos "livros" e "pessoas", mas reparem que ambos são do tipo "ArrayList", e este tipo não está sendo reconhecido pelo compilador. A solução para isso é simples, basta importar o pacote java.util que contém este tipo de dado.

Fazendo conforme indicado, o pacote é importado para a nossa Classe de teste e o erro desaparece.

Agora o campo "livros".

107

Não esquecendo que para que os erros desapareçam da Classe de teste, a Classe Biblioteca deve ser salva a cada alteração. E também que alguns desses erros, só desaparecerem, se a própria Classe de teste for salva.

Da mesma forma, vamos fazer para o campo "pessoas".

Neste momento, com todo o trabalho feito até aqui já salvo, não há mais erros de compilação no projeto.

Lembrando também, que existe uma outra forma de acessar os problemas e advertências para tratá-los. É a aba "Problems", geralmente localizada na parte inferior da janela do Eclipse.

108

Neste ponto, nós estamos aptos a completar o método construtor da Classe Biblioteca.

Antes disso, no entanto, vamos cuidar para que os campos da Classe Biblioteca possam ser acessados por outras Classes dentro do mesmo pacote. Para isso, como já mencionado anteriormente, basta remover o modificador "public" da definição dos campos, assim:

Com isso, a nossa Classe de teste pode acessar estes campos da forma correta, mas classes fora deste pacote, não podem.

A próxima intervenção em relação aos campos, é atender os alertas, e definir que tipo de Objeto vai ser tratado em cada uma das Listas.

Para isso, vamos usar a aba "Problems" já citada, selecionar uma das linhas, acionar o botão direito do mouse e selecionar "Quick Fix", assim:

Na janela que se abre, selecionamos as duas linhas com este mesmo problema, e escolhemos o ajuste "Add type arguments to ArrayList", assim.

109

Com isso, temos o problema parcialmente resolvido:

Mas precisamos substituir os pontos de interrogação pelos tipos de Objetos realmente desejados, assim:

Podemos agora ajustar o Construtor propriamente dito, começando pelo nome do campo de parâmetro, de "string" que foi gerado automaticamente para "nome", que é bem mais apropriado.

110

Em seguida, vamos atribuir o parâmetro "nome" recebido, ao atributo "nome" da instância que estiver sendo criada, assim:

O próximo passo, é criar os atributos de Livros e Pessoas da instância no formato de Listas, assim:

Existem algumas características que devem ser ressaltadas nestas duas linhas.

livros = new ArrayList<Livro>(); pessoas = new ArrayList<Pessoa>();

Quando chamamos o Construtor de um "ArrayList" usando o comando "new", e especificamos o tipo do Objeto específico que queremos usando o parâmetro de tipo "<Tipo>", é necessário o uso de () para finalizar o construtor de ArrayList, pois ele não possui parâmetros.

Portanto, a sintaxe do construtor nesses casos, é a seguinte:

new TipoGenérico<TipoEspecífico>();

Outra observação importante, é em relação à declaração dos campos a nível da Classe.

Campos declarados na Classe, não devem ser declarados novamente nos métodos da Classe, pois na verdade, estariam sendo declaradas novas variáveis, locais aos métodos, podendo causar muita confusão. A título de aprendizado, vamos ver o que ocorre se isso for feito.

111

Reparem que é gerado um alerta para o fato de a variável local "livros" não ter sido usada no escopo do método. Este é um erro muito comum de acontecer com iniciantes em Java, portanto, vamos evitá-lo, certo?

Com a nossa Classe Biblioteca criada, é hora de executar o nosso teste, e ver o que acontece.

Se tudo correu bem, o teste deve passar:

Um detalhe que deve ser observado em relação aos testes de JUnit, é que os nomes dos métodos de teste devem começar por "test".

Mais uma vez, a título de aprendizado, vamos ver o que ocorre se isso não for feito.

112

Com o nome do método alterado desta forma, e executando o teste novamente, teremos:

Reparem no alerta dizendo que não foi encontrado nenhum teste na Classe. Tudo por conta do nome fora do padrão esperado. Fiquem atentos!

Uma última observação a respeito dos testes: eles podem nos ajudar saber de antemão, qual tipo de dado é suportado por cada método.

Sabemos que os livros de uma Biblioteca são do tipo ArrayList. O que acontece se alguém tentar adicionar um livro usando um tipo de dado diferente do esperado?

Reparem que é gerado um erro de compilação justamente dizendo que o método não se aplica ao tipo de dado passado como parâmetro, pois ele esperava um "ArrayList" e foi passado um "String".


113

Aula 11 - Primeiros Métodos da Classe Biblioteca

Que Métodos precisamos na Classe Biblioteca?

Existem alguns métodos na Classe Biblioteca, cuja necessidade, chama a atenção. São eles:

• Métodos "get" para os campos(métodos "set" não são necessários) • Métodos addLivro e addPessoa • Métodos removeLivro e removePessoa • Métodos pegarLivro e devolverLivro • Método getLivrosDisponiveis • Método getLivrosEmprestados • Método getLivrosPessoa

Para providenciar o que está faltando, vamos continuar a usar a metodologia TDD, e os facilitadores do Eclipse.

Sendo assim, nossa primeira ação vai ser criar os métodos "get" para os seguintes campos:

Uma das formas de se conseguir isso, é: com a Classe Biblioteca selecionada.

Na barra de menus selecionar: Source » Generate Getters and Setters...

Na janela que é apresentada, expandir os campos e selecionar apenas os métodos que necessitamos:

114

Obtendo o seguinte:

Aprendendo e aplicando um pouco mais sobre a metodologia TDD, após qualquer modificação como a que acabamos de fazer, é uma boa hora de reexecutar os testes para garantir que as nossas alterações não tenham gerado nenhum erro. A palavra de ordem é: "Ficou em dúvida, reexecute os testes". Portanto, vamos fazer isso.

Mais uma vez, uma das formas de se fazer isso, é: com a Classe BibliotecaTest selecionada.

Na barra de menus selecionar: Run » Run As » JUnit Test.

Obtendo o seguinte:

115

Como era de se esperar, os testes continuam passando, afinal era uma alteração bem pequena e foi feita usando um dos facilitadores do Eclipse, mas serve para exercitar o uso de TDD.

O nosso próximo passo será escrever um método de teste para os métodos responsáveis por adicionar e remover Livros.

No entanto, nós vamos precisar de alguns objetos para efetuar estes testes.

• Objetos do tipo Livro • Objetos do tipo Pessoa • Um Objeto do tipo Biblioteca

Para evitar duplicidade de código, pois estes objetos podem ser úteis em outros métodos que ainda vão ser criados, existe no JUnit o método "setUp()", que como o nome indica é usado para inicializar o nosso procedimento de teste com tudo que for necessário.

Na verdade, existem alguns "métodos padrão" costumeiramente usados não só na inicialização, como também na finalização e nos próprios testes com JUnit

oneTimeSetUp() setUp() testEmptyCollection() tearDown() setUp() testOneItemCollection() tearDown() oneTimeTearDown()

Mas isso á assunto para um curso mais avançado. No momento, vamos abrir a nossa Classe de teste "BibliotecaTest", e criá-lo, assim:

Mas existe um problema com esta implementação. Ocorre que as variáveis: l1, l2, p1, p2 e b1, são locais ao método setUp. Desta forma, elas não estariam disponíveis para os demais métodos da nossa Classe de Teste.

116

A solução para isso, é simples: basta passar a definição das variáveis para o escopo da Classe, transformando-as em "campos". E mais uma vez, o Eclipse nos ajuda nesta tarefa com um dos seus facilitadores.

É bom que se tenha em mente, que em geral, o Eclipse os dá ao menos três formas diferentes para obter um determinado resultado: Um usando a barra de menus, outro usando o menu de contexto no próprio código fonte e um terceiro usando teclas de atalho.

Neste caso específico, vamos ver cada um deles.

Começando pelo menu de contexto no código:

Com a variável l1 selecionada, acionar o botão direito do mouse sobre ela e no menu de contexto, selecionar: Refactor » Convert Local Variable to Field...

Na tela que se abre em seguida, aceitar os valores default e acionar o botão OK.

117

Obtendo o seguinte:

Agora, usando a barra de menu:

Com a variável l2 selecionada, na barra de menus selecionar: Refactor » Convert Local Variable to Field...


118

Obtendo o seguinte:

Finalmente, usando as teclas de atalho:

Com a variável p1 selecionada, acionar: Alt + Shift + T. Isso faz surgir direto o menu de contexto específico de Refatoração, no qual basta selecionar: Convert Local Variable to Field..., ou simplesmente usar a tecla "v".


119

Obtendo o seguinte:

Fazendo o mesmo para as variáveis: p2 e b1, usando, dos métodos expostos o que você julgar mais cômodo, obteremos o seguinte:

É uma dúvida frequente dos iniciantes neste ponto, querer saber qual a diferença entre uma Variável e um Campo?

Como vimos nos procedimento acima, todos são Variáveis, só que: aquelas variáveis definidas a nível da Classe, são também chamadas de Campos (Fields), apenas nomenclatura.

Feito isso, podemos agora criar o nosso novo método de teste para a inclusão de Livros.

Mais uma vez, usando os facilitadores do Eclipse, inicie a construção do método pela inicialização dos objetos necessários, assim:

120

Em seguida, precisamos garantir que o objeto principal do nosso teste esteja vazio, assim:

O próximo passo, é adicionar livros na nossa biblioteca, assim:

Ocorre que: o método "addLivro" ainda não existe. Vamos usar o auxílio do Eclipse para a correção de erros que aparece na imagem acima, e criar o método (vazio por enquanto) na Classe Biblioteca, assim:

121

Uma vez adicionados os Livros, devemos garantir que o objeto não está mais vazio e possui 2 (dois) itens, assim:

Além disso, devemos garantir que os índices dos objetos são os esperados, assim:

O próximo passo, é testar da mesma forma os efeitos do método "removeLivro".

Na situação atual, se removemos um dos Livros da Biblioteca, deve restar apenas 1, portanto:

Neste momento, o método "removeLivro", não existe. Vamos usar o mesmo procedimento já usado anteriormente, para criar este método vazio (por enquanto), na Classe Biblioteca, obtendo o seguinte:

Além dos testes já efetuados, podemos ainda garantir que o índice do segundo Livro, passou a ser 0 (zero), lembrando que: quando havia dois objetos do tipo Livro, o primeiro tinha índice 0

122

(zero) e o segundo o índice 1 (um). Agora que retiramos o primeiro Livro, o índice do segundo Livro deve passar a ser 0 (zero).

Vamos verificar isso, desta forma:

Para finalizar, vamos fazer de forma semelhante o teste dos efeitos de remover o Livro que havia sobrado, assim:

Devemos ter voltado à situação inicial, ou seja, o objeto deve estar vazio.

É chegada a hora de implementar os métodos que vão cuidar de adicionar e remover os Livros, na Classe Biblioteca, assim:

Agora, devemos usar exatamente os mesmos procedimentos para criar os métodos para adicionar e remover Pessoas, usando é claro a metodologia TDD e começando pelos seus respectivos testes.

Sendo assim, o método de teste deve ficar assim:

123

E os métodos implementados na Classe Biblioteca, devem ficar desta forma:

Com todos os métodos prontos, devemos executar novamente os testes, neste momento, o ideal é que a nossa suite de testes seja alterada incluindo a classe "BibliotecaTest", assim:

Com a nossa Suite de testes (AllTests) alterada desta forma, podemos testar toda a aplicação e devemos obter sucesso, assim:

Podemos verificar neste momento, usando a Visão "Outline", que a Classe Biblioteca já possui vários métodos implementados:

124

Mais alguns vão ser implementados em breve.


125

Aula: 12 - Os métodos de Empréstimo e Devolução

Afinal é isso que uma Biblioteca faz

Agora que temos os métodos básicos da Classe Biblioteca criados, vamos implementar a parte de Empréstimo e Devolução de Livros.

Estes métodos vão ver um pouco mais complexos do que os que fizemos até aqui.

Prosseguindo no uso da metodologia TDD, vamos criar um método de teste para tudo isso, assim:

testMovimentaLivro

• Ele vai testar os métodos de Empréstimo e Devolução o Empresta um Livro o Empresta um segundo Livro o Devolve um Livro o Devolve um segundo Livro o Comandos de verificação depois de cada chamada de método

Planejamento e Design

Como já foi mencionado, estes métodos vão ser um pouco mais complexos, portanto, vamos cuidar do seu planejamento e design antes de começar a codificar.

Vamos estabelecer agora as características do nosso método de Empréstimo.

• Deve estabelecer o objeto Pessoa no campo pessoa do Livro • Usando o método setPessoa • O que acontece se o Livro já foi emprestado?

o Não deve permitir o empréstimo • Precisa testar isso no próprio método de Empréstimo • O método deve indicar sucesso ou falha de acordo com a situação • Devemos informar ao método chamador se o empréstimo foi bem sucedido ou não

Sabendo de tudo isso, vamos detalhar em Pseudo código, o que o método de Empréstimo deve fazer:

1. Garantir que o Livro ainda não foi emprestado. 2. Se ainda não foi emprestado, atribuir uma Pessoa para o Livro e retornar para o método

chamador que o empréstimo foi bem sucedido. 3. Caso contrário, simplesmente retornar ao método chamador que o empréstimo não

ocorreu.

Agora que sabemos o que o método deve fazer, vamos estabelecer o "como" ele vai fazer, definindo a sua assinatura:

1. Vai retornar um booleano (true ou false), indicando sucesso ou falha. 2. No Pseudo-Código, foi mencionado "uma Pessoa para o Livro". Mas qual Pessoa e qual

Livro? 3. Livro e Pessoa portanto, vão ser parâmetros do nosso método.

126

Sendo assim, a assinatura do método seria esta:

public boolean emprestimo(Livro li, Pessoa pe )

Com tudo isso em mente, podemos iniciar a construção do nosso método de teste, na Classe BibliotecaTest.

Nada de novo aqui. Usando os facilitadores do Eclipse, estamos prontos para começar.

Os primeiros passos, vão ser: Inicializar os objetos, com o já conhecido método setUp(). E adicionar Livros e Pessoas à Biblioteca, assim:

Neste ponto, vamos usar uma sintaxe um pouco diferente do método assertTrue do JUnit. De forma que: caso o retorno do método sendo testado seja falso, uma mensagem seja exibida, assim:

127

Lembrando que o método "emprestimo", que ainda vamos criar, retorna um valor booleano, indicando se a operação foi bem sucedida ou não.

Depois disso, supondo que o empréstimo tenha sido bem sucedido, devemos verificar se o nome da Pessoa atribuído ao Livro, é o que se espera, assim:

Lembrando aqui, que devemos recuperar o nome da Pessoa, e não comparar com o objeto Pessoa simplesmente. Como já foi mencionado, comparar dois objetos em Java pode ser enganador...

Também supondo que o empréstimo foi bem sucedido, podemos nos certificar que: uma tentativa de emprestar o mesmo livro vai falhar, usando agora o método assertFalse do JUnit. De forma que: caso o retorno do método sendo testado seja verdadeiro, uma mensagem seja exibida, assim:

Guarde na memória:

• assertTrue - dá certo se o método sendo testado retorna true. Caso contrário, emite a mensagem.

• assertFalse - dá certo se o método sendo testado retorna false. Caso contrário, emite a mensagem.

128

Com tudo isso, o método de Empréstimo está razoavelmente bem criticado.

Usando a mesma técnica e os mesmo dados, vamos fazer as verificações para o método de Devolução, assim:

Reparem que o método de Devolução, só precisa receber o Livro como parâmetro.

O próximo passo, é usar o "Quick Fix" do Eclipse para nos ajudar a criar os métodos que precisamos:

O que nos leva a isto:

Fazendo o mesmo para o método de Devolução:

129

Teremos:

Neste ponto, estamos aptos a implementar os métodos de Empréstimo e Devolução propriamente ditos.

Mas para isso, devemos considerar alguns detalhes

Por exemplo: o método de Empréstimo, vai precisar atribuir uma Pessoa a um Livro, mas apenas se o Objeto Pessoa estiver vazio (null).

Desta forma:

Aqui surgem algumas informações novas, que precisamos comentar.

• O comando if , que é de uso frequente, e portanto precisa ser bem estudado. • O operador de igualdade ==, que não deve ser confundido com o de atribuição =. Um

erro frequente entre os iniciantes. • O Literal1 null , que define um Objeto2 vazio.

Notas:

1. Diferente do que muitos imaginam, "null" não é uma palavra reservada. É um Literal. 2. Entenda-se qualquer Objeto: um Campo, uma Variável, ou a instância de uma Classe.

Referências:

• O comando if. • O operador de igualdade. • O literal null.

130

Portanto, com a expressão:

if (l1.getPessoa() == null)

Estamos verificando se não há nenhuma Pessoa atribuída ao Livro "l1".

O código do método de Devolução, vai ser muito semelhante, assim:

Nada de novo aqui, a não ser:

• O operador de diferente !=.

Neste caso, com a expressão:

if (l1.getPessoa() != null)

Estamos constatando que já existe uma Pessoa atribuída ao Livro "l1".

Agora, estamos prontos para testar tudo que fizemos até agora. Como as modificações foram feitas apenas na Classe Biblioteca, podemos executar apenas os testes da Classe correspondente: BibliotecaTest.

Desta vez, com a Classe de Teste selecionada:

Vamos usar o atalho: Alt + Shift + X + T.

Se tudo correu bem e não houve erros de digitação, o teste deve passar:

131

Assim, os nossos métodos de Empréstimo e Devolução estão prontos para evoluir.


132

Aulas: 13 e 14 - Evoluido os métodos de Empréstimo e Devolução

Melhorando os métodos de Empréstimo e Devolução

A essa altura, poderíamos pensar que o nosso método de Empréstimo, está pronto.

Mas será que está mesmo? Alguém lembra que existe um limite de Livros que uma Pessoa pode pegar emprestado?

Na Classe Pessoa, nós havíamos criado o campo maxLivros, com a finalidade de limitar o número de Livros que uma Pessoa pode pegar emprestado simultaneamente.

No entanto, nós não tratamos disso no método de empréstimo nem nos seus respectivos testes.

Lembrou? Então vamos cuidar disso. Mais uma vez, usando TDD, vamos começar pelos testes.

Vamos incluir mais alguns testes no método testMovimentaLivro da Classe BibliotecaTest.

Desta forma:

O primeiro teste com assertTrue, garante que eu devo conseguir emprestar o Livro "l2" para a Pessoa "p1".

Já o segundo teste com assertFalse, garante que eu não devo conseguir emprestar o Livro "l1" para a mesma Pessoa "p1", pois o seu limite de Livros emprestados (1 no caso) foi atingido.

Se neste momento, executarmos os testes, eles devem falhar, pois nós não alteramos o método de Empréstimo para levar em consideração o limite de Livros. Vamos confirmar isso (Alt + Shift + X + T):

133

Realmente, como era de se esperar, os testes falham. E é emitida a mensagem de Empréstimo indevido, pois como nós ainda não implementamos um tratamento para o limite de Livros, o método conseguiu emprestar mais um Livro para a mesma Pessoa mesmo com o limite sendo excedido.

Agora, para que possamos testar se o número máximo de Livros que uma Pessoa pode pegar emprestado foi atingido, precisamos antes de mais nada saber, quantos livros aquela Pessoa já havia pego emprestado.

Fica clara a necessidade de um método getLivrosPorPessoa. Tendo este método, seria bastante simples obter a quantidade de Livros, desta forma:

quantidade = b1.getLivrosPorPessoa(p1).size ();

Mas vamos manter o padrão, e começar pelos testes:

Agora reparem naquelas 4 linhas do método testMovimentaLivro, nós já as havíamos usado mais acima, e vamos precisar usar novamente neste novo método.

Isso é chamado de: redundância de código. Para evitar esse tipo de situação, assim que uma repetição de um determinado trecho de código é detectada, devemos procurar transformar o conteúdo deste trecho, num método à parte.

É mais um caso de Refatoração de Código, como vimos no item 12, aula 08.

Nesses casos, mais uma vez, os facilitadores do Eclipse nos ajudam.

Com as linhas que nos interessam selecionadas, na barra de menus, selecionar: Refactor » Extract Method..., ou usar o atalho: Alt + Shift + M.

134

Na Janela que se abre, especificar o nome desejado para o método, assim:

Isso faz com que todas as ocorrências daquelas linhas sejam substituídas pela chamada do novo método que foi automaticamente criado pelo Eclipse. Desta forma:

Agora, com o método addItems criado, podemos fazer uso dele no nosso novo método de teste:

135

Prosseguindo na implementação, vamos fazer os testes, na seguinte sequência:

• Garantir que no início, a Pessoa "p1" não tenha pego nenhum Livro. • Emprestar o Livro "l1" para a Pessoa "p1". • Verificar se o tamanho da Lista de Livros da Pessoa "p1", é o esperado. • Verificar se o índice do Livro "l1" na Lista de Livros é o esperado. • Emprestar o Livro "l2" para a Pessoa "p1". • Verificar se o tamanho da Lista de Livros da Pessoa "p1", é o esperado. • Verificar se o índice do Livro "l2" na Lista de Livros é o esperado.

O que vai nos levar ao seguinte:

Aqui, usamos mais uma vez o recurso de Lista (ArrayList).

Prosseguindo, vamos usar novamente o Quick Fix do Eclipse para criar o método.

136

Finalizando os métodos de Empréstimo e Devolução

O método getLivrosPorPessoa, será implementado da seguinte forma:

A qual, merece algumas explicações. Vamos ver linha a linha:

64. Define o ArrayList resultado que vai armazenar a Lista que o método deve retornar.

65. Um laço do tipo "foreach", que vai percorrer a lista de Livros.

66. O "if" que define as condições que vão eleger um elemento para a nossa Lista. o O Livro deve estar emprestado a uma Pessoa. o O nome da Pessoa a qual o Livro foi emprestado

deve ser igual ao da Pessoa passada como parâmetro

68. O elemento eleito é adicionado na Lista.

71. O ArrayList "resultado" é retornado.

Como funciona o laço "foreach"?

1. Coloca o primeiro Livro da lista "this.getLivros" em "umLivro" 2. Executa o bloco de código 3. Coloca o próximo Livro em "umLivro" 4. Executa o bloco de código 5. Repete até o final da Lista

O laço do tipo "foreach" é o mais indicado para processar Listas.

Observem também, que o "if" da linha 66 possui duas condições interligadas. Neste caso, foi usado o operador &&, que é o "E lógico", ou seja, para que a condição como um todo seja satisfeita, cada uma de suas partes deve ser satisfeita.

É muito importante notar que usamos o método ".equals()" para comparar o String nome da Pessoa. Esta é a forma correta de se comparar Objetos em Java. O operador "==", só deve ser usado para comparar tipos primitivos (int, boolean, char, double, etc.).

Depois disso tudo, é hora de executarmos os testes novamente. Vamos mais uma vez, selecionar a Classe de Teste BibliotecaTest e usar o atalho já conhecido: Alt + Shift + X + T:

137

Podemos ver que apesar de o teste do método "movimentaLivro" ter falhado, o teste do método "getLivrosPorPessoa", passou! Isso está correto, pois nós ainda não terminamos o método "movimentaLivro".

Neste ponto, alguém pode perguntar: É mesmo necessária a primeira condição do if, verificando se o objeto Pessoa associado ao Livro não está nulo? Vamos alterar o código desta forma:

E testar novamente, selecionando a Classe de Teste BibliotecaTest e usando o atalho: Alt + Shift + X + T:

Desta forma ocorreu um erro de compilação, gerando a mensagem "NullPointer Exception".

Esta é uma das mensagens de erro mais comuns no ambiente Java. E o motivo é sempre o mesmo: A tentativa de manipular um Objeto inexistente (null).

No nosso caso, com a retirada do teste, os Livros que não tinham sido atribuídos a nenhuma Pessoa, passaram a ser considerados, e no primeiro Livro da nossa Lista que não tinha Pessoa atribuída, onde tentamos obter o nome da Pessoa com "umLivro.getPessoa().getNome()" ocorreu o erro.

Tendo aprendido mais um pouco sobre os possíveis erros e necessidade de testes, vamos voltar o código à situação anterior com as duas condições:

138

Feito isso, podemos voltar ao método de Empréstimo, e implementar a verificação do limite de Livros por Pessoa, assim:

Foram duas as modificações feitas. Vamos ver linha a linha:

46. Foi criada a variável "livrosEmprestados", que armazena o tamanho da Lista de Livros da Pessoa que foi passada como parâmetro.

48. Foi inserida uma segunda condição no "if" para verificar se a quantidade de Livros que a Pessoa passada como parâmetro pediu emprestado, ainda é menor que o limite.

Com estas alterações feitas, é hora de testar novamente, selecionando a Classe de Teste BibliotecaTest e usando o atalho: Alt + Shift + X + T:

Agora sim, o teste deve passar.

Uma última verificação deve ser feita.

Como já havíamos incluído a Classe "BibliotecaTest" na nossa Suite de testes "AllTests", basta selecioná-la, e usando o mesmo atalho: Alt + Shift + X + T, executar todos os testes, garantindo que estas últimas alterações não causaram problema em outras partes da aplicação.

139

E aí está. Todos os testes devem ter passado e a nossa aplicação já evoluiu bastante!


140

Aula: 15 - Finalizando a Classe Biblioteca

Criando os métodos finais da Classe Biblioteca

Já estamos quase no fim da nossa tarefa. Os métodos básicos já foram criados. Agora, precisamos criar os métodos finais:

• getLivrosDisponiveis • getLivrosIndisponiveis • toString para a Classe Livro • toString para a Classe Biblioteca

Nota: desta aula em diante será usado o Windows7

O método getLivrosDisponiveis

Este método vai retornar uma lista dos livros que ainda não foram emprestados.

Mais uma vez, começando pelos testes...

Usando os facilitadores do Eclipse, vamos codificar o método de teste assim:

Prosseguindo, podemos copiar e alterar linhas de métodos anteriores até chegar a este ponto:

Neste caso, vamos logo criar o método.

141

Salvando o método criado.

Ficaremos livres de erros no nosso código de teste.

Depois de copiar e alterar mais alguma linhas de código, o método de teste deve estar assim:

O próximo passo é codificar o método getLivrosDisponiveis propriamente dito.

Para isso, vamos aproveitar o código do método getLivrosPorPessoa, e depois de copiar e alterar as suas linhas, devemos ter o método assim:

142

Em seguida vamos executar a Suite de testes:

Se tudo correu bem na codificação, os testes devem passar:

143

O método getLivrosIndisponiveis

De forma análoga ao método anterior, vamos criar o método de teste para este método, tendo como base o método testGetLivrosPorPessoa.

Depois de copiar e alterar algumas linhas, devemos ter o método de teste assim:

Criando o método...

O método vazio gerado:

Com o método vazio salvo, e de volta a nossa Classe de Teste, devemos estar livres dos erros.

Este método de teste deve ser bem familiar a esta altura.

144

Sendo:

1. Inicialização dos objetos de teste 2. Nenhum Livro indisponível 3. Um Livro indisponível 4. Dois Livros indisponíveis

Mais uma vez, o próximo passo é codificar o método getLivrosIndisponiveis propriamente dito.

Para isso, vamos aproveitar o código do método getLivrosDisponiveis, e depois de copiar e alterar as suas linhas, devemos ter o método assim:

Com o trabalho feito até aqui salvo e com a classe BibliotecaTest selecionada, vamos usar o atalho: Alt+Shift+X, T para executar os testes desta classe.

Novamente, se tudo correu bem na codificação, os testes devem passar:

145

Os métodos toString para as nossas Classes

Como já explicado anteriormente, o método toString é herdado da Classe Object.

Este método deve ser sobre escrito na maior parte das Classes.

Ele retorna uma representação em String do Objeto.

O método toString para a Classe Livro

Mais uma vez, começando pelos testes, vamos abrir a nossa Classe de testes para Livros.

Aproveitando algumas linhas do método testGetPessoa, e efetuando as alterações necessárias, vamos ter o seguinte resultado:

146

Vamos agora, codificar o método toString na Classe Livro.

O resultado final deve ser este:

A esta altura, o conteúdo deste método também deve ser familiar a todos, mas vamos descrever as suas principais linhas:

35. Define a variável local que vai armazenar a situação do Livro.

36. O "if" que define a situação do Livro. o Se o Livro não possui Pessoa associada, a situação é "Disponível". o Se o Livro possui Pessoa associada, a situação é "Emprestado para" esta Pessoa.

42. Retorna a combinação: Título + Autor + Situação como um String.

Com o trabalho feito até aqui salvo e com a classe LivroTest selecionada, vamos usar o atalho: Alt+Shift+X, T para executar os testes desta classe.


147

O método toString para a Classe Biblioteca

Diferente da anterior, a Classe Biblioteca, pode conter uma grande quantidade de Livros e Pessoas.

O método toString neste caso, vai retornar um sumário de informações.

Vamos abrir a nossa Classe de testes para Biblioteca.

Criando o método...

Aproveitando algumas linhas já conhecidas, e efetuando as alterações necessárias, vamos ter o seguinte resultado:

148

Vamos agora, codificar o método toString na Classe Biblioteca.

O resultado final deve ser este:

Mais uma vez, com o trabalho feito até aqui salvo e com a classe BibliotecaTest selecionada, vamos usar o atalho: Alt+Shift+X, T para executar os testes desta classe.


Para finalizar esta aula, podemos executar toda a Suite de testes para garantir que todas as Classes continuam funcionando adequadamente.

149

E aí está. Todos os testes devem ter passado e a nossa aplicação está praticamente pronta!


150

Aula: 16 - Criando o método main e o arquivo JAR

O progresso até agora

Neste ponto, a nossa aplicação está praticamente completa. Vejamos:

• Temos as Classes Pessoa, Livro e Biblioteca codificadas. • Como usamos a metodologia TDD, temos um alto grau de confiança de que as nossas

Classes vão funcionar de acordo com o que foi projetado.

No entanto, nós só executamos partes da aplicação, e ainda assim, partindo das Classes de Teste: PessoaTest, LivroTest e BibliotecaTest usando o JUnit.

Executando um programa Java

Nesta última aula nós vamos criar um programa independente para criar e modificar Objetos do tipo Biblioteca.

Para tal, precisamos entender que:

1. Quem executa um programa Java, é o Java Runtime Engine (JRE). 2. Depois de carregar as nossas Classes em memória, o JRE, precisa saber o que fazer

depois. 3. Para isso, O JRE tenta executar um método especial chamado "main" 4. Portanto, precisamos criar o método "main" em uma de nossas Classes.

Um exemplo:

Se a nossa aplicação tivesse algum tipo de Interface Gráfica com o Usuário (ou GUI), bastaria apresentar um formulário no método "main" e deixar o usuário prosseguir daí.

Criar uma Interface Gráfica em Java, está além do escopo deste curso, portanto:

No nosso caso:

Vamos simular uma ação do usuário sobre as nossas Classes no método "main" e exibir os resultados na console do sistema.

Para finalizar, assim que tivermos tudo isso funcionado dentro do Eclipse, vamos usar o seu "Ajudante de Exportação" para criar uma arquivo executável do tipo JAR.

Arquivos do tipo JAR, podem ser executados em qualquer computador (ou dispositivo) que execute Java (que tenha o JRE ou JDK instalados).

151

Na prática

Podemos colocar o método "main", em qualquer das nossas Classes, mas vamos fazer isso, na Classe Biblioteca, considerando que é ela a principal Classe da nossa Aplicação.

Mais uma vez, usando o assistente de código do Eclipse, vamos deixar que ele crie o método para nós.

Vamos digitar a palavra "main", seguida por Ctrl+Espaço e aceitar o método "main" proposto:

152

Obtendo o seguinte:

O método "main", é um método estático (static), que não retorna nada (void), e recebe como parâmetro um Array de Strings chamado "args" (String[] args).

Isso permite a um programa Java ler parâmetros da linha de comando. Não vai ser o caso do nosso exemplo.

Vamos prosseguir usando o assistente de código e fazer o seguinte:

• Criar uma Biblioteca. • Criar Livros e Pessoas. • Associar Livros e Pessoas à Biblioteca. • Efetuar alguns empréstimos e devoluções. • Tudo isso, exibindo os resultados parciais na console.

Começamos assim: "new" + Ctrl+Espaço, e selecionando "create new object".

153

Completando para nos atender:

Vamos prosseguir usando o assistente de código até obter o seguinte:

O próximo passo, é exibir o status atual da Biblioteca. Vamos criar o método "imprimeStatus" para esta finalidade. Método esse que será utilizado sempre que for necessário exibir o status atual da Biblioteca à medida que o nosso programa vai sendo executado.

154

Assim: "sysout" + Ctrl+Espaço.

Obtendo:

Completando esta primeira parte:

155

Usando a mesma estratégia, vamos criar novas situações:

Usando o assistente de código, vamos criar o método "imprimeStatus".

Obtendo:

156

Depois de devidamente alterado para exibir a situação de cada Livro, de cada Pessoa e da Biblioteca como um todo, o método deve ficar assim:

Agora que a nossa Classe possui um método "main", ela pode ser considerada uma aplicação Java, e como tal pode ser executada.

Para isso, temos algumas opções: usando o menu principal, usando teclas de atalho ou usando o menu de contexto.

Com a Classe Biblioteca selecionada, usar o botão direito do mouse para acionar o menu de contexto e selecionar: Run As » Java Application

157

O que deve produzir um resultado semelhante a este na console:

Agora que temos a nossa aplicação funcionando no Eclipse, podemos nos preocupar em gerar um arquivo "executável" para ela.

No ambiente Java, este arquivo "executável" é do tipo JAR (ou Java Archive).

Este arquivo vai poder ser executado fora do Eclipse em qualquer sistema que seja compatível com Java.

Para isso, vamos usar o menu: File » Export...

158

E na janela que se abre: Java » JAR file

Na janela seguinte, fica claro o motivo de ter criado os nossos testes em um pacote separado. Neste momento, podemos exportar apenas o código fonte que é o que efetivamente é necessário.

159

Na tela seguinte vamos aceitar os valores default:

Na próxima tela vamos especificar a Classe que contém o método "main":

160

Acionando o botão "Browse":

A qual selecionada:

161

Feito isso, o arquivo JAR deve ter sido gerado:

Para testar este nosso executável fora do Eclipse, será necessário abrir uma console do sistema operacional no diretório onde o arquivo JAR foi gerado.

No Windows XP, a maneira clássica era usar o comando "Run" ou "Executar", digitar o comando "cmd", para chamar a console do sistema, e a partir daí, chegar ao diretório desejado e executar os comandos necessários.

Já no Windows 7, o comando "Run" não fica habilitado por default, e a opção da barra de pesquisa, é por vezes, muito lenta.

Se você já está usando o Windows 7 como eu, vai aqui uma dica de como habilitar esta opção no menu "Start" ou "Iniciar":

Acione o botão direito do mouse no menu "Start" ou "Iniciar" e selecione a opção: Properties ou Propriedades

162

Na tela que se abre, acione o botão "Customize" ou "Customizar":

163

Use a barra de rolagem até localizar o comando Run e selecione-o:

Clique OK, Apply e OK novamente nas telas anteriores.

Isso deve fazer surgir a opção de "Run" no menu Start.

De volta ao nosso objetivo, vamos usar esta opção Run do menu Start. Na tela que se abre, vamos digitar "cmd".

164

O que deve fazer abrir uma console do sistema:

Agora, com os comandos normais do DOS, devemos nos posicionar no diretório onde o arquivo JAR foi gerado:

E lá emitir o comando para executar a nossa aplicação:

java -jar Biblioteca.jar

E o resultado esperado deve ser obtido:

165

Lembrando que o comando "java" pode ser executado de qualquer lugar, pois a sua localização está contida na variável de ambiente do sistema chamada PATH.

FIM - Este é o final do curso.

Congratulações!

Você não é mais um Iniciante em Java.

Grato por ter decidido usar este material para a sua iniciação.

Uma palavra final.

Alguns de vocês podem estar se perguntando: Mas onde está o código fonte?

Sim, é comum neste tipo de curso, um link para que os alunos façam o Download do código completo.

Sinto desapontar alguns, mas não vai ser esse o nosso caso.

A principal idéia aqui é fazer com que você pratique, e digitar o código, no nosso caso, faz parte do aprendizado.

O Eclipse possui inúmeros recursos de auxílio, dos quais vimos apenas uma pequena parte.

Quando você digita o seu próprio código, coisas inesperadas podem ocorrer, erros de digitação podem ser cometidos...

Tudo isso é bom! Vai permitir a você aprender mais.

Usem a lista de discussão para trocar idéias e dar feedback!

Java para Iniciantes

Visite este grupo

Grande Abraço.

Documents

Curso de Java básico para Iniciantes Usando Eclipse