Java com Orientação a Objetos

JAVA com Orientação a Objetos © !"#$% #!&'&#!!(% ) * + % % , , -% .% / 0 % 1 + 23% % 4 14 , 5 , 4 5 ) 6 5 ) 5* , / , 7 23% % + / % 8 / 7 % 23 / + 239 , ) 2 0 * : !"#$

JAVA com Orientação a Objetos 6 ; : %'$#'

#Informática, 2. Programação de Computador – Programas e Dados < =>;!?(@(A@B!!@$'36@1 $01.642 $$A

% !& & ' () * + ,' , * -

./&01/231/ 4.35 ../32))).6 7 4.35 ../32)80) 2! !9!&"&- :::&!&"&-

/363.

Agradecimento Inicialmente agradeço a Deus por me dar forças e condições de realizar este trabalho. Agradeço ainda a meus amigos, todos esses anos trabalhando com vocês só me fizeram uma pessoa melhor. Em especial, a minha família, a minha querida esposa Fernanda, a meu pai Alexandre, a minha mãe Leonidia, a meus irmãos e a meus queridos sobrinhos. Obrigado a todos pelo apoio tão importante que me fornecem.

Introdução Caro leitor, é um prazer apresentar para vocês a tecnologia Java e os conceitos vinculados à programação orientada a objetos. A ideia central deste livro é garantir aos estudantes da área de Ciência da Computação e afins uma forma alternativa de conhecer essa tecnologia e o paradigma que atualmente dominam parte do mercado. O livro é resultado de anos de experiência trabalhando com disciplinas ligadas à área de programação, no qual foram aplicados conhecimentos da tecnologia Java, assim como a prestação de serviços que envolviam tais elementos. Ao final da leitura deste livro, espera-se que o leitor tenha conhecimento suficiente para desenvolver e entender as aplicações que utilizam as diversas características que norteiam a tecnologia Java. Nos últimos anos, a programação Java tornou-se uma das mais populares do mercado e tem feito com que os profissionais, que dominam seus preceitos, passem a ser mais valorizados e até mesmo disputados por empresas, considerando a carência existente para tais nichos de mercado. Tal fatia de mercado, dominada pela tecnologia Java, deve-se em sua maioria às suas potencialidades, uma vez que são aplicações que podem estar presentes em desde eletrodomésticos, aparelhos celulares, carros até as mais simples, tais como as existentes na Web. Assim, a linguagem Java tem características que a tornam diferenciada, sendo de grande importância no que tange a criação de software. Diante disso, foi montado um roteiro neste livro, no qual se priorizou garantir ao leitor uma visão ampla de todos os conceitos importantes para sua iniciação na programação com a tecnologia Java. No Capítulo 1, são apresentados os fundamentos da programação com a linguagem Java, considerando elementos importantes, como, por exemplo, as palavras reservadas, estrutura básica de um programa Java e as vantagens e desvantagens de utilizar a tecnologia mantida atualmente pela Oracle. No segundo capítulo, começaremos a ver os fundamentos do paradigma de programação orientada a objetos, considerando passo a passo cada conceito, fazendo com que o leitor entenda os aspectos básicos e necessários para a continuidade no aprendizado, como, por exemplo, a ideia de classe e objetos na tecnologia Java. Continuando, no Capítulo 3, são trabalhadas

VI t JAVA com Orientação a Objetos

as estruturas mais avançadas da programação orientada a objetos, fazendo com que o leitor consiga dar mais um passo no aprendizado do paradigma e da tecnologia Java, sendo considerados conceitos, tais como construtores, destrutores e outros. Assim como no Capítulo 3, no Capítulo 4 continuaremos a trabalhar com os elementos mais avançados da programação orientada a objetos, tais como os importantíssimos conceitos de herança e polimorfismo, que devem ser vistos e tratados como elementos-chave da tecnologia Java e do paradigma de programação orientada a objetos. Claro que devemos lembrar sempre do conceito de portabilidade oriundo da estruturação muito bem pensada da tecnologia Java como um importante diferencial. Em nosso quinto capítulo, será apresentado a você, leitor, outros elementos da tecnologia Java, no qual iremos lidar com ferramentas úteis para o dia a dia de um programador. Trabalharemos nesse capítulo com bibliotecas matemáticas, números randômicos ou ainda veremos como lidar com datas, manipular strings e assim por diante. Logo, serão consideradas diversas possibilidades e vantagens que podem ser exploradas, o que com certeza irá auxiliar os programadores a dominarem tais conceitos. O Capítulo 6 tem por objetivo apresentar o trabalho de tratamento de exceções, sendo de extrema importância seu entendimento, já que se trata de um elemento central nas atividades que exigem a manipulação de dados, seja em arquivos texto, seja mesmo em um banco de dados. Este tema é de grande importância, pois a tecnologia Java possibilita, em sua programação, que sejam tratados eventuais problemas ou erros antes que estes venham a realmente ocorrer, permitindo que sejam tomadas as devidas providências para uma autorrecuperação do software durante a execução. Podemos enxergar isso como uma prevenção para os possíveis erros nos trechos mais suscetíveis a problemas. Finalizando, em nosso sétimo capítulo, começaremos a trabalhar com a manipulação de arquivos, lidando com o processo de criação, persistência de dados e leitura de dados utilizando classes e interfaces disponibilizadas pela tecnologia Java. Amigo leitor, em todo o livro tentarei manter uma linguagem mais simples, clara e cotidiana, na qual o principal objetivo e descomplicar o entendimento dos diversos conteúdos mencionados. Recomendo que sejam feitos os exemplos disponibilizados, que foram pensados considerando os aspectos que devem acompanhá-lo em sua jornada. Logo, vamos ao que interessa e tenha uma ótima leitura.

Sumário Capítulo 1 Conceitos básicos da tecnologia Java..........................1 1.1 Fundamentos da tecnologia Java ....................................................1 1.2 Estrutura e conceitos básicos da programação Java .......................5 1.3 Entrada de dados ........................................................................... 13 1.4 Estruturas de controle................................................................... 15 1.5 Arrays e matrizes ........................................................................... 21 1.6 Funções. ......................................................................................... 25

Capítulo 2 Programação orientada a objetos.............................29 2.1 Conceitos da programação orientada a objetos ........................... 30 2.1.1 Classe .......................................................................................... 32 2.1.1.1 Qualificadores de acesso ......................................................... 33 2.1.1.2 Pacotes ..................................................................................... 35 2.1.1.3 Import...................................................................................... 36 2.1.1.4 Comentários ............................................................................ 37 2.1.2 Atributos ..................................................................................... 38 2.1.3 Métodos ...................................................................................... 39 2.1.3.1 Identificador this ..................................................................... 40 2.1.4 Mensagem e modularização de código ...................................... 41 2.1.5 Objeto ou instanciação............................................................... 44

Capítulo 3 Construtores, destrutores e encapsulamento............51 3.1 Construtores .................................................................................. 51 3.2 Destrutores e Garbage Collector (Coletor de Lixo) ...................... 54 3.2.1 Garbage Collector ....................................................................... 55 3.3 Encapsulamento ............................................................................ 56

VIII t JAVA com Orientação a Objetos

Capítulo 4 Herança, polimorfismo e interface...........................63 4.1 Herança .......................................................................................... 63 4.2 Polimorfismo ................................................................................. 69 4.2.1 Sobrecarga .................................................................................. 70 4.2.2 Cast ............................................................................................. 71 4.2.3 instanceof ................................................................................... 73 4.2.4 Sobrecarga de construtores ....................................................... 74 4.2.5 Redefinição ................................................................................. 74 4.3 Interface ......................................................................................... 76 4.3.1 Herança múltipla ........................................................................ 83

Capítulo 5 Ferramentas úteis para o dia a dia............................85 5.1 Manipulação de strings ................................................................. 85 5.1.1 Construtores da classe String .................................................... 86 5.1.2 Outros métodos.......................................................................... 86 5.2 Data e hora ..................................................................................... 88 5.3 Operações matemáticas ................................................................ 93 5.4 Trabalho com vetores especiais .................................................... 95 5.4.1 Classe Vector............................................................................... 96 5.4.2 Classe HashMap ......................................................................... 98 5.4.3 Classe Arrays .............................................................................. 99

Capítulo 6 Tratamento de exceções e entrada de dados............101 6.1 Tratadores de exceções ................................................................ 102 6.1.1 Throws....................................................................................... 106 6.2 Entrada de dados ......................................................................... 107

SumáriotIX

Capítulo 7 Manipulação de arquivos de texto ..........................111 7.1 Arquivos ....................................................................................... 111 7.2 Entradas ....................................................................................... 112 7.3 Saídas ........................................................................................... 114 7.4 Streams ........................................................................................ 116 7.5 Acessos aleatórios em arquivos .................................................. 118

Referências Bibliográficas................121 Apêndice I Instalação do Sdk e Configuração das Variáveis de Ambiente (Windows Xp) .................................................................................... 123

Apêndice II JAVADOC ........................................................................................... 129

Capítulo 1 Conceitos básicos da tecnologia Java Quando falamos em programação, não há como deixar de vislumbrar tal atividade como sendo um elemento central na vida de um profissional ligado à área de Ciência da Computação e afins. No cotidiano, o mínimo que se espera de um profissional de TI é que este domine os elementos e os conceitos básicos, aplicados a uma determinada linguagem de programação. O mercado atualmente oferta uma infinidade de possibilidades de linguagens de programação para a construção de softwares, indo das mais complexas e trabalhosas até as mais simples. Existem, entre essas linguagens de programação, várias que são bem aceitas no mercado, que consideram obviamente variáveis estratégicas, tais como preço, velocidade da curva de aprendizagem e desenvolvimento. Entre tais, a linguagem e a plataforma de desenvolvimento de aplicações Java vêm no decorrer dos anos tornado-se uma das mais utilizadas e aceitas no mercado. Isso, graças ao seu potencial tecnológico combinado ao paradigma de orientações a objetos, além de considerar os custos envolvidos. O Java é uma tecnologia que foi originalmente desenvolvida pela Sun Microsystem em meados de 1995, sendo regida pela GPL (General Public License). A Oracle Corporation adquiriu todos os direitos pela Sun e obviamente, também sobre a tecnologia Java. Para a maioria dos autores e desenvolvedores, a tecnologia Java pode ser definida como: “simples, distribuída, interpretada, robusta, segura, de arquitetura neutra, portátil, multifunções e dinâmica“. Ao considerar tais perspectivas, o objetivo deste capítulo é apresentar e preparar o leitor para compreender e aplicar os fundamentos básicos da tecnologia Java. Estes são úteis e de extrema importância para a compreensão dos demais conceitos vinculados à plataforma de desenvolvimento mantida pela Oracle e que serão considerados nos próximos capítulos de nosso livro. 1.1 Fundamentos da tecnologia Java A maioria dos autores restringe-se a citar que o Java consiste em uma

2 t JAVA com Orientação a Objetos

linguagem de programação orientada a objetos baseada na sintaxe da linguagem de programação C. Porém, podemos ir além disso ao citar que o Java é uma plataforma tecnológica que possui diversas características que o mercado considera como importante e que devido a isto, tem garantido uma fatia considerável das aplicações desenvolvidas com essa tecnologia. Com certeza, pode-se afirmar que a característica que mais se destaca neste processo e a torna diferenciada diante das demais linguagens consiste na portabilidade dos sistemas desenvolvidos com o Java. Entende-se portabilidade como, nada mais nada menos, a independência de plataforma - no caso, o sistema operacional (Windows, Linux, Solaris, MAC OS) e o hardware, no qual os softwares serão executados. Tal característica nasce do fato da estrutura das aplicações desenvolvidas com a tecnologia Java ser inicialmente compilada e depois, interpretada. Indo um pouco mais além no entendimento, o ponto central desse processo esta na geração do bytecode, também conhecido como arquivo com extensão “.class”. Este é obtido ou gerado por meio da compilação do código-fonte dos arquivos “java puros” ou de extensão “.java”, que serão interpretados futuramente. É importante mencionar que com isso, graças ao fato da tecnologia Java possuir para cada plataforma (sistema operacional + hardware) uma Máquina Virtual Java, também conhecida como Java Virtual Machine (JVM), este processo torna todas as aplicações Java portáveis entre si. Assim, quem irá preocupar-se com as especificidades de cada plataforma não é mais o programador, mas sim a JVM fornecida. Essa máquina virtual é capaz de interpretar os arquivos compilados (“.class”), iniciando a execução do software, independentemente da plataforma na qual o programa foi construído. Por exemplo, uma vez compilado nosso programa utilizando o sistema operacional Windows em uma estrutura de hardware da família x86, caso queiramos que nosso programa rode em uma máquina com o sistema operacional Linux, não será necessário realizar uma nova compilação para este software, como acontece com as outras tecnologias e linguagens de programação. Neste contexto, será apenas necessária a presença da JVM para o Linux instalado, o que hoje é algo natural nas máquinas comercializadas. Como o leitor pode reparar, esta característica ímpar só é possível graças à existência da JVM, que é fornecida pela tecnologia Java e na qual cada sistema operacional possui uma específica, distribuída pela mantenedora da tecnologia. A JVM pode ser vista como sendo uma camada intermediária

Capítulo 1 - Conceitos básicos da tecnologia Javat3

entre sua aplicação e a plataforma que executará seu programa. A maioria dos computadores atuais já é vendida com algum tipo de Máquina Virtual Java e isso tem garantido uma popularização ainda maior das aplicações Java, o que nos faz crer que, em sua maioria, qualquer aplicação Java funcionará corretamente nos computadores obtidos atualmente no mercado. Para uma melhor visualização do processo citado como portabilidade, a Figura 1 demonstra o modelo computacional definido pela tecnologia Java e suas aplicações. Vamos conferir?

Figura 1: Estrutura de compilação e execução de programas no Java.

Como definição, podemos mencionar que um programa Java consiste em um conjunto de instruções, que a JVM é responsável por interpretar e dessa forma, garantir a independência de plataforma na qual o programa foi construído e será executado. Isto é, basta que haja uma implementação de uma máquina virtual para a plataforma ser utilizada. O termo plataforma, como já vimos, normalmente no meio computacional é definido como a combinação de sistema operacional mais hardware. Porém, para a plataforma Java, ela é definida somente com o software, por isso o conceito de máquina virtual. A plataforma Java possui dois componentes que precisamos conhecer quando a adquirimos, sendo:


Máquina Virtual Java (JVM): A máquina imaginária que é implementada por meio da emulação em um software executado em uma máquina real e que fornece as especificações da plataforma de hardware para a qual todo o código Java está compilado. A JVM faz parte do ambiente de execução Java, mais popularmente conhecido como JRE (Java Run-Time Environment); Interface para Desenvolvimento de Aplicações (API Java): Trata-se das interfaces de desenvolvimento para a utilização na criação de aplicações Java, no caso são as bibliotecas para a criação de programas que a própria linguagem Java fornece, disponibilizados por meio do JDK (Java Development Kit) ou como vem sendo disponibilizado nos últimos anos como SDK (Source Development Kit). Para o desenvolvimento de aplicações Java, é necessário que se tenha instalado no computador o SDK. Desta forma, obtenha uma cópia na página oficial da Oracle e instale em seu computador. O Apêndice deste livro contém mais informações sobre o processo de instalação do pacote SDK, assim como a configuração das variáveis de ambiente necessárias para a correta utilização do conjunto de ferramentas da tecnologia Java.

Após a correta instalação e configuração das variáveis de ambiente do SDK, podemos usar um editor de texto qualquer para a construção do código de nosso programa Java. Porém, existem diversos ambientes de desenvolvimento, também conhecidos como IDE (Integrated Development Environment), para a programação Java, sendo que os mais utilizados no mercado são: Eclipse, NetBeans e JBuilder. Como nossa intenção consiste no aprendizado da linguagem Java, não nos apegaremos a nenhuma IDE, o que deixa você, leitor, livre para a utilização ou não de uma dessas ferramentas de desenvolvimento, sendo que apenas um editor de texto será suficiente para concluir o aprendizado deste livro. Um aspecto importante a ser citado aqui é que a linguagem Java possui diferentes tipos de programas, sendo que a classificação é feita por meio da modalidade X localização de execução dos mesmos. Assim, esses programas podem ser definidos como: applications, applets e servlets. Nesta unidade, somente trabalharemos com as applications no console, ou seja, prompt de comando, seja Windows, seja Linux.


1.2 Estrutura e conceitos básicos da programação Java Agora, vamos ao que interessa. Nesta seção do livro, vamos aprender como são construídas as estruturas básicas para os programas escritos na linguagem Java, além de conhecer os conceitos mais básicos da programação com a tecnologia. O primeiro detalhe que deve ser considerado na linguagem consiste no fato de que todo programa Java é uma classe, independentemente das três possíveis modalidades dos programas Java citadas anteriormente (Applications, Applets e Servlets). A estrutura básica é sempre a mesma: “uma classe”. Um programa Java é organizado em arquivos de texto com a extensão “.java” e cada arquivo pode conter várias classes, mas usualmente teremos apenas uma. Aqui, temos uma consideração importante e que você não deve esquecer jamais: O nome do arquivo da classe java deve possuir exatamente o mesmo nome que foi dado internamente à classe, pois a máquina virtual procura a classe por meio do nome do arquivo.

Uma metodologia que pode auxiliá-lo a entender a tecnologia Java neste momento consiste na utilização de analogias com outras linguagens de programação, das quais você já tenha conhecimento e domínio. Então, vamos a elas! Se fôssemos realizar uma comparação básica, poderíamos dizer que as classes no Java podem ser comparadas às famosas units do Pascal. Já para os adeptos do C e C++, a estrutura de nossos programas praticamente será a mesma, uma vez que a tecnologia Java está baseada em tais linguagens. Ainda, veremos mais à frente em nossos capítulos que os atributos no Java são como as variáveis existentes em Pascal e C, e os métodos das classes Java seriam os procedimentos e as funções da linguagem C e Pascal. Vários destes aspectos citados serão considerados quando estivermos tratando do conceito de orientação a objetos. Outro detalhe a ser considerado é a definição de blocos de código que, no Java, são definidos com a utilização de “{“ e “}”, assemelhando-se assim ao C ou C++, diferentemente dos elementos em Pascal, que utilizam no caso, “BEGIN” e “END”. Por enquanto, preocupe-se apenas em entender como os blocos são definidos, sendo de extrema importância para começarmos a


entender os conceitos fundamentais para a construção de programas simples com a tecnologia Java. Então, diante disso, vamos ao que interessa. Chegou a hora de desenvolvermos nosso primeiro programa em Java. Transcreva o conteúdo abaixo para um editor de texto simples, tal como o ‘notepad’ do Windows ou mesmo o ‘Vi’ do Linux. Por enquanto, siga o exemplo conforme é apresentado, digitando como pode ser observado na primeira coluna, visto que a linguagem Java é case sensitive, ou seja, existem diferenças entre as letras maiúsculas e minúsculas em sua compilação e interpretação. A seguir, faremos uma análise do que foi feito em nosso primeiro programa.

//Classe PrimeiroPrograma.java class PrimeiroPrograma{ public static void main (String arg []){ System.out.println(“Olá leitor”); } }

Agora que você já construiu seu primeiro programa em Java e considerando o que já foi citado anteriormente neste capítulo, salve seu programa lembrando que o nome do arquivo Java deve ser necessariamente igual ao nome de declaração da classe - no caso específico, o arquivo deve ser salvo como “PrimeiroPrograma.java”. Salve o arquivo tomando o cuidado necessário para assegurar que a extensão “.java” seja garantida por seu editor de textos, uma vez que eles podem manter a extensão “.txt” e isso impedirá a compilação e a interpretação de seu programa. Feito isso, vamos à explicação de nosso programa, entendendo o código apresentado. Para que você tenha um programa executável construído com a linguagem Java, sua classe deve sempre possuir um método específico, que caracteriza a classe como uma aplicação que a Máquina Virtual Java deverá interpretar no momento da execução do programa. Todo programa/ classe Java que possuir a função executável ou, como veremos nos capítulos seguintes, o método executável com a assinatura “public static void main (String[] args){ }” apresentada na linha 3 de nosso código anterior, será considerado um programa executável pela JVM.


Logo, este trecho será executado automaticamente quando for encontrado no programa submetido à maquina virtual. Um detalhe importante que deve ser comentado nesse trecho trata-se do vetor (array) “String[] args”. Esse trecho presente na assinatura de nossa função executável pode conter parâmetros, que foram passados pela linha de comando na execução de nosso programa. Demonstraremos isso a seguir. Outro detalhe a ser destacado e que você deve reparar no código apresentado, está no fato de que, por convenção, ou seja, algo aceito por todos os programadores Java, os nomes das classes no Java são sempre iniciados com letra maiúscula e, caso venham a ser compostos, cada nova palavra será iniciada novamente com uma letra maiúscula, definindo seu início. Note que isso é feito em nosso código anterior e, diante disso, passe a adotar em seus programas Java. Na quarta linha de nosso primeiro programa, é apresentada a linha System.out.println(“Olá leitor”);, que nada mais faz do que realizar a impressão em console. Esse comando informa ao sistema (System) que será realizada uma operação de saída (out), sendo que tal operação consiste em uma impressão com quebra de linha (println). Existem outras possibilidades de realizar a impressão em console Java e estaremos lidando com elas no momento certo. Então, memorize a linha demonstrada, pois sempre iremos utilizar essa linha de código quando quisermos realizar a impressão em console em nossos próximos programas. Certo pessoal, até aqui conseguimos vencer uma parte importante de nosso primeiro capítulo, considerando que os aspectos citados são comuns a qualquer programa Java que você venha a construir de agora em diante. Mas, está faltando visualizarmos o resultado de nosso primeiro programa. Para isso. teremos de compilar e interpretar nosso programa e, logo, necessitamos de outras ferramentas. Existem dois comandos básicos que a tecnologia Java fornece por meio do JDK para tais funções, sendo: javac e java, respectivamente. Tais comandos só funcionarão em seu prompt de comando, como, por exemplo, o DOS do Windows, depois de definidas as variáveis de ambiente, para que os comandos estejam disponíveis em qualquer caminho de seu sistema operacional, sendo: t

JAVA_HOME: Deve conter o caminho da pasta, na qual foi instalado o SDK, ou seja, o local onde possui todas as ferramentas e APIs básicas fornecidas pela tecnologia Java em seu computador;


t

CLASSPATH: Deve conter o caminho no qual estão localizadas as bibliotecas dos programas que você está utilizando. Por padrão, o valor desta variável é apenas “.”, que significa que as bibliotecas utilizadas estão na mesma pasta da aplicação que você está desenvolvendo. Caso seja necessário, incremente a essa variável os caminhos nos quais existam outras APIs importantes para o desenvolvimento de sua aplicação, que podem ter sido adquiridas na Internet, por exemplo.

Para que você obtenha maiores informações sobre a criação de variáveis de ambiente, disponibilizamos, ao final deste livro, no ANEXO I, um tutorial sobre o assunto. Além disso, podem ser encontrados na Internet diversos tutoriais sobre o assunto, sendo que sempre devemos levar em consideração o sistema operacional a ser utilizado no momento do desenvolvimento e da configuração. Uma vez que o JDK está instalado corretamente e foram definidas as variáveis de ambiente, estamos prontos para compilar e executar nosso primeiro programa. Assim, digite os comandos apresentados abaixo em um prompt de comando do seu sistema operacional, considerando que no prompt, devemos estar no diretório no qual são mantidas nossas classes. Em nosso exemplo, a classe PrimeiroPrograma.java está no diretório c:/>programas.

javac PrimeiroPrograma.java java PrimeiroPrograma

O primeiro comando apresentado consiste no javac que irá realizar a compilação de sua classe. Já o segundo comando apresentado, java, irá realizar a interpretação do bytecode gerado por meio da compilação, conforme a estrutura apresentada na Figura 1. Certo! Se tudo ocorreu conforme o esperado, será impresso o texto “Olá leitor”, como é apresentado na imagem a seguir.


Caso o leitor tenha dúvidas sobre como realizar a navegação nos diretórios de seu computador, indicamos a leitura de qualquer tutorial que auxilie na manipulação de comandos na linha de comando de seu sistema operacional. Mas, outro ponto importante na construção de uma aplicação no Java, ou seja, na construção das classes e que deve ser considerado para darmos um passo adiante em nosso aprendizado consiste na definição das variáveis de uma classe Java. Em muitos momentos, conforme já mencionamos, as variáveis na linguagem Java aparecerão nos textos, livros e tutoriais, sendo tratadas como atributos. Logo, qual a diferença entre atributos e variáveis? A diferença entre eles é que um atributo está intrinsecamente ligado às características da classe, ou seja, descreve algo ligado ao contexto ou à ideia central à qual a classe está relacionada ou preocupa-se em descrever. Um exemplo seria um atributo para manter os dados de RG de uma pessoa. Já as variáveis não precisam ser aplicadas necessariamente a um contexto da classe, como, por exemplo, em uma variável auxiliar para o comando de repetição FOR ou mesmo uma constante. Por enquanto, não se preocupe com isso, pois no decorrer da disciplina, essa diferença se tornará mais clara e logo você saberá diferenciar tais elementos de programação com base nos paradigmas da orientação a objetos. Em continuidade ao nosso aprendizado sobre os conceitos básicos da tecnologia Java, vamos por a mão na massa e criar nosso segundo programa, utilizando o armazenamento em memória com variáveis. Transcreva o código a seguir para um editor de texto, assim como fizemos em nosso primeiro programa. Depois disso, compile e execute-o por meio dos comandos javac e java, respectivamente, em um prompt de comando de seu sistema


operacional, conforme realizado no exemplo anterior. Não se esqueça: Para que você consiga executar tais comandos seguido do nome de seu programa, aqui SegundoPrograma.java, você deve estar localizado no diretório no qual a classe se encontra, no caso onde foi salva. Fique atento também ao fato mencionado de que o nome de nosso arquivo Java deve ser igual ao da classe - neste exemplo, nosso arquivo Java deve ser nomeado como SegundoPrograma.java.

// SegundoPrograma.java class SegundoPrograma{ public static void main (String arg []){ int a = 5; a = 5+10; System.out.println(“O valor é:”+a); } }

No código de nosso segundo programa, começamos a manipular o armazenamento na memória volátil, ou seja, a criação de variáveis. No programa, foi inicialmente criada uma variável do tipo inteiro ‘a’, que recebe uma atribuição de valor, no caso o valor ‘5’. Depois, na quarta linha de nosso segundo programa, é feita uma operação cujo resultado é armazenado na mesma variável ‘a’, que é impressa na linha seguinte. Note que, em regra, quando se quer definir variáveis, constantes e mesmo atributos no Java, como veremos nos conceitos de orientação a objetos, em primeiro lugar você deve informar o tipo de dado que será mantido, no caso String, int ou qualquer outro tipo de dados, sendo ele primitivo ou não. Depois, é dado o nome de acesso à variável e finalmente, atribuímos um valor inicial ou não, conforme é apresentado a seguir.

Tipo variável = ValorInicial; final tipo CONSTANTE = Valor;


Na segunda linha de nossa caixa anterior, a palavra reservada final determina que tal variável não sofrerá alterações, sendo mantido o valor atribuído no momento de sua declaração, consistindo assim em uma constante para todo o programa, enquanto este estiver em execução. Outro detalhe importante que você deve saber e nunca mais esquecer é que o Java é uma linguagem de programação fortemente orientada a objetos e com exceção dos tipos primitivos, “qualquer” coisa no Java consiste em uma classe/objeto. Devemos destacar que existem várias palavras que são reservadas pela linguagem Java e elas não podem ser utilizadas em vários momentos em seu programa, como, por exemplo, na definição de nome dos atributos, classes ou outros elementos. Tais palavras reservadas são apresentadas na Tabela 1 a seguir. Tabela 1. Palavras reservadas. abstract

double

int

strictfp

boolean

else

interface

super

break

extends

long

switch

byte

native

synchronized

case

new

this

catch

package

throw

char

for

private

throws

class

goto

protected

transient

const

if

public

try

continue

implements

return

void

default

import

short

volatile

do

instanceof

static

while

Várias dessas palavras reservadas são elementos naturais em outras linguagens de programação, principalmente na linguagem C. Assim, o leitor que já possui algum domínio do C ou C++, não terá dificuldades com a manipulação das palavras reservadas no Java. Outro ponto importante no Java é que devem ser considerados, uma vez que são extremamente necessários, os operadores matemáticos. No caso, utilizamos os operadores +, -, * e / para realizarmos as operações matemáticas básicas, ou seja, soma, subtração, multiplicação e divisão, respectivamente. No Capítulo 5, iremos trabalhar com a API Math, que possibilitará a você realizar operações matemáticas mais complexas. Devemos ainda considerar


outros operadores que são de suma importância para a linguagem Java, estando relacionados principalmente ao processo lógico dentro de nossos programas, como no caso dos testes condicionais, sendo que os mais utilizados são listados no quadro da Tabela 2. Tabela 2. Operadores no Java. OPERADORES

DESCRIÇÃO

==

Igualdade

!=

Diferente

>

Maior

<

Menor

>=

Maior igual

<=

Menor igual

!

Negação

&&

E lógico

||

Ou lógico

Entre as várias considerações que podem ser feitas quanto ao uso dos operadores, devemos destacar ainda a outra funcionalidade atribuída ao operador “+”, que consiste na concatenação de Strings, como pode ser observado em nosso próximo exemplo. Conforme mencionado anteriormente e como pode ser vislumbrado na Tabela 1, uma String não é um tipo primitivo, mas sim uma classe. Logo, você deve estar perguntando-se: “Então, qual a diferença entre um tipo primitivo e uma classe”? Existem várias diferenças que poderiam ser citadas, mas como diversas delas estão relacionadas ao conceito de orientação a objetos, do qual ainda não tratamos, vamos prender-nos inicialmente à diferença de que uma classe geralmente agrega funcionalidades das quais os tipos primitivos não dispõem. Essas funcionalidades, no caso, são denominadas de métodos e que conheceremos mais profundamente no Capitulo 2. Um exemplo que demonstra essa diferença com a utilização de uma funcionalidade pode ser observado no exemplo a seguir, no qual é realizada a conversão de uma String em um inteiro, sendo de extrema importância para os vários programas que iremos construir. Logo, tente memorizar tal funcionalidade da classe Integer.


// TerceiroPrograma.java public class TerceiroPrograma { public static void main(String args[]){ String entrada = “1”; entrada = entrada+”1”; Integer numero = Integer.parseInt(entrada); System.out.println(entrada); System.out.println(numero); }

}

Note que no exemplo anterior, é criada uma variável do tipo String denominada entrada, que recebe o caractere “1”. Note que não é um número, mas sim um caractere. Em nossa segunda linha do exemplo, o valor existente na variável de entrada é concatenado a um novo caractere, no caso “1”. Note que o resultado dessa operação matematicamente seria o valor 2, mas, no caso, por se tratar de manipulação, em específico uma concatenação, o valor mantido na variável será “11”, pois não estamos lidando com uma operação matemática. Na terceira linha é feita a transformação desse conjunto de caracteres em um tipo número, que possibilitará as operações matemáticas. Nas duas últimas linhas do exemplo são realizadas as impressões em console dos valores existentes nas duas variáveis do programa. 1.3 Entrada de dados Bom pessoal, um importante aspecto de qualquer programa computacional consiste na entrada de dados. Pois bem, a primeira coisa a ser feita é conhecer a classe Scanner do pacote java.util. A classe Scanner possibilita que seja realizada a leitura dos dados procedentes tanto do teclado quanto de outras fontes como arquivos de texto. A Scanner passou a ser disponibilizada a partir da distribuição Java 5, na qual se buscou simplificar todo o trabalho com a manipulação de dados oriundos de fontes de dados, no caso as streams vindas do sistema (System.in) ou mesmo de arquivos de texto. Pois bem, nada como um exemplo para que possamos memorizar todos os conceitos e detalhes vinculados à classe Scanner. Assim, transcreva o código a seguir e execute, observando a utilização de nossa nova funcionalidade.


//QuartoPrograma.java import java.util.Scanner; class QuartoPrograma{ public static void main(String[] arg){ Scanner entrada = new Scanner(System.in); System.out.println(“Digite um numero “); //lendo o número digitado no teclado int valor = entrada.nextInt(); System.out.println(“o numero digitado “ + valor); } }

Repare que em nosso exemplo anterior, surgiu um novo elemento que está relacionado à importação de uma classe para sua utilização. Este conceito ficará mais claro em nosso próximo capítulo quando estivermos falando sobre os conceitos relacionados à mensagem entre as classes por meio de métodos. Mas, voltando ao exemplo, repare que na quarta linha é criada uma variável denominada entrada do tipo Scanner, que é inicializada ‘escutando’ as entradas do sistema (System.in). Repare que na sexta linha de nosso programa, por meio da função ou do método nextInt( ) da variável de entrada, o valor digitado pelo usuário será atribuído à variável valor, que será impressa na linha seguinte. No momento da execução do programa, você irá reparar que logo após ser impressa a mensagem solicitando que o usuário digite um número, o programa aguardará a entrada do valor. Isso se deve às características do método nextInt( ) da classe Scanner. Um ponto importante a ser citado está no fato de que, assim como no caso das impressões no console, existem outras possibilidades para realizar a entrada de dados no Java, porém, com certeza, a utilização da classe Scanner é a mais simples. Portanto, em nossos exemplos iniciais, a utilização da classe Scanner será o suficiente até que conheçamos as outras possibilidades e você escolha qual a mais adequada para seus programas.


1.4 Estruturas de controle Certo pessoal, chegamos a um ponto importante de sua leitura, no qual iremos aprender a trabalhar com uma das características mais importantes em um programa, que consiste nas estruturas de controle. Agora, comentaremos sobre os famosos if/else, switch, while, do-while e for. Podemos mais uma vez considerar a relação de analogia para entender estes comandos. Essencialmente, a única diferença desses comandos no Java para a programação em Pascal está nos indicadores de bloco “{” e “}”, sendo, porém, semelhantes em C ou C++. Então, vamos trabalhar com cada um deles. O primeiro consiste no comando de seleção if que possibilita que um programa analise se uma expressão lógica é verdadeira ou falsa e a partir disto, direcione a execução de seu programa. A estrutura do if trabalha com a perspectiva de acontecimentos, logo, realiza o que sua tradução do inglês, que é “Se”, se propõe. Sendo mais detalhista, trata-se de uma estrutura na qual, “Se” a expressão lógica do comando for verdadeira, a sequência natural do if será executada. Porém, “Se” a expressão lógica for falsa, surgirá um novo elemento na estrutura, que consiste na cláusula else (então). Essa cláusula será executada na sequência do if, obviamente se ela tiver sido implementada. if (expressão_lógica){ Sequência 1; }else{ Sequência 2; }

Para que não existam dúvidas, vamos a um pequeno exemplo de fixação dos conceitos do comando de seleção if/else.


//Classe ExemploIf.java class ExemploIf{ public static void main (String[] args){ if (args.length > 0){ System.out.println(“Dentro do if”); }else{ System.out.println(“Dentro do else”); } } }

Assim como fizemos em nossos exemplos anteriores, salve sua classe com o nome “ExemploIf.java” e utilize os comandos javac e java, respectivamente, para a compilação e a execução de seu programa, conforme é apresentado na figura a seguir.

Repare que em nossa figura anterior, junto ao comando java e ao nome da classe, consta um conjunto de valores “Teste do if/else”. Estes, por sua vez, são os argumentos passados para o programa durante a execução, que podem ser acessados por meio do vetor de String “args”, presente na assinatura do método principal void main. No exemplo apresentado no código java, o código dentro do bloco definido pela cláusula if só será realizado caso, pelo menos, um argumento seja passado no momento da execução do programa, do contrário, o vetor args estará vazio e o bloco da cláusula else será executado.


Outra interessante estrutura de seleção que deve ser mencionada consiste na cláusula switch. A switch é equivalente de maneira lógica a um conjunto de cláusulas if organizadas de forma encadeada e isso é usualmente mais eficiente durante uma execução de um programa. A expressão utilizada pelo switch deve retornar necessariamente um resultado ordinal, ou seja, classificado em um dos possíveis blocos da cláusula, mais conhecidos como “case”. As diretivas encontradas a partir do caso escolhido são executadas até o final da cláusula switch ou até uma ordem de “break” que encerra a cláusula. Se o valor a ser testado não possuir um caso específico, então será executada a diretiva default, que é opcional, sendo colocada ao final da cláusula switch, após todos os casos de classificação possíveis. Assim, para um melhor entendimento do mencionado, vamos a mais um exemplo.

/Classe ExemploSwitch.java class ExemploSwitch{ public static void main (String args[]){ switch(args[0].charAt(0)) { case ‘A’:System.out.println(“Vogal A”); break; case ‘E’:System.out.println(“Vogal E”); break; default:System.out.println(“Não é vogal”); } }

} Repare que, em nosso exemplo, trabalhamos mais uma vez com a utilização do vetor args, ao qual os valores são passados durante a execução, conforme feito no exemplo para a cláusula if. Aqui, nosso programa faz uma verificação se a vogal presente na primeira posição do vetor é a vogal ‘A’ ou ‘E’, ou seja, realiza a classificação dos valores testados. É interessante mencionarmos a existência da diretiva default no exemplo, que será executada se nenhum dos casos for realizado. Então, salve seu programa e execute, conforme apresentado a seguir.


Veja que neste exemplo, fizemos uso mais uma vez dos argumentos para passar valores para que sejam verificados em nosso programa, em específico a vogal ‘A’. Prosseguindo, outra estrutura a ser mencionada no Java é a estrutura de repetição condicional while. O while consiste em uma cláusula na qual seu bloco será executado durante ou ‘ENQUANTO’ a expressão lógica a ser testada for verdadeira. A execução do bloco só será realizada desde que a expressão lógica analisada seja verdadeira. A síntaxe para a estrutura de repetição while é descrita a seguir. while ( expressão lógica ){ Sequência; }

Assim, mais uma vez iremos recorrer a um exemplo para a fixação desta estrutura de controle de fluxo. No programa abaixo, iremos imprimir os valores menores que o passado no argumento durante a execução para nosso programa. //Classe ExemploWhile.java class ExemploWhile{ public static void main (String args[]){ int j = 10;


while (j > Integer.parseInt(args[0])){ System.out.println(«»+j); j--; } } }

Outra possibilidade na linguagem de programação Java para a estrutura de repetição while consiste na estrutura do-while, que pode ser utilizada como uma condição ao final do loop. Essa estrutura está intrinsecamente ligada à tradução dos termos, que é: “faça/enquanto”. Isso faz com que tenhamos a garantia de que o bloco de código definido será executado ao menos uma vez. No caso, ambas as estruturas apresentadas, while e do-while são repetições baseadas em condições lógicas. Observe a seguir a síntaxe da estrutura do-while. do{ Sequência; } while (expressão_lógica);

Vamos brincar com a estrutura do-while? Então, transcreva o código abaixo, compile e execute-o.

//ExemploDoWhile.java public class ExemploDoWhile { public static void main (String args[]) { int min, max; Scanner entradas = new Scanner(System.in); System.out.print(“Digite o valor minimo:”); min = entradas.nextInt(); System.out.print(“Digite o valor maximo:”); max = entradas.nextInt(); do { System.out.println(“” + min + “ < “ + max); min++;


max--; } while (min < max); System.out.println(“” + min + “ < “ + max + “ Condicao invalida.”); } }

No exemplo, são capturados dois valores vindos do teclado. O mais importante de nosso exemplo está na cláusula do-while, que irá imprimir os valores mínimo e máximo passados, e que serão impressos em tela e decrementados, pois fazem parte do bloco “do”, ou seja, o bloco será executado ao menos uma vez. Diante disso, outras impressões só ocorrerão caso a condição existente na diretiva while seja satisfeita. Repare, na figura a seguir, a execução do código proposto.

Porém, existem situações nas quais a repetição necessita ser apenas incremental e decremental, obviamente com uma condição de parada para ambos os casos. Para estes momentos, a estrutura ‘for’ executará a sequência do comando enquanto a expressão lógica for verdadeira. Um fato interessante que deve ser comentado sobre essa estrutura é a possibilidade da criação e da inicialização da variável de controle na entrada do comando. Ela será utilizada para o controle da condição, sendo incrementada ou decrementada a cada repetição. A seguir observe a estrutura de repetição ‘for’.


for(inicialização; condição; incremento/decremento){ Sequência; }

Assim como nos exemplos anteriores, vejamos uma aplicação dessa estrutura.

//Classe ExemploFor.java class ExemploFor{ public static void main (String args[]){ for (int j=0; j<10; j++){ System.out.println(j); } } }

Repare que na condição a ser satisfeita, foi inicializada uma variável ‘j’ que irá auxiliar no processo de controle com o seu incremento. O mesmo poderia ser feito com o decremento do valor atribuído a ‘j’. No caso, no Java, assim como em C ou C++, o incremento e o decremento podem ser obtidos apenas com a utilização dos comandos ‘j++’ ou ‘j- -’. 1.5 Arrays e matrizes Agora, em nosso primeiro capítulo, trabalharemos com os arrays ou também conhecidos como vetores e matrizes, que nada mais são que vetores multidimensionais. No caso, os arrays são vistos como estruturas homogêneas e estáticas, ou seja, mantêm uma estrutura regular que não muda de tamanho. Logo, o espaço destinado aos armazenamentos de valores, bem como o tipo de dado, é sempre do mesmo tipo do início ao fim da vida do programa. A primeira posição de um vetor no Java consiste na posição 0. A


linguagem disponibiliza diversas propriedades que podem ser úteis na manipulação de vetores, uma vez que sua criação é muito simples, como veremos no exemplo a seguir. Uma das propriedades mais importantes de um array é length, que representa o tamanho de seu vetor. Ela se torna útil, pois além de verificar qual o tamanho do vetor, auxilia no acesso a determinadas posições, como, por exemplo, a última, que iremos acessar como (length – 1). Mas, vamos ao que realmente interessa, que é conhecer a sintaxe de criação de nossos vetores, bem como verificar sua manipulação. Para isso, o código abaixo demonstra a utilização dos arrays no Java. //Classe ExemploArray.java class ExemploArray{ public static void main(String[] args){ int[] vetor = new int[ 10 ]; System.out.println(“Tamanho vetor:”+vetor. length); for (int i = 0; i < vetor.length; i++) { vetor[i] = i; System.out.println(vetor[i]); } } }

Uma vez executado como feito anteriormente, nosso exemplo define um vetor com 10 posições do tipo inteiro. Repare que a definição do espaço de memória para tal vetor depende da utilização da sintaxe ‘[ ]’. Várias podem ser as possibilidades de utilização dos vetores, que, como mencionado, consistem em um espaço de memória destinado ao armazenamento de valores durante a execução, auxiliando na organização de nossos programas, como exemplificado com a utilização do comando for. Eles serão muito úteis em exemplos nos quais não são utilizados conceitos relacionados ao banco de dados, pois auxiliam na manutenção dos valores durante a execução. No caso, teremos acesso sempre a uma determinada posição, sendo que podemos considerar um vetor como uma linha na qual iremos acessar um endereço de memória mantido em sequência, como demonstrado abaixo.


0 10

1 20

2 50

3 70

4

5

6

7

8

9

Assim, se acessarmos o vetor em sua segunda posição, obteremos o valor 50. Outro detalhe a ser mencionado na definição de valores para um vetor é que estes podem ser inseridos no vetor no momento da definição de seu tamanho, no momento de sua criação. No caso, execute o exemplo a seguir e observe seu funcionamento.

//Classe NovoVetor.java class VetorInicializado{ public static void main(String[] args){ double[] nota = {7,8, 8,4, 4,2, 1,8, 6,4}; for(int i=0; i < nota.length-1;i++) System.out.println(“Valor no vetor:”+nota[i]); } }

Repare que no exemplo, o tamanho do vetor apresentado é definido pelos valores que serão armazenados e passados entre { }. No caso, teremos um vetor com 5 posições, no qual sua instanciação é realizada no momento de sua definição com valores do tipo double. Ainda no exemplo anterior, é importante mencionar que devido à nossa estrutura de repetição ‘for’ possuir apenas uma linha definida em seu bloco, no caso a impressão dos valores do vetor, não é necessária a delimitação do bloco de escopo da estrutura com os caracteres “{” “}”. Certo, mas e quanto às matrizes? Quando falamos sobre matrizes no Java, devemos ter em mente um aspecto importante que, porém, não impedirá ou dificultará seu trabalho. O fato é que a linguagem Java possui somente arrays unidimensionais, sendo que para a criação de arrays multidimensionais, ou seja, matrizes, o que podemos fazer é criar ou simular “pseudomatrizes” por meio da definição de um array de arrays.


Obviamente que isso passa de maneira despercebida na construção de suas matrizes, sendo apenas uma estruturação interna da linguagem e que, como mencionado, não irá interferir em seu programa de maneira significativa. Você deve ter em mente apenas a constante necessidade de duas estruturas de repetições para percorrer todo o vetor, assim como em qualquer outra linguagem de programação. Para entender melhor o processo, vamos a um exemplo.

//Classe Matrizes.java class Matrizes{ public static void main(String[] args){ int [][]matriz = new int[2][3]; for(int i=0; i< matriz.length; i++){ System.out.println(“Linha: “+i); for(int j=0; j< matriz[i].length; j++){ matriz[i][j]= i+1; System.out.println(“Valores da coluna”); System.out.println(matriz[i][j]); } } } }

Após executar o programa, teremos como resultado a impressão da coluna, da qual cada uma das posições faz parte no momento. Como mencionamos, são necessárias duas estruturas de repetição para percorrer toda a matriz, lembrando que uma é responsável por fazer referência à linha e a outra estrutura a um novo vetor, no caso, uma pseudocoluna, conforme é impresso no programa anterior. No Java, existem outras estruturas de vetores que, no caso, são classes que fornecem mais ferramentas e funcionalidades, agregando valor ao programa. Em nosso sexto capítulo, iremos analisar mais e apresentar essas estruturas adicionais para o trabalho com vetores, tais como as classes Array, HashMap e Vector. Então, para a definição de vetores e matrizes, sempre estaremos envolvidos em três etapas:


1-Declaração do vetor ou matriz: Ocorre da mesma forma como em uma variável, porém basta acrescentar antes ou depois da variável um par de colchetes. Exemplo: double posicao[][], controle[][]; int []indice;

2- Reservar o espaço de memória: No caso, é necessário definir o tamanho do espaço de memória que será mantido para a estrutura. Para isso, é utilizado o operador new. Exemplo: posicao = new double[10][20]; indice = new int[5];

3- Armazenar valores nas posições: Para armazenar um valor ou informação em um dos elementos do vetor ou matriz, é necessário informar o índice, ou seja, o local no qual iremos manter os dados. Exemplo: nota[3] = 7.8; posição[4][6] = 3365; double[] nota = {7,8, 8,4, 4,2, 1,8, 6,4};

A manipulação de vetores e matrizes é essencial para o trabalho com as estruturas de dados. Diante disso, fica como sugestão que seja dada uma especial atenção ao trabalho com vetores e matrizes, refazendo os exemplos sugeridos e memorizando sua sintaxe. 1.6 Funções Caro leitor, chegamos ao último tema que será analisado neste capítulo, que se trata do trabalho com funções. Assim como nas demais linguagens, uma função consiste em uma rotina ou sub-rotina automatizada. As funções


são interessantes para as atividades que serão utilizadas rotineiramente, ou seja, que se repetirão várias vezes e com isso, evitam que tenhamos de reimplementar tal trecho a cada momento de necessidade. Resumidamente, sempre que se quiser usar um mesmo trecho de código que realiza uma tarefa específica repetidamente, o melhor a fazer é criar uma função. O entendimento deste conceito é primordial para que, em nosso próximo capítulo, possamos lidar com o conceito de métodos. O primeiro passo para criar uma função gira em torno do fato de que a função deve ser sempre global, ou seja, deve ser enxergada por todo o código da classe e para tanto, também deve ser estática, sendo definida pela palavra reservada static. A palavra reservada static é responsável por garantir que ao ser realizada a execução de uma instância da classe mais de uma vez, somente haverá uma única referência para determinada variável ou função existente na memória em seu computador. Ou seja, ao declarar uma função como static, todas as instâncias de uma determinada classe irão acessar e compartilhar o mesmo endereço de memória da função. Outro detalhe ao qual devemos ficar atentos é que ao declararmos algum trecho, variável ou função como static, isso nos permitirá que sejam acessados diretamente sem a necessidade de criar uma instância da classe. Esses conceitos ficarão mais claros ao trabalharmos com a orientação a objetos, porém é importante saber que existem diversos padrões de projetos que fazem referência à utilização da palavra reservada static, como, por exemplo, o Singleton. As funções podem ser tanto sem argumentos quanto parametrizadas, porém a estrutura padrão que deve ser digitada dentro da classe, mas fora da função main, como é apresentada a seguir. static void nomeDaFunção(lista de parametros){ // código da função }

Em nosso exemplo, a estrutura apresentada faz referência a uma lista de parâmetros, que pode ou não ser declarada. Assim, como mencionado, existem funções nas quais não existem argumentos, mas necessariamente devem existir os parênteses. Para ter uma melhor fixação da sintaxe, vamos a um exemplo da utilização de funções. Digite o código a seguir e verifique seu funcionamento, assim como nos demais exemplos averiguados até aqui.


// Classe ExemploFuncao.java public class ExemploFuncao{ public static void mostrarMensagem() { System.out.println(“Chamei minha função”); } public static void main(String[] args) { // chamando a função dentro do // programa principal mostrarMensagem(); } }

Em nosso exemplo, foi criada uma função chamada mostrarMensagem( ), que apenas imprime na tela. Nossa função é chamada dentro do método principal main( ), ou seja, poderíamos realizar a chamada quantas vezes fossem necessárias sem ter de reescrever todo o código novamente. Este exemplo é um bom começo para o entendimento da ideia de mensagens, mas isso é um assunto para o nosso próximo capítulo. É importante mencionar que a ideia de função em java muitas vezes é confundida com o conceito de métodos, sendo que iremos saber mais sobre eles em nosso segundo capítulo Bom pessoal, assim finalizamos nosso primeiro capitulo e espero que todos tenham assimilado, aprendido e gostado do fascinante e, ao mesmo tempo, importante mundo Java. Um detalhe que deve ser mencionado e deve fazer parte de sua rotina como programador é que a atividade de programação torna-se cada vez mais clara com a prática. Desta forma, sempre que possível, refaça todos os exemplos sugeridos neste capitulo. Nos vemos no próximo capítulo.

Capítulo 2 Programação orientada a objetos A tecnologia Java ganhou espaço nos últimos anos considerando diversos aspectos. Vários deles já comentamos, como, por exemplo, a ideia de máquina virtual que possibilita a portabilidade entre os programas desenvolvidos com o Java ou mesmo o fato da tecnologia Java ser regida pela GPL. Porém, outro aspecto deve ser mencionado neste contexto. Ele consiste no fato da linguagem Java trabalhar sobre os conceitos oriundos do paradigma da programação orientação a objetos. Neste capítulo, trabalharemos com os conceitos básicos relacionados a este paradigma de programação, obviamente baseados na tecnologia Java. Fica como dica que é muito importante que os temas abordados em nosso primeiro capítulo tenham sido assimilados de maneira satisfatória, garantindo assim um melhor aproveitamento dos tópicos que virão a ser tratados não só neste capítulo, como nos seguintes também. Certo! Vamos ao que realmente interessa. O paradigma de programação orientada a objetos trata de uma forma diferente o enfoque até então trabalhado na maioria das linguagens de programa, que se sustentavam no paradigma de programação estruturada. A ideia por trás do paradigma da programação orientada a objetos baseia-se em uma contextualização mais humana e próxima da realidade, isso considerando que quase tudo o que temos e lidamos em nosso dia a dia são objetos. Por exemplo, o carro que você anda, a casa onde você mora. Poderíamos, então, imaginar que até mesmo as pessoas, animais e qualquer outro tipo de entidade podem ser vistos grosseiramente como objetos. Claro que existem situações nas quais esses “objetos” podem não ser concretos e palpáveis, tal como o veículo que mencionamos, mas no caso abstrato, como, por exemplo, os softbots (robôs de software), também podemos imaginar que eles existem e possuem elementos que os diferenciam, assim como atitudes e funções que possibilitam que possamos imaginar que estes podem servir de modelos computacionais. O paradigma de programação orientada a objetos é relativamente novo na concepção e na implementação de sistemas de software, considerado


os demais disponíveis no mercado. Vários são os benefícios que podem ser vislumbrados com a utilização desse paradigma, entre eles estão o aumento da produtividade de programadores por meio de uma maior expansibilidade e a reutilização de código, ou mesmo o fato de controlar a complexidade e os custos com a manutenção do software. Neste caso, o objetivo central da orientação a objetos na criação de programas computacionais é permitir que os programas possam ser desenvolvidos de maneira a espelhar o modo como os objetos são organizados no mundo real, criando a figura de modelos que podem ser reutilizados quantas vezes forem necessárias, bem como criar uma estrutura modular, na qual os problemas possam ser resolvidos sem que o todo seja afetado. Tais benefícios oriundos do paradigma ficarão mais claros com o decorrer da leitura do livro e o conhecimento dos conceitos. Diante do exposto, caro leitor, é importante que você saiba que a programação orientada a objetos baseia-se nos seguintes conceitos: classes, atributos, métodos e objetos que serão apresentados neste capítulo, além dos construtores, encapsulamento, herança, polimorfismo e interface que serão apresentados em nosso próximo capítulo. 2.1 Conceitos da programação orientada a objetos Então, vamos lá amigo leitor! Aqui, iremos entender mais a fundo a Programação Orientação a Objetos (POO). Como citado, grande parte de nosso entendimento e relacionamento com as coisas do mundo real se dá através do conceito de objetos concretos ou mesmo abstratos. Observando ainda as coisas e seres que existem, há uma natural tendência a identificar o que é cada uma destas diferentes entidades, um móvel, uma pessoa e assim por diante. Relembrando um exemplo claro deste fenômeno e que já citamos, olhemos um carro. Logo, algo que se pode ver e reconhecer sua forma, tamanho, cor e aplicação. Porém, algo que acredito que muitos ainda não imaginaram é que tais observações podem ser feitas para todos os carros. Esse carro que acabamos de observar não é o único que existe. Inúmeros outros estão disponíveis com as mesmas características, porém sendo objetos completamente distintos. O que podemos começar a vislumbrar é que podemos ter computacionalmente uma estrutura que garanta que as informações possam ser mantidas e trabalhadas para inúmeras situações semelhantes.

Capítulo 2 - Programação orientada a objetost31

Voltemos ao exemplo do carro. Se existem vários carros com as mesmas características e funcionalidades, é de se imaginar que exista uma forma ou molde que garanta que todos saiam iguais, de forma padronizada e serializada. Estes conceitos oriundos da administração foram absorvidos de maneira eficiente pela computação e pelo paradigma da orientação a objetos, que adotou a ideia de criação de modelos computacionais que podem ser reutilizados e fazer com que esses elementos se completem, modularizando a programação. O que temos inicialmente é a ideia de uma modelo, que a qualquer momento podemos dispor de seu uso para criar novos ‘objetos’ de um determinado tipo de entidade que será mantida na memória. É claro que cada objeto no mundo real é único, no caso, ninguém é igual a ninguém. Cada objeto possui uma característica ou mesmo uma função que o torna único, servindo como uma identidade que o diferencia dos demais, mesmo que sejam do mesmo tipo. Por exemplo, uma pessoa. Todas as pessoas possuem um nome, endereço, trabalho, mas todas são diferentes uma das outras, sendo que cada uma possui sua identidade própria, algo que a torna única e diferenciada. Poderíamos grosseiramente dizer que se trata do RG individual e pessoal de cada objeto. Assim pessoal, além das características genéricas vinculadas a todas as classes de objetos, existe também a identidade vinculada a cada objeto individualmente. Por meio dos exemplos citados, podemos descrever informalmente os conceitos fundamentais da programação orientada a objetos, sendo eles: t t t t t t t t t

Classe; Atributos e métodos; Objeto; Referência a Objetos; Construtores; Encapsulamento; Herança; Polimorfismo; Interface.

Como citado no início deste capítulo, iremos concentrar-nos agora apenas nos quatro primeiros conceitos mencionados. Os demais serão apresentados nos próximos capítulos.


Caro leitor, mas o que você deve ter em mente quando iniciar o estudo sobre os conceitos da orientação a objeto é o fato de que tal paradigma irá auxiliá-lo a entender e visualizar de maneira mais ampla um problema a ser resolvido, conseguindo assim, uma maior independência entre a programação e o modelo do problema a ser trabalhado, o que obviamente irá facilitar possíveis manutenções e reutilizações com uma modularização, como já citei. 2.1.1 Classe Em nosso primeiro capítulo, já trabalhamos com a criação de classes. Mas, agora, vamos entender sua real contextualização, sendo o conceito primordial para o entendimento da POO. Uma classe é um modelo formado por propriedades ou características, que serão definidas mais à frente como atributos, operações e funcionalidades, que iremos conhecer como métodos e definem o comportamento básico dos objetos oriundos de uma classe. Podemos imaginar uma classe em seu sentido estrito e epistemológico, ou seja, uma representação genérica de um conjunto de entidades individuais e iguais. Por exemplo, uma classe de alunos, na qual todos são semelhantes dentro do contexto, com nome, matrícula e assim por diante. Em nosso caso, a classe é a representação comum ou padrão de um conjunto de entidades iguais. As classes são a modelagem das entidades do mundo real de uma forma mais natural computacionalmente, pois estamos acostumados a lidar com “objetos”, que possuem características, “atributos”, funcionalidades e “métodos”. Tomemos como exemplo o carro. Este poderia ser definido por uma classe que descreve de maneira comum um conjunto de objetos do tipo carro, independentemente de sua marca, cor ou tipo, atendo-se especificamente aos conceitos que, de alguma maneira, descrevem a estrutura de um carro de forma genérica. Então, vamos a um exemplo de uma classe, na qual podemos descrever um conjunto de entidades a partir de um modelo computacional genérico. // Classe Carro.java class Carro{ String cor; String marca; String modelo;


void andar(){ System.out.println(“Carro andando”); } void parar(){ System.out.println(“Carro parado”); } }

Vale a pena novamente mencionar que os nomes das classes devem ser iniciados com letras maiúsculas, diferenciando assim dos atributos e das instâncias de objetos que utilizam letras minúsculas em suas iniciais. Caso o nome seja composto por mais de uma palavra, recomenda-se que as demais palavras também iniciem em letra maiúsculas. Exemplo: Carro, CarroDeCorrida. Observando o exemplo de classe acima, verifica-se que ela não possui um método principal, sendo assim, ela não retornará nenhuma ação ao ser executada, sendo apenas a descrição de um objeto do mundo real, ou seja, a ideia central e descrevendo o problema a ser implementado. Em nosso caso, descreve uma estrutura para manter os dados e descreve as funcionalidades de um carro como um modelo que será utilizado. Isso é interessante, pois sempre que quisermos manter informações ou mesmo utilizar suas funcionalidades, não precisaremos implementar novamente todo o código, necessitando apenas uma nova instanciação de um objeto da classe ou mesmo sua cópia para outro projeto. De maneira mais formal, podemos então dizer que uma classe é uma abstração que descreve as propriedades relevantes de um conjunto de elementos em termos de sua estrutura, atributos e comportamento - os métodos. 2.1.1.1 Qualificadores de acesso Outro aspecto interessante e que auxilia em uma programação mais ‘realista’ com a utilização do paradigma orientado a objetos consiste na ideia do qualificador de acesso. Tantos as classes que já conhecemos quanto os atributos e métodos que ainda iremos conhecer fazem uso e estão na maioria das vezes associados ao conceito de qualificador de acesso ou também conhecido como especificação de visibilidade.


Vamos a uma analogia para tentar entender o conceito de visibilidade. Você resolve parar um pouco com a leitura de seu livro de programação com Java e resolve dar uma volta de carro. Diante disso, começa a lembrar dos conceitos que leu, rememorando que seu carro é um objeto dentro de uma classe que define todos os aspectos comuns de todos os carros. Mas, ao ligar seu carro, você começa a pensar: “Bom, eu tenho visíveis várias características e várias funcionalidades, mas existem outras que não consigo enxergar e que tenho certeza que contribuem para o bom funcionamento do veículo, tais como a partida, rotação do motor e assim por diante”. Pois bem, ao considerar esta situação, é possível verificar que, em diversos momentos em nosso cotidiano, existem objetos, características e funcionalidades que estão visíveis e outras não. Logicamente que isso irá depender dos aspectos funcionais e da utilidade de cada objeto. É aí que entram os especificadores ou os qualificadores de visibilidade. Eles permitem definir quem ou o que pode ser visível ou acessível no momento do desenvolvimento de suas classes. Na maioria das situações, com as quais você irá deparar-se, uma classe fará uso de outras classes e essas devem estar acessíveis por meio da utilização dos qualificadores. Para tanto, deve-se utilizar uma das estruturas apresentadas a seguir. No caso, os tipos de qualificadores básicos são: Tabela 3. Qualificadores de acesso. Qualificador

Descrição

public

Define que o conteúdo da classe é público e pode ser utilizado livremente por outras classes do mesmo pacote ou de outro pacote.

protected

Define que o conteúdo da classe está protegido e que só pode ser utilizado por classes do mesmo pacote.

private

Define que o conteúdo é privado e só pode ser utilizado internamente na própria classe.

Assim, poderíamos enriquecer nosso exemplo da classe carro apresentada anteriormente com os qualificadores de visibilidade. Verifique que tanto


a classe como suas variáveis que descrevem as características e as funções, que descrevem seu comportamento ou funcionalidades, podem fazer uso de tais especificadores. //Classe Carro.java public class Carro{ public String cor; public String marca; public String modelo; protected void andar(){ ligar(); System.out.println(“Carro andando”); } protected void parar(){ System.out.println(“Carro parado”); } private void ligar(){ System.out.println(“Carro ligado”); } }

Os qualificadores de visibilidade são essenciais para o conceito de encapsulamento, com o qual trabalharemos em nosso próximo capítulo. Por padrão, quando não declarada a visibilidade de uma classe ou mesmo atributo e método, a máquina virtual Java irá interpretar que tais elementos estarão especificados com o operador protected, ou seja, protegidos e acessíveis apenas dentro do pacote do qual fazem parte. 2.1.1.2 Pacotes Com isso, temos outro conceito que interfere nas classes tanto quanto a visibilidade. No caso, consiste na ideia de pacotes, declarados no Java como package. A principal função desta diretiva no Java está na organização das classes e obviamente em sua visualização por outras classes de um projeto. O que podemos então verificar é que o pacote está diretamente


relacionado aos qualificadores de visibilidade no acesso a classes, características e funcionalidades destas. Ou seja, a utilização da diretiva package na classe indica que todo o conteúdo público (public) pode ser utilizado por outras classes pertencentes ao mesmo pacote ou não. O conteúdo determinado como protegido (protected) na classe pertencente a um pacote só pode ser acessado ou utilizado por outras classes pertencentes ao mesmo pacote e o conteúdo definido como privado (private) só será acessível dentro da própria classe, independentemente do pacote do qual faz parte. Caso o pacote de uma classe não seja informado, essa classe passará a fazer parte do pacote default (src, abreviação de source, traduzindo, fonte). Do ponto de vista usual, dentro de seu projeto, um pacote de classes Java consiste em um diretório, no qual existem uma ou mais classes, ou seja, é um repositório de classes. Geralmente, colocam-se no mesmo package as classes com o mesmo propósito. Sob certos aspectos, os packages reproduzem a ideia de bibliotecas, que podem ser importadas em uma classe Java por meio do comando import. 2.1.1.3 Import O comando import é responsável por garantir a reutilização e a modularização dos programas no Java. Logicamente, tais conceitos são semelhantes ao include do C ou C++ e garantem, com os demais conceitos de visibilidade e pacotes, definições de segurança e organização. Certo pessoal! Diante do exposto até aqui, vamos a um exemplo de uma estrutura padrão de uma classe, considerando todos os conceitos apresentados. Além disso, apresentaremos um novo elemento da linguagem neste exemplo, que consiste nos comentários. package local.diretorio; // atributos da classe // métodos da classe }


Note que a estrutura apresentada apenas define os conceitos já vistos por você nos exemplos anteriores. Porém, deve-se tomar muito cuidado com a manipulação de pacotes e imports, pois podem ocorrer erros de referência, uma vez que as classes e os pacotes não existam. 2.1.1.4 Comentários Bom pessoal, os comentários são extremamente úteis na linguagem Java. Isso porque não somente permitem os simples comentários, mas ganham valor ao considerarmos as possibilidades que a própria máquina virtual define para tal elemento. No caso, a tecnologia Java define três tipos de comentários, sendo eles: com uma linha, múltiplas linhas e documentação. O primeiro, com uma linha, utiliza duas barras (//) para marcar seu início e tudo após as duas barras é considerado um comentário pela JVM. O segundo tipo de comentário utiliza a combinação /* e */ para delimitar as múltiplas linhas de comentários. E o último tipo consiste no comentário de múltiplas linhas, semelhante ao segundo, porém com o propósito de documentar a programação. No Java, recomenda-se como uma boa prática de programação, que todas as classes sejam documentadas e para isso, a tecnologia Java nos dá uma mãozinha, como pode ser observado no Apêndice II deste livro. Na Tabela 4, é demonstrada a utilização dos comentários apresentados. Tabela 4. Tipos de comentários Tipos de comentários // comentário de uma linha // tudo após as duas barras é um comentário /* comentário de múltiplas linhas */ /** comentário de documentação que também * podem ter múltiplas linhas */


Usualmente, o comentário com o objetivo de documentação é posicionado antes do elemento a ser documentado, sendo que seu conteúdo é extraído automaticamente pelo utilitário javadoc fornecido com o JDK.

Como mencionado, o apêndice deste livro traz exemplos para a criação da documentação de suas classes, com a utilização do suporte fornecido pela JVM.

Conforme já citado em nosso capítulo anterior e algumas vezes na seção onde definimos as classes, os atributos e os métodos são conceitos que estão intrinsecamente associados à ideia de classe. Então, mãos à obra! Vamos conhecer um pouco mais sobre esses conceitos. 2.1.2 Atributos Um atributo nada mais é que uma variável contextualizada, na qual representa uma característica ou uma propriedade da classe de objetos em questão. É uma variável destinada a armazenar informações associadas à classe. Por exemplo, vamos considerar novamente o famoso carro apresentado nas seções anteriores. Seja qual for o carro, várias características podem ser elencadas para ele, entre elas, sua marca. Trata-se de uma propriedade comum a todos os carros, pois todo carro possui uma marca ou mesmo uma cor. Assim, é natural que ao definirmos uma classe, por exemplo, CarroDeCorrida, ela possua um atributo ou no caso, uma variável contextualizada destinada a armazenar sua marca e sua cor. Podemos definir os atributos como “variáveis da classe que podem ser de tipos primitivos ou de outras classes destinadas a manter os dados dentro de um contexto”. A definição de um atributo dentro de uma classe Java é feita da mesma maneira como em uma declaração de variável, sendo definido o seu tipo e nome, que deve indicar qual seu propósito. Considere o exemplo da classe CarroDeCorrida a seguir. //Classe CarroDeCorrida.java package fabrica;


public class CarroDeCorrida{ public String cor; public String marca; }

Mais uma vez, temos de lembrar que, em nossa classe, não existe um método executável, ou seja, o método main( ), sendo que tal classe representa uma descrição de um problema que, no caso, consiste em manter as informações sobre, por exemplo, um carro de corrida durante a execução. Poderíamos dizer grosseiramente que se trata de um mapeamento das informações a serem mantidas. Mas, de nada valem os atributos sem que estes possam ser trabalhados e transformados. É aí que entram os métodos. 2.1.3 Métodos Como verificamos no tópico anterior, enquanto os atributos permitem manter dados vinculados e contextualizados aos objetos, ou seja, valores que descrevem as características de um objeto, os métodos são responsáveis por realizar operações sobre os atributos, sendo capazes de especificar ações ou transformações para uma classe de entidades. A ideia central na construção de métodos está relacionada ao fato de conferir um caráter dinâmico aos objetos de uma classe, exibindo um comportamento que transforme e modifique seu estado atual. Na maioria das vezes, essa transformação se dá por meio da alteração de valores dos seus atributos, tentando imitar o comportamento de um objeto real ou abstrato. Bom, assim como nos demais conceitos, cada método possui uma assinatura e corpo definidos por: t t t t

qualificador de acesso; tipo de retorno; nome; lista de parâmetros.

Definido o corpo do método, vem seu escopo, que define a implementação à qual o método se propõe, que deve estar entre “{ }”. Apresento a seguir mais um exemplo, além de aproveitá-lo para demonstrar mais um elemento da linguagem Java. Vamos utilizar o exemplo de um caixa eletrônico.


//Classe ContaCorrente.java package banco; public class ContaCorrente{

!" private String titular;

!# $ % & "' this.saldo -= valor; return “Saque realizado com sucesso!”; }

!# $ % ! & "' this.saldo = this.saldo + valor; return “Deposito realizado com sucesso!”; } }

Repare que no exemplo, temos dois métodos, sacar e depositar. Por convenção, os métodos sempre devem ser declarados com o verbo no infinitivo, tal como: desenhar, andar, propor, correr e assim por diante. No caso de nomes compostos, o primeiro nome será no infinitivo e os demais declarados normalmente, tal como: gerarDocumentacao( ), depositarDinheiro( ) ou depositarCheque( ). Mas, um elemento deve ter chamado sua atenção no exemplo. No corpo dos métodos pode ser visualizado o identificador this. 2.1.3.1 Identificador this O identificador this é responsável por fazer referência a um atributo ou método da própria classe. No exemplo apresentado anteriormente, é feita a referência ao atributo saldo. Isso é muito útil, pois é comum que os parâmetros possuam nomes iguais aos já existentes nos atributos de uma classe, diferenciando-os. Uma alternativa para a utilização do identificador this é sua definição nas classes Java para a chamada de um método construtor dentro da própria


classe. Isso é feito por meio do método reservado this( ). É importante que você saiba que todos os conceitos apresentados até aqui devem ser sempre bem planejados e isso é geralmente feito no momento do projeto de suas aplicações. As classes, atributos e métodos podem ser representados de maneira gráfica, o que é extremamente útil para enxergar os possíveis gargalos ou deficiências em sua aplicação. Para tanto, existem várias notações, geralmente gráficas, para a representação de classes, atributos e métodos, mas com certeza a mais utilizada comercialmente trata-se da UML (Unified Modeling Language). Não iremos aprofundar-nos quanto à utilização da UML em nosso livro. Fica como sugestão para o leitor que, como forma de enriquecer sua leitura e aprendizado da programação orientada a objetos, procure conhecer mais sobre tal notação. 2.1.4 Mensagem e modularização de código Como mencionado no início deste capítulo, um dos pontos-chave da programação orientada a objetos consiste na possibilidade de modularizar o código. Com isso, podemos chegar mais próximo da realidade vivida no cotidiano, bem como possibilitar uma manutenção mais simples. É considerando tais perspectivas que surge um novo conceito relacionado à linguagem Java e ao paradigma de orientação a objetos: a mensagem. O conceito de mensagem entre as classes Java trabalha com a ideia de que as classes, ou melhor, os objetos ou as instâncias de uma classe podem invocar métodos de objetos de outras classes para desempenhar alguma tarefa de maneira a completar sua função e melhor definir o problema. O conceito garante que caso uma classe necessite de um serviço ou funcionalidade, mas a função faça parte de outro contexto, então será necessário apenas utilizar o que é proposto em outra classe, mantendo assim a organização de modo a garantir que todo o código fique em seu devido lugar. Obviamente, isso tornará seu código mais inteligível para as possíveis intervenções que venham a ocorrer no futuro, como no caso de uma manutenção. Dúvidas? Certo, vamos ao já mencionado no exemplo do carro. Imagine que se construa uma classe Carro que possui vários atributos, tais como: cor, marca e modelo. Além disso, na classe sejam definidos os métodos andar( ) e parar( ). Pois bem, até aqui nada de novidade. Porém, para que um veículo ande, é necessário que seu motor seja ligado. É aí que entra o conceito de mensagem como uma forma de melhor definir o problema.


O correto seria a criação de uma nova classe, que defina a ideia do objeto motor, que teria como atributos características, tais como: potência, ignição e combustível. Além dos atributos, os métodos para a manipulação desses atributos, que seriam, por exemplo, ligar( ) e desligar( ). Desta forma, quando um carro anda, o que é acionado é o motor e para tanto, é ele que deve ter seu estado alterado. O motor, como parte do carro, deve receber uma mensagem oriunda da classe carro que informe tal solicitação, fazendo acesso ao método ligar( ). Logo, o conceito de mensagem trata da comunicação entre as classes. Para ter uma melhor fixação, vamos demonstrar tais conceitos da maneira como devem ser abordados, criando classes. Aqui, utilizaremos as classes que definem nosso problema e de forma legível para seu entendimento, caro leitor. Então, vamos lá? Transcreva as classes abaixo para um editor de texto. Entretanto, não é necessária a compilação e a execução do programa, já que não temos uma classe principal que garanta uma visualização dos resultados. // Classe CarroNovo.java package fabrica; public class CarroNovo{ // atributos String cor; String marca; String modelo; Motor novoMotor = new Motor(); // métodos public void andar() { novoMotor.ligar(); System.out.println(“ANDANDO”); } public void parar() { novoMotor.desligar(); System.out.println(“PARANDO”); } }


_____________________________________________________ __ // Classe Motor.java package fabrica; public class Motor { // atributos Boolean ignicao; String potencia; String combustível; // métodos public void ligar() { ignicao = true; System.out.println(“Ligado”); } public void desligar() { ignicao = false; System.out.println(“Desligado”); } }

Neste exemplo, podemos notar que existe um novo elemento na classe CarroNovo, que consiste na utilização de uma INSTÂNCIA da classe Motor. Estarei abordando mais sobre a importância deste conceito na próxima seção com o uso da palavra reservada new. Outro exemplo que pode ser útil para o entendimento do conceito de mensagens entre classes é apresentado a seguir. No próximo exemplo, é implementada uma classe denominada ProgramaPrincipal, com um método principal onde se cria uma variável ou para que você vá acostumando-se, um objeto da classe Mensagem que possui o método imprimir( ) acessado durante a execução pela classe ProgramaPrincipal. Trata-se de um exemplo sem uma contextualização, mas que é útil para enxergar a divisão de tarefas e a modularização do código com os conceitos da orientação a objetos. Considerando as características do exemplo, podemos compilar e executá-lo para a visualização.


// Classe ProgramaPrincipal.java class ProgramaPrincipal{ public static void main (String arg []){ Mensagem m = new Mensagem(); m.imprimir(); } } // Classe Mensagem.java class Mensagem{ public void imprimir(){ System.out.println(“Mensagem”); } }

No exemplo, é feita a utilização do método imprimir( ) da classe Mensagem pela classe ProgramaPrincipal. Ainda no exemplo, é feita novamente a utilização do operador new. Trata-se de mais uma palavra reservada para a tecnologia Java que é responsável pela atribuição de uma instância a um atributo. A ideia de instanciação é essencial para compreendermos todo o paradigma da programação orientada a objetos. Então, vamos conhecer o conceito de objeto. 2.1.5 Objeto ou instanciação Como já deve ter sido percebido, a criação de novos objetos de uma classe se chama instanciação ou simplesmente criação do objeto. O objeto consiste em representar um único exemplar de uma determinada classe. Vamos voltar ao exemplo do carro. A classe CarroDePasseio representa os atributos (características) e os métodos (comportamento) de todos os carros de passeio. Logo, a classe consiste em um modelo para reservar um espaço de memória para manter e transformar os dados. A partir da classe CarroDePasseio, podemos criar vários objetos, ou seja, várias representações ou instâncias a partir do mesmo modelo, pertencente à classe. Por exemplo, podemos manter os dados de uma Mercedez, um Gol ou qualquer que seja o carro de passeio. Note, qualquer um dos veículos citados é um exemplar específico da


classe CarroDePasseio. Cada carro em específico possui características, tais como, cor, tamanho e marca, que o torna único e métodos que definem como ele pode ser ligado, desligado e como deve andar. Se fôssemos pensar grosseiramente, poderíamos ter uma classe Pessoa, da qual você, leitor, é um objeto ou uma instância da classe (conjunto) de pessoas. Pensemos, você é único e ninguém é igual ao outro, onde cada um possui características próprias e comportamentos distintos, ou seja, cada um é um objeto diferente pertencente a uma determinada classe. Pode-se definir um objeto como sendo uma instância de uma classe (grupo) que tem valores próprios para os atributos definidos na classe, tendo uma identidade única, ou seja, sendo único no conjunto de elementos do mesmo tipo. A notação para instanciar um novo objeto utiliza o operador new, destinado à sua criação. NomeDaClasse nomeDoObjeto = new NomeDaClasse(); Exemplo: CarroDePasseio mercedez = new CarroDePasseio(); Mensagem m = new Mensagem();

A primeira coisa que você deve ter reparado é que a declaração de um objeto é realizada de maneira semelhante a dos atributos de uma classe. Então, é valido mencionar que as classes podem conter instâncias de outras classes como atributos, com diversos elementos compondo um todo, assim como apresentado na classe Carro e Motor. Outro exemplo seria a mesma classe carro que pode ter como atributo um proprietário, que pode ser definido como sendo de uma classe Pessoa, como é apresentado no exemplo a seguir. Conforme já visto neste capítulo, o exemplo abaixo apresenta o conceito de importação de outras classes. O código é meramente ilustrativo, não sendo necessária sua execução. // Classe Carro.java package concessionaria; import concessionaria.Pessoa; public class Carro{ // atributos


int velocidadeMaxima = 50; Pessoa proprietario = new Pessoa(); // métodos public void mostrarVelocidadeMaxima(){ proprietario.dirigir(); System.out.println(velocidadeMaxima); } } ______________________________________________________ // Classe Pessoa.java package concessionaria; public class Pessoa{ String nome; String endereco; public void dirigir(){ System.out.println(“DIRIGINDO”); } }

Mas, quando falamos de objeto, o que realmente está por trás disso é outra importante característica da orientação a objetos, no caso, o reuso do código. Mais uma vez fazendo referência ao exemplo do carro, a mesma classe pode ser utilizada para definir vários objetos do mesmo tipo, sendo que somente os dados referentes às características de cada um diferem. Por exemplo, poderíamos ter um objeto denominado carroDePasseio e outro instanciado com sua referência sendo carroDeCorrida. Ambos podem ser instâncias da classe Carro, sendo que os dois objetos são oriundos da mesma classe, diferenciados apenas pelos valores associados aos atributos que cada um assume. Porém, ambos utilizam o mesmo modelo, mais especificamente, a classe Carro. Cabe ainda destacar outros detalhes da instanciação de objetos. Agora que já sabemos como os objetos são criados, com a utilização do operador new, é importante entender o que acontece quando criamos esses objetos.


Quando um objeto é criado por meio do comando new, o que é retornado à variável ou ao atributo, como já vimos, é uma referência. Referência? O que é isso? Vamos à explicação. Quando um objeto é criado, ele é uma referência ou uma indicação para um determinado espaço de memória reservado, sendo que o nome da variável torna-se apenas uma âncora para o acesso ao espaço de memória no momento da execução de seu programa, no qual estão dispostos nossos atributos e métodos. A ilustração apresentada a seguir torna isto mais claro.

Figura 2. Referência para objetos.

Após a explicação e as considerações feitas sobre o espaço de memória ser o objeto, é necessário também dizer que o operador new não é a única forma de atribuirmos referência a um objeto ou uma instância. Uma maneira de visualizar o objeto como uma referência, no caso uma âncora, é o fato de também se poder fazer a cópia de uma referência de um objeto para outro, com ambos passando a apontar para o mesmo endereço de memória. Se copiarmos uma referência para outro objeto, ele estará referenciando o mesmo objeto que a instância original está referenciando. Para ter um melhor entendimento do que foi dito, observe a Figura 3.

Figura 3. Cópia de referência de objetos.


Entendido o conceito, você deve perguntar: Mas, como fica isto em linhas de código no Java? Respondendo ao seu questionamento, observe e transcreva o código na sequência, onde são criadas duas classes que exemplificam o explicado. Conforme visto em nosso primeiro capítulo, utilizaremos o método executável main para imprimir os valores que foram referenciados aos atributos das classes. //Classe Carro.java package concessionaria; import concessionaria.Pessoa; public class Carro{ //atributos int velocidadeMaxima = 50; Pessoa proprietario = new Pessoa(); //métodos public void mostrarVelocidadeMaxima(){ proprietario.dirigir(); System.out.println(velocidadeMaxima); } }

___________________________________________________ //Classe Pista.java package concessionaria; public class Pista{ public static void main(String[] args){ Carro carroDeCorrida = new Carro(); Carro carroDePasseio = new Carro(); carroDeCorrida.velocidadeMaxima = 300; carroDePasseio.velocidadeMaxima = 60; carroDeCorrida.mostrarVelocidadeMaxima(); carroDePasseio.mostrarVelocidadeMaxima();


Carro novoCarro = carroDeCorrida; carroDeCorrida.mostrarVelocidadeMaxima(); carroDePasseio.mostrarVelocidadeMaxima(); novoCarro.mostrarVelocidadeMaxima(); } }

Entre as diversas linhas que devem ser observadas no código anterior, devemos dar mais importância à linha na qual a instância da classe Carro chamada novoCarro recebe a referência, ou seja, o endereço de memória do objeto carroDeCorrida, observe.

Carro novoCarro = carroDeCorrida;

Os atributos carroDeCorrida e novoCarro fazem referência ao mesmo espaço de memória, pois não foi atribuído um novo espaço de memória para o objeto novoCarro, mas sim, o mesmo espaço ao qual o objeto bolaGrande já fazia referência. Esta é uma característica fundamental da linguagem Java, sendo que sempre são passadas referências no Java, não valores. Tal fato torna o trabalho e a manipulação das estruturas de dados com o Java muito simples. Assim, finalizamos nosso segundo capítulo e no próximo, iremos continuar a conhecer outros conceitos vinculados à programação orientada a objetos.

Capítulo 3 Construtores, destrutores e encapsulamento Dando continuidade à nossa análise sobre os conceitos relacionados ao paradigma da programação orientada a objetos, iremos, neste capitulo, descrever e aprender a lidar com três novos e importantes elementos para a tecnologia Java. É importante que os conceitos expostos nos capítulos anteriores tenham sido compreendidos para ter um melhor aproveitamento do conteúdo que será apresentado neste capítulo. Como visto nos capítulos anteriores, a ideia de classe na linguagem Java é o núcleo de todo o processo da orientação a objetos, no qual podemos representar qualquer objeto, seja ele concreto, tal como um carro, seja mesmo abstrato, tal como um softbot. Mas, não podemos deixar de mencionar outros conceitos importantes que auxiliam a concretizar o paradigma, como, por exemplo, os atributos e os métodos, conhecidos no capítulo anterior, ou mesmo os métodos construtores, destrutores e a ideia de encapsulamento na qual iremos trabalhar. Tais ferramentas tecnológicas possibilitam que a linguagem Java possa descrever com maior clareza o problema e com isso, obter uma solução melhor. O primeiro conceito no qual iremos trabalhar são os construtores e sua função no paradigma e na linguagem Java. 3.1 Construtores Em nosso segundo capítulo, analisamos a criação de objetos, que denominamos de instanciação de um objeto. Ali, obtínhamos uma referência para um espaço de memória, lembra? Pois bem, como vimos, isso nos obriga a seguir uma determinada sintaxe, conforme é apresentado a seguir. Carro novoCarro = new Carro();

Já foi analisada a utilização da palavra reservada new no ato da instanciação de um objeto ao verificar sua responsabilidade pela nova instância. Mas, podemos dizer que é uma meia verdade. Isto porque, como visto no exemplo anterior, o operador new antecede a chamada de um método. É esse


método que denominamos de construtor do objeto ou apenas construtor. Sua função, como o próprio nome explicita, é construir, ou melhor, preparar o espaço de memória definido para um objeto para receber os dados conforme determinado na estrutura definida na classe. Sua invocação geralmente é feita no momento da criação de um objeto, da mesma maneira como é feita para qualquer método. Porém, um detalhe a ser considerado é que os métodos construtores possuem o mesmo nome da classe na qual são definidos. Por definição, os métodos construtores são métodos especiais invocados pelo sistema na instanciação de um objeto, sendo que o operador new apenas informa qual método construtor de uma determinada classe será utilizado pela JDK no momento da criação do objeto para inicializar os valores dos atributos. Neste caso, cabe um exemplo para ter uma melhor visualização dos conceitos. No exemplo a seguir, definimos um método para a classe Carro. Transcreva o código e tente visualizar as peculiaridades dos métodos construtores. // Classe Carro.java package conceitos; public class Carro { // atributos Boolean chave = true; // métodos construtores public Carro(){ this.chave = true; } public Carro(Boolean chave){ this.chave = chave; }

// métodos funcionais public void ligar() {

Capítulo 3 - Construtores, destrutores e encapsulamentot53

chave = true; System.out.println(“Ligar”); } public void desligar() { chave = false; System.out.println(“Desligar”); } }

No exemplo apresentado, foi criada a classe Carro, sendo definidos dois métodos funcionais: ligar e desligar. Pois bem, mas o que realmente importa para nós está na definição dos métodos construtores. Repare que no exemplo, foi definido o método público Carro(). Ele consiste em um método construtor. A invocação de um método construtor nada mais é que uma referência para a área de memória onde foi criado o novo objeto, podendo ser trabalhados os valores de inicialização do objeto. Desta forma, podemos, então, dizer que o método construtor é responsável pela definição e pela alocação de memória para um novo objeto. Como mencionado, um método construtor deve possuir o mesmo nome da classe, porém verifique que, para tal método, não é definido nenhum tipo de retorno. Isso acontece sempre e com qualquer que seja o método construtor ou mesmo objeto a ser inicializado, pois nosso método construtor é responsável por estruturar o espaço de memória e inicializar os valores para os atributos de uma classe, não por fazer operações funcionais do objeto criado e retornar valores. O método construtor apresentado sem parâmetros também é conhecido como método construtor DEFAULT, sendo o mais comum. Nele, podem ser realizadas todas as inicializações citadas para os métodos construtores parametrizados. Outro aspecto interessante a ser destacado sobre os métodos construtores é a capacidade fornecida pela própria JVM, que no caso de não ser definido nenhum método construtor para uma classe, a própria JVM fica responsável por disponibilizar um método construtor para a inicialização do espaço de memória no ato da instanciação de um objeto. Esse método, porém, sempre será vazio, sem parâmetros e sem inicializações com valores para seus atributos. Um exemplo para tal citação é a criação do objeto ‘chave’ demonstrado no quadro anterior, no qual é utilizado o construtor default.


Em vários problemas, é interessante que os valores de determinados atributos sejam inicializados no momento da instanciação dos objetos, como ocorreu no nosso exemplo. No caso, podem ser criados quantos métodos construtores forem necessários, diferenciados apenas pela lista de parâmetros definida para o método construtor PARAMETRIZADO. Assim, podem ser passados valores para a inicialização dos atributos da classe no momento de sua instanciação. Outra importante função dos métodos construtores é a possível realização operações que auxiliem e interfiram no funcionamento de um objeto, abrindo arquivos, estabelecendo comunicação, inicializando dispositivos que serão úteis ao programa. Carro novoCarro = new Carro(Boolean chave);

Resumidamente, uma classe Java pode possuir diversos construtores, todos obrigatoriamente devem possuir o mesmo nome da classe, SENDO SOMENTE UM DEFAULT, diferenciados por sua assinatura, no caso, suas listas de parâmetros. Isto é o que denominamos de sobrecarga do construtor. Isto torna o conceito de orientação a objetos mais próximo da realidade, facilitando o uso de classes em diferentes contextos e circunstâncias. Detalhe importante a ser mencionado aqui é o fato de um método construtor poder fazer a chamada de outros métodos da classe ou mesmo instanciar novos objetos, realizando assim, a chamada de métodos construtores de outras classes e com isso, possibilitando a construção de objetos que se completam e definem de maneira mais realista a representação do problema, já que, conforme vimos, em sua maioria, um programa é composto por várias classes que se comunicam por meio de mensagens. Uma vez criados os objetos, é interessante para nossa programação entender a liberação dos recursos de memória utilizados. Para isso, iremos detalhar e trabalhar com os destrutores e o coletor de lixo. 3.2 Destrutores e Garbage Collector (Coletor de Lixo) Na tecnologia Java, existem os construtores que realizam as operações iniciais de um objeto, preparando-o para o correto funcionamento, além da alocação de memória para estas, mas existem também os métodos


destrutores. Assim como os construtores, o destrutor é uma característica oriunda da linguagem C++. É um método especial que tem por finalidade liberar o espaço de memória utilizado por um objeto e com isso, finalizar qualquer operação que esteja em andamento, como, por exemplo, fechar arquivos, encerrar a comunicação e liberar os recursos alocados no sistema, e com isso, eliminar qualquer vestígio da instância do objeto. Os métodos destrutores seguem uma sintaxe padrão, conforme é apresentado a seguir. ! " ?&'

// Aqui é geralmente utilizado // para liberar recursos. }

Como apresentado, um método destrutor deve sempre ser identificado pelo nome finalize() e pode ser invocado a qualquer momento. Outro detalhe que pode ser percebido quanto aos destrutores é que ao contrário dos construtores, que podem conter parâmetros em sua assinatura, os destrutores não têm parâmetros na assinatura do método, porém sempre deve ser definido o valor de retorno como void. A real finalidade dos destrutores é liberar do sistema a memória usada durante a execução do objeto, sendo que este é um dos mais complexos problemas encontrados no desenvolvimento de sistemas. Isto é devido ao fato de que os recursos de um sistema são finitos. Importante detalhe a ser citado é que a invocação de um método destrutor não caracteriza a finalização concreta do objeto instanciado, mas sim, apenas uma sinalização para que o sistema, assim como definido pela JVM, libere os recursos recolhendo o espaço de memória do objeto destruído. É aí que surge outro conceito. 3.2.1 Garbage Collector Preocupados com o problema do estouro de memória comum e encontrado em diversas linguagens, os criadores da tecnologia Java incorporaram à maquina virtual um mecanismo que tem como objetivo a liberação da memória automaticamente, que é executado simultaneamente ao programa Java. Este recurso é denominado Garbage Collector ou mais popularmente conhecido como Coletor de Lixo. No Java, conforme mencionado no


capítulo anterior, um objeto sempre referencia um endereço de memória, porém quando esse endereço deixa de ser referenciado pelo programa, no caso, sai do processo de execução do programa em questão, este espaço de memória é marcado para uma futura liberação pelo Garbage Collector. A ideia é que uma vez marcado como um objeto no qual seu espaço de memória pode ser devolvido para o sistema, o coletor de lixo devolve a memória ao sistema para uma futura utilização. Tal sinalização é feita por meio dos métodos destrutores já vistos. Outro aspecto interessante do coletor de lixo está no fato de que este mecanismo tenta sempre se antecipar aos possíveis erros, oriundos da falta de recursos do sistema. Para isso, quando não há mais memória disponível no sistema, o garbage collector faz uma varredura para obter os espaços de memória ociosos para sua liberação de imediato para o sistema, prevenindo erros de estouro de memória. Considerando tais elementos da tecnologia Java, um aspecto positivo é que não é necessário o tratamento para a liberação da memória, ficando a critério do programador a utilização dos métodos destrutores, diferentemente de outras linguagens de programação, como, por exemplo, o C++, que deve realizar tal tratamento. Um detalhe importante para finalizar nossa análise sobre o coletor de lixo e os métodos destrutores está no fato de que um objeto no Java pode ser eliminado com uma nova inicialização, por meio da invocação dos métodos construtores que irão reiniciar a referência de uma variável ou um atributo. No caso, o objeto perderá a referência ao espaço de memória anterior. Outra possibilidade de fazer com que o coletor de lixo libere recursos é atribuir o valor null a um objeto, sendo que com isso, sua referência de memória ficará à disposição. Tais possibilidades são importantes, pois garantem que não ocorram erros no sistema, devido à falta de recursos do hardware. 3.3 Encapsulamento Iremos, agora, trabalhar com outro importante elemento conceitual do paradigma de programação orientada a objetos - o encapsulamento. Este conceito é útil para garantir que a solução dos problemas propostos seja sempre realista e que cada elemento só enxergue o que realmente é importante. No caso, consiste em um mecanismo que é utilizado com a finalidade de esconder os detalhes de implementação das classes Java, de maneira a se


assemelhar à realidade dos objetos reais. O ponto central do conceito é possibilitar uma maior segurança e domínio da complexidade, pois uma classe deve ofertar apenas o que ela pode fazer, não como ela faz. Vamos ser um pouco mais claros. O objetivo do encapsulamento é que uma classe impeça que seus atributos e métodos sejam acessados diretamente. Para isso, o certo é disponibilizar apenas métodos públicos para o acesso aos valores produzidos que realmente devem ser visualizados, ofertando apenas a real funcionalidade que a classe se propõe a realizar. Note que aqui é feita uma referência aos qualificadores de visibilidade apresentados em nosso segundo capítulo, sendo: public, protected e private. Tais características são oriundas da ideia cotidiana que encontramos e que geralmente passam despercebidas em nosso dia a dia na abstração de um objeto do mundo real. Vamos a um exemplo para ter um melhor entendimento. Ao assistirmos televisão ou mesmo ouvirmos um rádio, não temos nenhum conhecimento de como estes objetos trabalham internamente. Aqui, apenas são fornecidas interfaces ou maneiras de interagir com estes equipamentos, por exemplo: um botão para ligar/desligar ou mesmo aumentar/ diminuir o volume. Todos esses elementos são funcionalidades que mexem com parâmetros ou propriedades internas (atributos) do equipamento. Então, o encapsulamento é útil na proteção dos atributos da classe, disponibilizando, por meio de métodos, o acesso às propriedades da classe e com isso, a alteração do estado destas e do sistema. Definindo os métodos de encapsulamento, eles fornecem uma forma de comunicação entre os usuários de uma classe e a implementação disponível nesta, facilitando a escrita, manutenção e alteração dos programas. Existem métodos convencionados entre os programadores Java que criam uma interface entre os atributos e o usuário, sendo uma camada de comunicação publica. São denominados métodos get e set vinculados a cada atributo das classes e evitam o acesso direto a tais atributos, aumentando a segurança ao impedir que a implementação e a forma como os atributos são tratados estejam visíveis. Um exemplo desses métodos é apresentado no quadro a seguir. // Classe Carro.java package conceitos; public class Carro { // atributos


private Boolean chave = true; // método construtor public Carro(){ setChave(true); } public Carro(Boolean chave){ setChave(chave); } // métodos de encapsulamento private void setChave(Boolean status){ this.chave = status; } private Boolean getChave(){ return this.chave; } // métodos de funcionamento public void ligar() { setChave(true); System.out.println(“###LIGADO###”); } public void desligar() { setChave(false); System.out.println(“###DESLIGADO###”); } // método destrutor

! " ?&'

chave = null; } }

Destrinchando o código apresentado no quadro anterior, observe que os métodos que descrevem o funcionamento da classe, aqui ligar e desligar,


não fazem mais referência direta aos atributos, como ocorria nos outros exemplos apresentados até aqui. Algumas partes do código devem ser citadas. Note que o atributo-chave passou a ser declarado como privado, evitando o acesso de qualquer outra classe diretamente a ele. Foram implementados os métodos set e get, que garantem o encapsulamento dos atributos, no caso, as interfaces de acesso para a inserção de valores e recuperação. Assim, garantimos que qualquer requisição desse atributo deve ser realizada através dos métodos get e set definidos para o atributo. Nesta nova contextualização, os atributos devem obrigatoriamente ser acessados por meio de métodos. Os métodos set são utilizados para atribuir valores e os métodos get para a recuperação dos valores atuais dos atributos. Isso consiste em uma boa prática de programação que deve ser inserida em seu cotidiano, ainda mais no que tange à programação Java. Vamos a mais um exemplo para demonstrar os vários conceitos vistos até aqui. Transcreva o programa a seguir e execute-o, conforme já foi realizado em vários exemplos dos Capítulos 1 e 2. // Classe Carro.java package conceitos; import java.util.Scanner; public class Carro{ // atributos private Boolean chave = true; // métodos construtores public Carro(){ setChave(true); } public Carro(Boolean chave){ setChave(chave); } // métodos de encapsulamento private void setChave(Boolean status){ this.chave = status; }


private Boolean getChave(){ return this.chave; } // métodos de funcionamento public void ligar() { setChave(true); System.out.println(“###LIGADO###”); } public void desligar() { setChave(false); System.out.println(“###DESLIGADO###”); } // método destrutor

! " ?&'

chave = null; } // método executável public static void main(String[] args){ Scanner scn = new Scanner(System.in); Carro novoCarro = new Carro(); System.out.println(“Digite 1 para ligar \n 2 para“ + desligar); int opcao = scn.nextInt(); switch(opcao){ case 1: novoCarro.ligar(); break; case 2: novoCarro.desligar(); break; } } }


No exemplo, é solicitada uma entrada ao usuário que define qual será a funcionalidade a ser acessada. Para tanto, a classe Scanner é responsável por capturar essas entradas em um console, sendo utilizado o método nextInt( ). O programa apresentado inicialmente importa a classe Scanner para que possamos capturar uma entrada do teclado, criando uma interação com o usuário. Após a definição da classe Carro, foi criado o atributo-chave, bem como os métodos de encapsulamento get e set para acesso a este. Foram criados os métodos construtores, configurando a sobrecarga dos construtores, com um possuindo parâmetros e o outro, não. Um importante detalhe a ser mencionado para os construtores é que, caso o programador defina pelo menos um método construtor, o método default disponibilizado pela própria JVM deixará de existir, sendo necessária a declaração do método construtor default pelo programador, conforme é exemplificado. Este é um conceito que está relacionado à ideia de polimorfismo que iremos explorar mais a fundo no próximo capítulo. Por enquanto, atente ao fato de que sempre que um método construtor for definido, o método default disponibilizado pela JVM deixará de existir e você deverá fornecê-lo, caso queira utilizá-lo. Finalizando, o exemplo anterior possui um método executável que define uma instância, no caso, o objeto da classe carro denominado ‘novoCarro’ que permite o acesso ao espaço de memória com seus atributos e métodos. Assim, finalizamos mais um capítulo, no qual conhecemos os elementos do paradigma da programação orientada a objetos. Fica como sugestão que todos os exemplos sejam refeitos para que todos os conceitos vistos sejam mais bem assimilados. Em nosso próximo capítulo, continuaremos a trabalhar com a orientação a objetos aplicada à tecnologia Java.

Capítulo 4 Herança, polimorfismo e interface Caro leitor, neste capítulo iremos conhecer outros conceitos ainda vinculados ao paradigma da programação orientada a objetos. Sendo bem mais específico, poderíamos dizer que este é o mais importante dos capítulos estudados até aqui, pois daremos os princípios que tornam o paradigma e a tecnologia diferenciados. Como mencionado diversas vezes no decorrer do livro, o paradigma da Programação Orientada a Objetos (POO) trabalha determinando um retrato fidedigno dos objetos do mundo real. Logo, nada mais sensato e interessante que a existência de um conceito que denote a hierarquia existente entre os objetos reais. Tal conceito é de extrema importância e diferencia a linguagem de programação Java que, aliada à orientação a objetos, possibilita um melhor aproveitamento e reutilização do código por meio da ideia de herança. Outra característica da POO que iremos analisar está vinculada ao polimorfismo. A palavra polimorfismo é oriunda da palavra grega polimorfos, que significa diversas formas. Este conceito é fundamental, já que possibilita chamadas ou invocações semelhantes para diferentes implementações por meio da redefinição ou da sobrecarga de métodos. Finalizando, neste capítulo ainda conheceremos o conceito de interface, que nos possibilitará uma maior abstração da modelagem do mundo real para as classes no Java. Isso torna a linguagem Java mais extensível e reutilizável. 4.1 Herança Como mencionamos, iremos trabalhar nesta seção com um dos mais importantes conceitos da orientação a objetos, se não o mais importante: a herança. Este, por sua vez, consiste na aplicação de uma técnica muito simples e que segue os preceitos do mundo real. Um bom começo para o entendimento da herança é vislumbrar os aspectos já bem conhecidos da estrutura familiar, na qual existe uma hierarquização entre pais e filhos, normal a qualquer ser humano. Ao definir a herança, pode-se dizer que consiste em


uma técnica na qual uma determinada classe, denominada subclasse, utiliza atributos e métodos já definidos em outra classe denominada superclasse (pai), especificada como ancestral da subclasse (filho). Sendo mais claro, a herança consiste no compartilhamento de atributos e métodos, assim como acontece num relacionamento genético do tipo pai e filho. A classe-pai, que é denominada superclasse ou classe base, possui definições gerais que podem ser utilizadas nas classes-filho, também conhecidas como subclasses. Isto significa que podem ser definidas classes mais genéricas, ou seja, em um sentido mais amplo, sendo refinadas sucessivamente em subclasses que herdam todas as características das classes mais genéricas, sendo assim mais específicas. Isso é conhecido como especificação de uma classe. A especificação, termo muito utilizado quando se fala de herança, centra no fato de que as subclasses possuem características próprias que as diferenciam das classes-pai ou mesmo de outras classes que também herdam das mesmas superclasses, das quais são herdados atributos e métodos. Um exemplo disso seria imaginarmos uma estrutura familiar, no qual um filho herda de seu pai diversas características, tais como a cor dos olhos, cabelos e voz. Porém, esse filho, que herda tais atributos, possui características que são especificamente suas, como, por exemplo, o jeito de andar ou mesmo de correr. Isso o torna mais especifico que o ente do qual herdou várias características, no caso, seu pai. Podemos considerar que sempre que uma classe herda de outra, a classe que herda passa a ser um tipo especial da classe-pai. Complicado? Veremos que não. Vamos a mais um exemplo, desta vez contextualizado a linguagem Java para clarear esta ideia. Tome como exemplo uma subclasse Paciente que herda todos os atributos e métodos de uma superclasse Pessoa, sendo assim, um paciente é um tipo de pessoa, porém mais especifico, já que além de herdar todos os atributos e métodos definidos na classe-pai, no caso a classe Pessoa, a Paciente tem seus próprios atributos e métodos que a diferenciam para o contexto que se predispõe a representar. Caro leitor, acredito que devidamente apresentado o conceito de herança, é necessário conhecermos a sintaxe para sua utilização na linguagem Java. O conceito de herança, no qual uma classe estende outra, é realizado por meio da utilização da palavra reservada extends, conforme é demonstrado hierarquicamente no quadro a seguir.

Capítulo 4 - Herança, polimorfismo e interfacet65

// Classe SuperClasse.java public class SuperClasse{ //atributos e métodos da superclasse } // Classe SubClasse.java public class SubClasse extends SuperClasse{ //atributos e métodos da subclasse }

No quadro anterior, é interessante notar que a superclasse não recebe nenhuma marcação que a diferencia. Porém, repare que para a subclasse, é definida a herança por meio da palavra reserva extends, que a torna uma extensão da superclasse. Com isso, podemos dizer que a subclasse, mais específica, possui o comportamento da superclasse. Outro ponto importante a mencionar, que é oriundo da utilização dos procedimentos de herança, é a utilização da palavra reservada super. Sua função é possibilitar à subclasse o acesso à superclasse. Assim, quando for necessário acessar algum método ou atributo na superclasse, a sintaxe para tanto será “super.nomeMétodo( )”. Desta forma, você está explicitando que deseja invocar um método da superclasse. Outro detalhe importante é quanto a invocar o método construtor da classe base e isto pode ser feito através da invocação do método “super( )”. Provavelmente, você ainda não deve ter percebido a importância do que foi dito até aqui. Pois bem, a importância está no fato de que, com a utilização dos princípios da herança, não é necessário que seja reescrita boa parte do código em um programa Java, pois tudo que já foi produzido na classe-pai fica à disposição da classe-filho. Outro detalhe importante a ser citado é que uma parte do código, que será comum a várias outras partes de um programa, pode ser escrita somente uma vez em uma classe-pai, como mencionamos. Com isso, caso seja necessária a manutenção de alguma parte desse código, não será necessário que seja alterado em todas as classes-filho, somente na classe-pai, e as demais subclasses herdarão a alteração. Do ponto de vista da manutenção do código, isso é um diferencial a ser considerado no processo de desenvolvimento com a tecnologia Java. Como nos demais conceitos trabalhados até aqui, vamos a um exemplo para fixar esse importante princípio da orientação a objetos que imita a realidade. Então, transcreva a classe a seguir.


// Classe Pessoa.java package consultorio; public class Pessoa{ // atributos String nome; String endereco; // métodos public void setNome(String newNome){ this.nome = newNome; } public void setEndereco(String newEndereco){ this.endereco = newEndereco; } public String getNome(){ return this.nome; } public String getEndereco(){ return this.endereco; } public void andar(){ System.out.println("Estou andando"); } }

Em nosso exemplo, foi definida a classe Pessoa, na qual estão detalhadas algumas características e comportamentos inerentes a uma pessoa real. Feito isto, contextualizando o problema, todos sabemos que um médico nada mais é que genericamente uma pessoa. Mas, não podemos deixar de considerar que ele, além de suas peculiaridades humanas, possui especificidades quanto ao exercício da profissão de um médico, que o diferem das demais pessoas, sendo assim, temos uma especificação da classe Pessoa. Desta maneira, podemos dizer que um médico tem uma relação “é um(a)” pessoa, com características e métodos específicos a este e que devem


ser considerados. Ao trabalhar com as relações do tipo “é um(a)”, temos uma chave para identificar e determinar quando uma classe deve ou não ser descendente de outra existente. Para ter uma melhor visualização do processo, transcreva a classe Medico e note que ela explicita o conceito de herança de atributos e métodos da classe Pessoa por meio da palavra reservada extends após o nome da classe. // Classe Medico.java package consultorio; public class Medico extends Pessoa{ // atributos String horario; String especialidade; // métodos public void setHorario(String newHorario){ this.horario = newHorario; } public void setEspecialidade(String newEspecialidade){ this.especialidade = newEspecialidade; } public String getHorario(){ return this.horario; } public String getEspecialidade(){ return this.especialidade; } }

Como dito, note que os atributos e os métodos que definem um médico como pessoa não foram novamente reescritos, pois já foram definidos na classe Pessoa, sendo reaproveitados pela classe Medico por meio da herança. Com isso, aquilo que foi definido para certa classe não precisa ser repetido para uma classe mais especializada originada da primeira, logo, seus atributos e métodos. Desta forma, o paradigma da orientação a objetos auxilia a


reduzir a repetição do código em um programa e em sua manutenção. Para ter uma melhor visualização prática das vantagens obtidas com a herança, vamos a um exemplo. Nele, utilizamos as classes criadas anteriormente na definição de um programa executável, no qual é feito o cadastro de um médico. Note que aqui, começamos a fazer com que a solução de nossos problemas passe a ter uma característica modular, aumentando o reuso e facilitando posteriormente a manutenção. // Classe Consultorio.java package consultorio; import java.util.Scanner; public class Consultorio{ public static void main(String[] args){ // instância da classe Medico Medico novoMedico = new Medico(); Scanner scn = new Scanner(System.in); // entrada de dados System.out.println("#####Cadastro Clinico#####"); System.out.println("Entre com o nome do médico:"); novoMedico.setNome(scn.next()); System.out.println("Entre com o endereço do” + “médico:"); novoMedico.setEndereco(scn.next()); System.out.println("Entre com o horario do” + “médico:"); novoMedico.setHorario(scn.next()); System.out.println("Entre com a especialidade do” + ”médico:"); novoMedico.setEspecialidade(scn.next()); //impressão dos dados obtidos e mantidos para o //objeto System.out.println("\n####DADOS DO MÉDICO####"); System.out.println("Nome do médico:"+novoMedico. getNome()); System.out.println("Endereço do médico:"+novoMedico.


getEndereco()); System.out.println("Horário do médico:"+novoMedico. getHorario()); System.out.println("Especialidade:"+novoMedico. getEspecialidade()); } }

No exemplo anterior, o mais importante a ser mencionado é que, mesmo não definidos na classe Medico, os atributos e os métodos referentes ao nome e ao endereço, que são oriundos da classe Pessoa, estão disponíveis para a instância da classe Medico denominada novoMedico. Isto, relembrando, só é possível graças à herança existente na classe Medico da classe Pessoa, evitando a reescrita do código já existente na superclasse Pessoa para a subclasse Medico. A utilização do processo de herança também é muito importante para as estruturas correlatas ou mesmo as definições de melhores práticas, como no caso de vários padrões do projeto. Fica como sugestão a leitura sobre design pattern, que pode enriquecer seus programas, além de evitar, em muitos casos, o retrabalho. Finalizando nossa seção que trata dos princípios da herança na orientação a objetos com Java, é importante citar que a linguagem não suporta a herança múltipla, assim como o C++. Entretanto, existem alternativas para lidar com tal limitação, que serão consideradas ainda neste capítulo. Com isso, chegamos ao final desta seção, na qual trabalhamos a importante característica do paradigma de orientação a objetos, que é a herança. Mas, iremos analisar outra característica não menos importante para a orientação a objetos baseada na tecnologia Java, o polimorfismo, que consiste em uma estrutura fortemente dependente do processo de herança. 4.2 Polimorfismo Como já dito na introdução deste capítulo, a palavra polimorfismo advém do grego polimorfos e significa diversas formas. Como observado em sua essência epistemológica da palavra, o conceito segue os mesmo princípios. Sendo mais especifico, o polimorfismo nada mais é que a definição de métodos com o mesmo nome, que definem a solução de um mesmo problema,


seja na própria classe, seja na superclasse. O conceito, mais um do paradigma da orientação a objetos, pode ser aplicado de duas formas: sobrecarga ou redefinição. Com certeza, a forma mais simples de obter o polimorfismo é por meio da sobrecarga de métodos ou também conhecido como overload. 4.2.1 Sobrecarga A sobrecarga, em sua essência, consiste na possibilidade de ter em uma mesma classe, vários métodos com o mesmo nome, “porém com assinaturas diferentes”. Mas, como assim com assinatura diferente? Certo, se você se lembra do conceito de assinatura visto em nosso primeiro capítulo, ele é aplicado aos métodos definindo o nome, tipo de retorno e lista de parâmetros ou argumentos. Neste caso, o que foi citado é que apesar do nome ser igual, o tipo de retorno ou mesmo a lista de parâmetros deve ser diferente para um método. Com isso, os métodos podem possuir o mesmo nome, sendo considerados diferentes por receberem um diferente número ou tipo de parâmetros, ou mesmo o tipo de retorno pode ser diferente. Este é um conceito muito simples de ser assimilado e para tanto, vamos utilizar nosso exemplo recorrente da classe Carro, na qual pode acontecer o polimorfismo. // Classe Carro.java package fabrica; public class Carro{ // atributos Combustivel combustivel = new Combustivel(); // métodos public void setCombustivel(Combustivel newCombustivel){ this.combustivel = newCombustivel; } public Combustivel getCombustivel(){ return this.combustivel; }


KK U X public void abastecer(Alcool abstAlcool) { setCombustivel((Combustivel) abstAlcool); System.out.println(“Abastecido com álcool”); } public void abastecer(Gasolina abstGasolina) { setCombustivel((Combustivel) abstGasolina); System.out.println(“Abastecido com gasolina”); } public void abastecer(BioDiesel abstBioDiesel) { setCombustivel((Combustivel) abstBioDiesel); System.out.println(“Abastecido com biodiesel”); } }

Aqui, é demonstrado um exemplo de sobrecarga dos métodos de uma mesma classe, no qual um carro pode ser abastecido de diversas maneiras, porém a essência da função é a mesma, no caso, abastecer o carro para que ele possa andar. É importante mencionar que o exemplo apresentado é apenas ilustrativo, uma vez que não foram apresentadas as classes Combustivel e suas especificações, no caso, Gasolina, Alcool e BioDiesel, que também foram utilizadas no exemplo. A ideia aqui é que seja entendida a essência do conceito de polimorfismo e sua abstração do mundo real. Conforme pode ser observado, em nosso dia a dia, uma mesma funcionalidade pode ser desempenhada de várias maneiras, porém devendo ser guardadas as devidas especificidades de funcionamento de cada uma. O exemplo disso é um carro bicombustível. Em nosso exemplo, mais um elemento importantíssimo que foi utilizado deve ser comentado - o cast.

4.2.2 Cast O cast é a forma mais comum de conversão de tipos, porém sua utilização possui algumas peculiaridades que devem ser observadas na hora da


utilização do recurso. O cast no Java pode ser realizado de duas formas, considerando a conversão dos tipos, sendo: implícito e explícito. Estes recursos, por sua vez, estão geralmente associados à utilização do conceito de herança, no qual, como vimos, uma classe-filho (subclasse) é semelhante à classe-pai (superclasse), da qual foram herdados os atributos e os métodos. É deste ponto que podemos partir para o entendimento do cast implícito. Neste caso, toda subclasse pode ser associada à declaração de uma superclasse. Esta é a forma mais simples, pois não há a necessidade de utilização de nenhum recurso adicional para ser efetuado, sendo apenas descrito por meio da declaração convencional de um objeto da classe-pai e do método construtor da classe-filho. Para ter uma melhor visualização, vamos a um exemplo. Pai objeto = new Filho();

Em nosso exemplo, o objeto é declarado como uma instância da classe-pai, porém ele é ‘construído’ como sendo do tipo da classe filho, ou seja, recebe uma área de memória referente à subclasse. Note que há uma conversão natural, pois ambos são semelhantes devido ao processo de herança. Grosseiramente, poderíamos dizer que isso é possível, pois a classe-filho pode ser hierarquicamente inferior à classe-pai, conhece e sabe que ela própria é do tipo superclasse e, portanto, não precisa necessariamente ser informada que será convertida. Isto é feito no momento em que utilizamos a palavra extends na classe-filho, ou seja, a herança. Já o cast em sua forma explicita, é denominado assim, pois é necessária a informação para a Máquina Virtual Java de qual classe se deseja fazer a conversão, no caso o cast. Neste caso, de uma classe-pai, tenta-se convertê-la em uma classe-filho. Porém, ao fazer novamente uma análise hierárquica para ter um melhor entendimento, a superclasse não sabe e em momento algum é informada quais são suas classes-filho. Portanto, é necessário informar explicitamente em qual tipo de classe-filho a instância da classe-pai será convertida. Então, caro leitor, aqui o convido a verificar como isso pode ser realizado na linguagem Java, observando a sintaxe no exemplo a seguir. Pai objetoPai = new Filho(); Filho objetoFilho = (Filho)objetoPai;


Em nosso exemplo, o objeto declarado como objetoPai é instanciado como sendo do tipo da classe Filho. Logo após, a referência do objetoPai é convertida por meio de um cast explicito no objetoFilho. Estes conceitos são importantes para que possamos também conhecer outro importante elemento da linguagem Java - o operador instanceof. 4.2.3 instanceof O instanceof é um operador utilizado para a realização de casts do tipo explícito, nos quais não se tem conhecimento de qual classe o define. Aqui, podemos trabalhar um pouco mais o exemplo apresentado da classe Carro quanto ao seu abastecimento. Vamos a ele então. ... public void encherTanque(Combustível c){ if(c instanceof Alcool){ abastecer((Alcool) c); }else{ abastecer((Gasolina) c); } } ...

No código anterior, repare que temos um método ‘encherTanque’ que recebe como parâmetro um objeto da classe Combustível. Dentro desse método, é verificado, por meio da utilização dos operadores condicionais if/else, qual o tipo de combustível. Para isso, dentro do teste, é utilizado o operador instanceof, que realiza a verificação de qual é o combustível selecionado. De acordo com o valor da instância, é chamado o método abastecer usando a sobrecarga de métodos. Simploriamente, instanceof significa “instância de” ou “é do tipo”. Assim, em nossa verificação anterior, no teste condicional o que é feito nada mais é que uma comparação para definir se o objeto passado como parâmetro é uma instância da classe Alcool ou da classe Gasolina.


4.2.4 Sobrecarga de construtores Outro exemplo que pode ser citado para o polimorfismo é a sobrecarga dos métodos construtores, onde são definidos diversos métodos com o mesmo nome, porém com assinaturas diferentes. Tais considerações já foram feitas em nosso terceiro capítulo, no qual definimos dois métodos construtores para uma classe, pois, conforme visto, uma vez declarado um construtor, qualquer que seja sua assinatura, passa a ser obrigatória a definição do método construtor default para sua utilização, já que o método construtor fornecido pela JVM deixará de ser fornecido. 4.2.5 Redefinição Nossa segunda forma de utilização do conceito de polimorfismo consiste na redefinição de métodos ou também conhecido como sobrescrita (override), isso realizado sobre os métodos existentes nas superclasses. Tal conceito está baseado na herança, da qual as subclasses herdam atributos e métodos de uma classe-pai. Isso devido ao seguinte fato: Imagine que nem sempre os métodos fornecidos pela classe-pai são suficientes para resolver os problemas da subclasse, visto que a classe-filho é uma especialização, tendo suas particularidades a serem consideradas no processo. É aí que entra a sobrescrita dos métodos, na qual a subclasse reescreve um método utilizando a mesma assinatura definida na classe-pai, sendo que no momento da invocação do método, dentro da subclasse, será acionado o método ali definido que se sobrepõe ao da superclasse. Vamos a um exemplo: imagine um pai e um filho, ambos são pessoas e assim, possuem características e comportamentos de um ser humano. É natural que o filho herde os trejeitos de seu pai, porém existem características e comportamentos que, por mais inerentes ao processo de herança que sejam, precisam ser especializados, ou seja, por mais que exista o processo de herança, ao falar, por exemplo, o filho possui especificidades em sua voz que são só suas, apesar da aproximada semelhança com a de seu pai. Para o paradigma da orientação a objetos, uma operação, ação ou mesmo uma transformação que um objeto realiza por meio dos métodos são implementações específicas das operações desejadas para uma classe. Então, mesmo que esta venha a herdar os atributos e os métodos de outra classe, sempre terão prioridade as características e os comportamentos definidos


para o escopo específico da classe. Para ter um melhor entendimento, vamos a uma implementação. Altere a classe Medico do exemplo apresentado na seção anterior, no qual essa classe herda os atributos e os métodos da classe Pessoa. // Classe Medico.java package consultorio; public class Medico extends Pessoa{ // atributos String horario; String especialidade; // métodos public void setHorario(String newHorario){ this.horario = newHorario; } public void setEspecialidade(String newEspecialidade) { this.especialidade = newEspecialidade; } public String getHorario(){ return this.horario; } public String getEspecialidade(){ return this.especialidade; }

KK YZ X public void andar(){ System.out.println("Estou andando rápido"); } }

Note que no exemplo apresentado, foi criado na classe Medico o método andar( ). Tal método já havia sido definido na classe Pessoa, na seção anterior, e devido ao processo de herança existente entre as classes Pessoa e


Medico, não foi necessária sua reescrita na classe filho, ou seja, na classe Medico. Porém, devido às características específicas da classe Medico, esse método é redefinido e, então, passa a atender as particularidades dessa classe. Assim, a máquina virtual Java entenderá que ao ser invocado um método, no qual houve o processo de redefinição, o método da subclasse será o que deve ser acionado. Caro leitor, acredito que até aqui você deve ter verificado que o conceito de polimorfismo é importantíssimo para o paradigma de orientação a objetos, assim como os demais mecanismos de abstração de dados, herança e encapsulamento já apresentados. 4.3 Interface Amigo leitor, agora que já conhecemos os conceitos de herança e polimorfismo, vamos a outro conceito-chave no paradigma da orientação a objetos - as interfaces. O conceito de interface é um tanto amplo, já que ao trabalharmos com o Java, ele está constantemente presente. De um lado, como vimos, toda classe no Java tem um propósito específico, geralmente se relaciona com outras classes e aí, temos um sistema completo e funcional que se comunica por meio de mensagens. Essas mensagens são trabalhadas por meio dos métodos definidos segundo os modificadores de acesso e tais métodos são interfaces (entradas) para o acesso ao conteúdo de uma instância. Mas, a tecnologia Java ampliou o conceito, tornando-o ainda mais flexível. Poderíamos dizer grosseiramente que a tecnologia Java possui um tipo especial de classe que são as interfaces. Isso ocorre devido à sintaxe de definição de uma interface no Java ser semelhante à utilizada para uma classe. Entretanto, no lugar do identificador class, deve ser utilizada a palavra reservada interface. A ideia central do conceito de interface é a modelagem dos comportamentos que são esperados na definição de uma determinada classe. O nome interface coerentemente tem o objetivo de explicitar que esse conceito Java pretende disponibilizar um meio padronizado de acesso a diferentes tipos de implementação como uma interface propriamente dita. Para isso, em uma interface são definidos apenas métodos abstratos e variáveis finais. Um ponto importante a ser destacado é o fato de uma interface não ter uma implementação para seus métodos ou mesmo instâncias para suas variáveis. Logo, a utilização das interfaces garante que você sempre se concentre nos objetos e nos relacionamentos que existirão,


construindo, desta forma, uma espécie de planta baixa do sistema para possibilitar a construção baseada nos modelos existentes, definindo assim uma camada extra de abstração para seu sistema que servirá de base para o restante. O código a seguir apresenta a sintaxe para a definição de interfaces nos Java. // Interface Aluno.java package escola; public interface Aluno{

!# ^`|~~U~

!# # &' public abstract int faltas();

!# # & '

!# # & ' }

Algumas considerações devem ser feitas e estar sempre em mente quanto à utilização das interfaces. Uma interface não pode ser instanciada, sendo que seu objetivo é definir um modelo de comportamento abstrato para as classes. Tais classes que se propõem a implementar a interface devem fornecer a implementação dos métodos declarados na interface ou, ao menos, declará-los em seu escopo. Uma boa analogia para as interfaces é imaginá-las como sendo um contrato, no qual qualquer classe que se propõe a implementar a interface deve, ao menos, declarar métodos e variáveis estáticas e finais em seu escopo. Note que no exemplo anterior, é feita a utilização da palavra reservada abstract. Ela pode referenciar tanto métodos quanto classes ao apresentar apenas a ideia ou mesmo um modelo do todo, sem que seja fornecida a implementação para tais métodos ou classe, deixando explícita somente a abstração do objeto. O conceito de abstração muitas vezes se confunde com o conceito de interface. A função das classes abstratas é forçar o programador a implementar subclasses para a resolução dos problemas. Assim, os métodos da classe abstrata são declarados com o modificador abstract e sem corpo. Voltando ao conceito de interface, para que uma classe implemente uma interface, em sua definição deve ser colocado o identificador


implements seguido da lista de interfaces separadas por vírgulas. Vamos a um exemplo de uma classe que implementa a interface aluno definida no quadro anterior. // Classe AlunoImp.java package escola; public class AlunoImp implements Aluno{ // atributos

!" private int faltas; // métodos

!# &' return nota1(nota1)+nota2(nota2)/2; } public int faltas(){ return faltas; }

!# & ' this.nota1 = nota; return nota1; }

!# & ' this.nota2 = nota; return nota2; } }

Caro leitor, vamos entender o exemplo apresentado no quadro anterior. Conforme pode ser observado, a classe AlunoImp implementa a interface Aluno e, então, deve fornecer uma implementação para os métodos declarados na interface Aluno, que foi construída anteriormente. Além de fornecer a ideia de um contrato entre as classes, conforme mencionado, outro aspecto que pode ser explorado no conceito de interface, consiste na ideia da plugabilidade. Vamos a um exemplo para deixar tal perspectiva


mais clara. Imagine uma classe que utiliza uma determinada interface que disponibiliza os métodos abstratos para a conexão com um banco de dados. Assim, existem diversas formas de implementar uma conexão. Logo, podemos ter uma interface que defina todas as maneiras como uma conexão pode ser implementada, cabendo ao desenvolvedor plugar o método que lhe for mais conveniente, isso sem a necessidade de alterações drásticas no programa, uma vez que todas as classes que implementam tal interface para a conexão, de alguma maneira, deverá comprometer-se a fornecer todos os métodos, como em um contrato, independentemente da forma como será implementado cada método. Vamos a outro exemplo clássico e bem simples para o entendimento da ideia de plugabilidade, que é elemento central em vários padrões de projetos utilizados. Pois bem, imagine uma empresa de software que possui um programa de controle médico. Este pode ser aplicado tanto a clínicas para tratar pessoas quanto a clínicas veterinárias. Tal sistema é relativamente simples e realiza apenas o controle de pacientes. Verificando o funcionamento de ambas as clínicas, os processos são idênticos, apesar de lidar com pacientes completamente diferentes. Resumindo, o sistema pode ser utilizado em ambos os casos. Mas, como? No caso, poderia ser criada uma interface Paciente que definiria os métodos comuns aos pacientes, restando as classes que implementam tal interface. Então, observe o código a seguir. // Interface Paciente.java package clinica; public interface Paciente { public void setNome(String nome); public void setHistorico(String historico); public String getNome(); public String getHistorico(); }

Observe a seguir que nossas classes Pessoa e Animal, que implementam a interface Paciente, a partir deste momento deveriam ter as seguintes definições obrigatoriamente.


// Pessoa.java package clinica; public class Pessoa implements Paciente { // atributos private String nome; private String historico; // Métodos public void setNome(String nome) { this.nome = nome; } public void setHistorico(String historico) { this.historico = historico; } public String getNome(){ return nome; } public String getHistorico(){ return historico; } }

Definida a classe Pessoa, para a classe Animal teríamos uma semelhança, uma vez que ela deve também implementar a interface Paciente. // Animal.java package clinica; public class Animal implements Paciente { // atributos private String nome; private String historico; // Métodos public void setNome(String nome) { this.nome = nome;


} public void setHistorico(String historico) { this.historico = historico; } public String getNome(){ return nome; } public String getHistorico(){ return historico; } }

Isso permite uma padronização dos procedimentos ou mesmo que o código possa ser utilizado duas ou mais vezes, dando extensibilidade ao programa, bastando apenas que seja construída uma nova classe que se proponha a implementar a interface e assim, que se possam utilizar todos os demais benefícios de seguir tais regras. Para tanto, teríamos como declaração dos objetos das classes, por exemplo. // Clinica.java package clinica; public class Clinica { public static void main(String[] args){ Paciente p = new Pessoa(); Paciente a = new Animal(); // Dados para a pessoa p.setNome(“Alex Coelho”); p.setHistorico(“Apresentou problemas na” + “garganta.”); // Dados para o animal a.setNome(“Totó”); a.setHistorico(“Problemas na pata.”); // Imprimindo os relatórios


Relatorios r = new Relatorios(); r.imprimirRelatorio(p); r.imprimirRelatorio(a); } }

Note que em ambos os casos, o espaços de memória construídos são diferentes, um para a pessoa ou para o animal. Porém, quanto à sua definição, são do mesmo tipo, no caso instâncias da interface Paciente. Repare. Paciente p = new Pessoa(); Paciente a = new Animal();

Isso nos garante uma padronização nos processos, fazendo com que outras funcionalidades do sistema possam ser utilizadas de forma extensível a vários produtos. No nosso caso específico, a vantagem de utilizar a interface Paciente se caracterizaria na utilização dos procedimentos de geração de relatório, por exemplo, como é apresentado no código a seguir e já referenciado no exemplo anterior. // Relatorios.java package clinica; public class Relatorios { public void imprimirRelatorio(Paciente p) { System.out.println(“Relatório de Pacientes”); System.out.println(“Nome:”+p.getNome()); System.out.println(“Histórico:” +p.getHistorico()); System.out.println(“Histórico:” +p.getCadastro()); } }

Para finalizarmos nosso capitulo, vamos a outra funcionalidade que o conceito de interface possibilita, sendo a manipulação da herança múltipla no Java.


4.3.1 Herança múltipla Embora a linguagem Java não forneça um mecanismo explícito que possibilite a herança múltipla, ou seja, uma classe herdar de mais de uma classe, com a utilização de interfaces é possível obter algo próximo da essência do conceito, com a implementação de diversas interfaces por uma classe. Como uma classe pode implementar diversas interfaces e deve prover implementações para os métodos declarados nas interfaces, obtém-se uma pseudosobrescrita dos métodos e com isso, ela disponibiliza todos os métodos e atributos para as classes que a utilizam. Para ter um melhor entendimento, vamos a mais uma analogia. Um exemplo clássico é o do carro anfíbio, que possui características e comportamentos tanto de um carro quanto de um barco. Então, nosso primeiro passo é criar as interfaces que definem os métodos. // Carro.java package estaleiro; public interface Carro { public void puxarFreioDeMao(); } % ?

na herança múltipla.

// Barco.java package estaleiro; public interface Barco { public void navegar(); }

Feito isso, agora é necessário criar a nossa classe CarroAnfibio que irá implementar as interfaces propostas e com isso, passará a ser obrigada a reescrever os métodos propostos nas interfaces. Assim, vamos ao que interessa. Transcreva o código a seguir e analise sua utilização.


KK ~#" package estaleiro; !# ~# implements Carro, Barco { public void puxarFreioDeMao() { System.out.println(“Puxou o freio de mão!”); } public void navegar() { System.out.println(“Navegando!”); } }

Repare no exemplo que com isso, garantimos o comportamento ambíguo do objeto real com a utilização das interfaces que mapearam o problema. Acredito que com isso, você tenha conseguido visualizar toda a vantagem de utilizar interfaces, que consiste na definição de um protocolo que seja comum entre as classes, além de criar uma especificação do que uma classe deverá oferecer e implementar em termos de métodos, o que resulta numa forma de abstração. Então pessoal, chegamos ao final dos principais conceitos do paradigma de programação orientada a objetos, porém isso não significa o final de nossa jornada. Nos próximos capítulos, iremos conhecer ferramentas interessantes que irão possibilitar a você, caro leitor, ter um melhor aproveitamento da linguagem Java e dos conceitos do paradigma de programação orientada a objetos. Assim como nos capítulos anteriores, aproveite para refazer todos os exemplos propostos.

Capítulo 5 Ferramentas úteis para o dia a dia Neste capítulo, iremos considerar diversas ferramentas para um programador Java. Elencar quais seriam as prioridades de um programador em seu cotidiano não é algo tão simples assim, porém com certeza a manipulação de strings, trabalho com datas e horas, definição de operações matemáticas e manipulação de vetores especiais estão entre as funções que mais se destacam. Assim como mencionado no início de nosso livro, tudo no Java consiste em classes, exceto os tipos primitivos. Relembrando nossos tipos primitivos: int, float, boolean etc. Nossas classes derivam da classe Object, que tem as definições padrão para qualquer classe. Logo, todas as funcionalidades e operações que são fornecidas pela biblioteca padrão da tecnologia Java são definidas em classes que operam por meio de seus métodos. Diante disso, iremos abordar como a linguagem Java possibilita o trabalho com estas importantes ferramentas para o dia a dia. 5.1 Manipulação de strings Como já vimos desde o início de nossa leitura, a classe String trata-se de uma das mais utilizadas, ao considerarmos que no cotidiano computacional, em sua maioria, as operações dependem deste tipo de dado em sua entrada. Pois bem, diversas linguagens apresentam formas diferentes de lidar com as strings, seja no formato de um vetor de caracteres, seja mesmo fornecendo uma operação responsável por desempenhar a função de elemento agregador destes. A tecnologia Java fornece a classe String para a realização de operações e a manipulação de palavras e frases. Como você deve já ter percebido, diferentemente dos tipos primitivos, tais como int, float e assim por diante, sempre que instanciamos um objeto do tipo String, com ‘S’ maiúsculo em sua inicial, isso denota, segundo a convenção existente entre os desenvolvedores Java e já conhecida por você, que se trata de uma classe. Por se tratar de uma classe, ela nos fornece uma gama de serviços que podem ser acionados por meio de seus métodos. São tais métodos que tornam as classes


diferenciadas dos tipos primitivos, como já citado. A tecnologia Java fornece classes que também auxiliam na manipulação dos principais tipos, como, por exemplo, Int, Float, classe Boolean, entre outras. Repare que aqui temos o mesmo padrão: todas as iniciais são maiúsculas, logo, todas são classes que agregam valores aos tipos de dados por meio de métodos. Mas iremos apenas nos concentrar aqui na manipulação de strings com as principais operações possíveis utilizando o Java. Desta forma, conheceremos os principais métodos disponibilizados pela classe String, começando pela utilização de seus métodos construtores. 5.1.1 Construtores da classe String Assim como em todas as classes Java, é necessária a existência de um método construtor responsável por garantir a instanciação dos objetos do tipo String. Pois bem, a classe String fornece dois métodos construtores para a instanciação de seus objetos, sendo um parametrizado e outro default. Outra forma, no entanto, de realizar a criação de nosso objeto é por meio da passagem de valor explícita, ao qual o objeto fará sua referência. Vamos observar como pode ser realizada a criação de nossos objetos da classe String. String s = “Palavra”; String s1 = new String(); String s2 = new String(“Palavra”);

Repare que tudo que foi apresentado no quadro anterior não é novidade. Vários exemplos já apresentados a você, leitor, nos demais capítulos fizeram menção a alguma das possibilidades de criação ou instanciação de objetos da classe String. É vital para seus programas que o objeto seja construído com algumas das possibilidades mostradas, garantindo que não ocorra erro de pontos nulos, sem uma referência de memória. 5.1.2 Outros métodos Considerando inicializados nossos objetos, vários métodos são úteis para a manipulação de Strings, como segue na Tabela 5. Consideremos um objeto ‘s’ do tipo String para a sintaxe.

Capítulo 5 - Ferramentas úteis para o dia a diat87

Tabela 5. Principais métodos da classe String. Método

Função

Sintaxe

length( )

Retorna o número de caracteres da string.

Int tamanho = s.lenght( );

charAt(int)

Captura um caractere na posição especificada na string.

char caractere = s.charAt(3);

equals(String)

Compara duas strings e retorna um valor booleano (verdadeiro ou falso)

Boolean iguais = s.equals(s1);

equalsIgnoreCase(String)

Compara duas strings ignorando a diferença entre minúsculas e maiúsculas e retornando valores booleanos.

Boolean iguais = s.equalsIgnoreCase(s1);

compareTo(String)

Compara duas strings e retorna 0 se ambas forem iguais. Se a string que chama o método for menor que a passada como parâmetro, será retornado um número negativo e caso contrário, um número positivo.

Int result = s.compareTo(s1);

substring(int) substring(int, int)

Retorna um novo objeto String a partir do ponto especificado em valor inteiro ou, então, delimitando a posição inicial e final.

indexOf(char)

Retorna a posição da primeira ocorrência do caractere passado como parâmetro na string que invocou o método.

String nova = s.substring(3); String nova = s.substring(3,5);

Int posicao = s.indexOf(‘A’);


toUpperCase( )

Retorna um novo objeto String com todos os valores em maiúsculo.

String nova = s.toUpperCase( );

toLowerCase( )

Retorna um novo objeto String com todos os valores em minúsculo.

String nova = s2.toLowerCase( );

Amigo leitor, como você deve ter percebido, a classe String fornece diversas possibilidades que podem tornar a vida do programador mais fácil. Outros métodos da classe String poderiam ser considerados aqui. Assim, fica como dica que você verifique na documentação oficial da classe String as demais possibilidades para a manipulação das strings. Porém, nem só de strings vive um programa, outras classes devem ser consideradas como elementos comuns e interessantes para o cotidiano de um desenvolvedor Java. Entre tais classes, podemos citar as classes que auxiliam na manipulação de datas e horas, sendo nosso próximo assunto. 5.2 Data e hora Um dos elementos que mais geram problemas e controvérsias na programação Java, com certeza consiste na manipulação de datas e horas. Isso pode tomar proporções ainda maiores quando falamos de aplicações que irão rodar e depender da Internet e de seus diversos servidores espalhados pelo mundo. Considerando tais problemas, a tecnologia Java fornece um conjunto de classes que, conforme já vimos, disponibilizam uma grande variedade de métodos que possibilitam o trabalho com datas e horas. As principais classes que são utilizadas para a manipulação de datas são: java.util.Date, java. util.Calendar e java.util.GregorianCalendar. É importante mencionar que a classe Date está em desuso e, portanto, em processo de depreciação, o que pode fazer com que nas próximas versões da máquina virtual Java, ela não seja mais fornecida e os sistemas que a utilizam tenham problemas devido à sua falta. Mas, ainda assim, é importante apresentá-la ao considerarmos que diversos sistemas ainda a utilizam. Certo, então, nada melhor que apresentar sua utilização com um código. Logo, transcreva o código a seguir e execute-o.


// ExemploData.java import java.text.SimpleDateFormat; import java.util.Date; import java.util.GregorianCalendar; public class ExemploData { public static void main(String[] args) { Date d = GregorianCalendar.getInstance(). getTime(); SimpleDateFormat format = new SimpleDateFormat(); System.out.println(format.format(d)); } }

Com a execução do programa, você deve ter percebido outra possibilidade da classe Date, que consiste na manipulação de informações sobre o tempo, tais como: hora, minutos, segundos e milissegundos. No exemplo apresentado, note que a data impressa segue o padrão americano e para isso, é necessária a manipulação de sua formatação, que é feita no método construtor da classe SimpleDateFormat. Essa classe fornece um conjunto de caracteres padrão para a formatação do objeto Date. Podemos citar alguns exemplos de formatações de datas, como a seguir. dd/MM/yy = 21/08/11 dd/MMM/yyyy = 21/AGO/2011

Para obtermos a formatação no padrão brasileiro, criaremos uma classe alterada no trecho que se refere ao método construtor da classe SimpleDateFormat, como apresentado a seguir. Execute o código e verifique sua saída. // Data.java import java.text.SimpleDateFormat; import java.util.Date; import java.util.GregorianCalendar; public class Data {


public static void main(String[] args) { Date d = GregorianCalendar.getInstance().getTime(); SimpleDateFormat format = new SimpleDateFormat(“dd/MM/yy”); System.out.println(format.format(d)); } }

É importante mencionar aqui que a classe SimpleDateFormat conta com a utilização de diversos caracteres que auxiliam na formatação para a manipulação de datas e as mesmas, estão disponíveis em sua documentação padrão. Outra maneira de obtermos a data pode ser com a utilização das classes DateFormat e Locale. A classe Locale é importante, pois auxilia na designação do local e no processo de alteração dos padrões regionais. A mesma já vem com diversas regiões preconfiguradas como constantes, que apenas necessitam ser determinadas no momento de sua implementação. Já a classe DateFormat, define alguns padrões que podem ser aplicados a uma data ou hora. Vamos a um exemplo para sua fixação. // DataFormatada.java import java.text.DateFormat; import java.util.Locale; import java.util.Date; public class DataFormatada { public static void main(String args[]){ Date d = new Date(); Locale local = new Locale («pt»,»BR»); DateFormat df = DateFormat.getDateInstance( DateFormat.LONG, local); System.out.println(“Hoje são: “+ df.format(d)); } }

Porém, como mencionado, a classe Date está em processo de descontinuação e dessa forma, a tecnologia Java passa a fornecer outras classes para


a manipulação de datas. A principal, com certeza, consiste na Calendar. A classe Calendar consiste em uma classe abstrata, ou seja, contém as abstrações que definem uma data e hora, e desta forma, disponibiliza atributos e métodos para a manipulação de datas, uma vez que a data e a hora existem em qualquer lugar. Mas, o fato de ser uma classe abstrata não permite a instanciação direta por meio do operador new. Assim, para instanciar um objeto Calendar, caro leitor, você deve utilizar o método estático sobrecarregado getInstance( ), que na maioria das vezes é herdado da classe GregorianCalendar. A classe Calendar permite que várias operações sejam aplicadas a uma data, enriquecendo o que já é ofertado pela classe Date. Para entender sua manipulação, vamos a um exemplo. // ExemploDataCalendar.java import java.text.DateFormat; import java.util.Calendar; import java.util.Date; public class ExemploDataCalendar { public static void main(String args[]){ Date d = new Date(); Calendar calendario = Calendar.getInstance(); calendario.setTime(d); DateFormat df = DateFormat.getDateInstance( DateFormat.SHORT); System.out.println( df.format(calendario.getTime())); } }

Repare que no exemplo, utilizamos uma instância da classe Date para definirmos a data atual passada pelo sistema, porém poderíamos também ter, ao invés de utilizado o objeto do tipo Date, definido por meio de String os diversos parâmetros de uma data ou mesmo hora. Segue um exemplo para a visualização.


... calendario.set(ano,mês,dia); calendario.set(ano,mês,dia,hora,minuto); calendario.set(ano,mês,dia,hora,minuto,segundo); ...

Porém, nem sempre é interessante utilizar a classe Date, dada sua atual situação, sendo que a própria classe Calendar com a utilização do método getInstance( ) já fornece todo o suporte necessário para a aquisição da data. Além disso, o objeto do tipo Calendar, no nosso caso, calendário, pode ser utilizado para a manipulação dos elementos vinculados à data por meio de suas constantes, além de realizar, como já dito, operações como, por exemplo, a soma ou a subtração dos dias em uma data. Como nos demais tópicos trabalhados até aqui, vamos a mais um exemplo. // DataCalendario.java import java.text.DateFormat; import java.util.Calendar; import java.util.Locale; public class DataCalendario { public static void main(String args[]){ Calendar calendario = Calendar.getInstance(); DateFormat df = DateFormat.getDateInstance( DateFormat.SHORT, Locale.UK); System.out.println(df.format (calendario.getTime())); System.out.println(Calendar.DAY_OF_MONTH); System.out.println(Calendar.DAY_OF_WEEK); System.out.println(Calendar.DAY_OF_YEAR); calendario.add(Calendar.DAY_OF_YEAR,10); //adiciona 10 dias à data atual calendario.add(Calendar.MONTH,5); //adiciona 5 meses à data atual calendario.add(Calendar.YEAR,2); //adiciona 2 anos à data atual System.out.println(df.format (calendario.getTime()));


} }

No exemplo anterior, utilizamos duas classes conhecidas, DateFormat e Locale. Note que utilizamos a constante “Locale.UK” que define que seguiremos os aspectos regionais da Grã-Bretanha. Logo depois, é feita a impressão da data e algumas operações para, então, termos uma nova impressão da data com os valores alterados. É claro que existem diversos outros métodos e constantes que a classe Calendar oferta e, logo, para serem obtidas maiores explicações, podem ser acessadas na documentação oficial. 5.3 Operações matemáticas Outra classe importante para o cotidiano de um programador Java é a java.lang.Math. Ela disponibiliza diversos métodos e constantes para as operações matemáticas que podem ser acessadas de maneira estática, ou seja, não é necessário realizar a instanciação de um objeto. Exemplos das diversas possibilidades são as constantes π (pi) e ln (base dos logaritmos naturais, também chamado de número de Euler ou logaritmo neperiano), sendo respectivamente 3,141592653589793 e 2.718281828459045. Essas duas constantes podem ser acessadas conforme o exemplo a seguir explicita. // Matematica.java public class Matematica { public static void main(String args[]){ // Cálculo do comprimento de um círculo double comp = 2 * raio * Math.PI; System.out.println(comp); // Logaritmo neperiano System.out.println(Math.E); } }

Foram apresentadas no código as constantes “Math.PI” e “Math.E” que, conforme já mencionado, simplificam a utilização dos valores para π


e ln. Porém, nem só de constantes vivem as operações matemáticas e para isso, a classe Math disponibiliza vários métodos que auxiliam nas mais diversas operações. Entre os principais métodos ofertados pela classe, temos a comparação de valores maiores e menores, bem como operações como potências e raízes para os cálculos de Trigonometria. Considerando isso, vamos à apresentação de métodos para uma comparação para o conhecimento de sua sintaxe. // ComparaValores.java public class CamparaValores { public static void main(String[] args) { " System.out.println(“O maior valor é “ + Math.max(valores1[0], valores1[1])); System.out.println(“O menor valor é “ + Math.min(valores1[0], valores1[1])); } }

Verifique que no exemplo, foi realizada a comparação de valores, sejam eles máximos, sejam mínimos por métodos da classe Math. Porém, a maioria dos métodos fornecidos pela classe Math auxilia na manipulação dos valores trigonométricos. Para verificarmos a utilização dos métodos da classe Math para a Trigonometria, nada mais interessante que utilizar o clássico exemplo da hipotenusa. Logo, transcreva o código e execute-o. // Hipot.java public class Hipot{ public static void main(String args[]) { double p1 = 12; double p2 = 16; System.out.println(“A distancia entre os pontos é “ + Math.hypot(p1, p2)); } }


Outros métodos, como os que calculam o seno, cosseno e tangente, além de suas variações, são fornecidos pela classe Math. Finalizamos nossa análise sobre os métodos da classe Math com um dos mais utilizados e importantes, que é o “Math.random( )”. O método trabalha com valores randômicos que variam de 0.0 até 1.0. Em geral, é necessária a manipulação de tais valores para se obter sua utilidade para a criação de aplicações do dia a dia, como podemos perceber no exemplo a seguir. // NumeroRandomico.java public class NumeroRandomico { public static void main(String[] args) { int valorMin = 0; int valorMax = 10; int ranger = valorMax - valorMin; double valorRandomico; for (int i = 0; i < 10; i++) { valorRandomico = Math.random(); System.out.println(“O número entre” +valorMin+” e “+valorMax+” é:” + Math.round( valorMin + valorRandomico * ranger)); } } }

No exemplo, definimos os valores mínimos e máximos que definem o limite para os valores randômicos que queremos. Logo após, criamos uma variável que recebe o valor randômico. Finalizando, temos um laço de repetição, no qual realizamos o arredondamento da transformação dos valores fracionados. É importante mencionar que existem outros métodos da classe Math que podem ser utilizados para as operações matemáticas que agregam valor às suas aplicações. 5.4 Trabalho com vetores especiais Como temos visto desde o início de nosso trabalho, a tecnologia Java


se destaca claramente das outras devido à sua diversidade. Diante isso, outra ferramenta que deve ser mencionada, entre as diversas que a linguagem Java disponibiliza, consiste nas classes para o trabalho com vetores. Em sua maioria, as diversas linguagens de programação disponíveis no mercado trabalham com vetores convencionais que delimitam um tamanho fixo. Isto é, impedem que estes sofram alteração de tamanho durante a execução, como, por exemplo, os que foram desenvolvidos em nosso primeiro capítulo. A linguagem Java fornece subsídios adicionais para a manipulação dos vetores, resolvendo problemas como o citado, no caso, a alteração de tamanho durante a execução. Além disso, disponibiliza classes para as operações de nossos vetores estáticos. Isso tudo obviamente é feito por um conjunto de classes. 5.4.1 Classe Vector Entre estas, temos a Vector, que possibilita a criação de uma estrutura de dados semelhante aos vetores convencionais, porém os objetos instanciados com a utilização dessa classe podem ser redimensionados dinamicamente durante a execução. Logo, a qualquer momento, quando é necessário mais espaço para o armazenamento, o próprio sistema, por meio da máquina virtual, encarrega-se de dobrar o tamanho do espaço inicialmente alocado para o vetor, no caso, um objeto da classe Vector. Pois bem, outra característica, que deve ser considerada e que torna a classe Vector diferenciada, está na capacidade de armazenar qualquer tipo de entidade, independentemente de seu tipo. Isto se dá devido ao fato da classe Vector fazer o armazenamento de referências para Object. Logo, como já sabemos, tudo no Java consiste nas classes que herdam de Object e isso, garante que possamos trabalhar com qualquer que seja o tipo do elemento a ser armazenado no vetor. Então, nada como a prática para entendermos melhor os conceitos apresentados. Vamos a eles. // Classe ExemploVector.java import java.util.Vector; public class ExemploVector{ public static void main(String[] args){


Vector vetor = new Vector(); Carro mercedez = new Carro(); vetor.add(mercedez); Bola bolaFutebol = new Bola(); vetor.add(bolaFutebol); if(!vetor.isEmpty()){ for (int i = 0; i < vetor.size(); i++) { Object object = vetor.elementAt(i); } System.out.println(vetor.size()); } } }

No exemplo anterior, um detalhe a ser observado está no fato de que, diferentemente dos vetores trabalhados até aqui, não definimos o tamanho de nosso vetor para a variável ‘vetor’. Isso graças à capacidade da classe Vector que determina o tamanho a ser alocado durante a execução, sendo que isso é ideal para a manipulação de grandes vetores, bem como estruturas heterogêneas. Por ser uma classe, Vector disponibiliza para seus objetos, no caso, vetores especiais, funcionalidades que não são comuns aos vetores tradicionais, tais como, a verificação do tamanho do vetor ou mesmo se eles estão vazios, conforme foi apresentado no exemplo, através dos métodos size( ) e isEmpty( ). Entretanto, isto não elimina um dos maiores problemas do trabalho com vetores, que é sua navegação e busca. Imagine um vetor que cresce e tem um tamanho de um milhão de posíções. No caso, isso tornaria o processo de busca computacionalmente inviável, já que para encontrar um elemento, seria necessário percorrer o vetor. Isto se torna mais crítico, caso o objeto procurado esteja no final do vetor. Para solucionar esse problema, a linguagem Java fornece outra classe para o trabalho com vetores - a HashMap.


5.4.2 Classe HashMap Seu diferencial está no fato de que ela permite a associação de índices que identificam e tornam o objeto único dentro do vetor. Tal índice se torna uma chave para a recuperação do valor de maneira pontual. Isto garante que possa ser realizada uma consulta de um vetor de um para um. Obviamente, isto é bem diferente do que ocorria com a definição dos vetores estáticos vistos em nosso primeiro capítulo ou mesmo nos definidos com a classe Vector. Depois destas considerações, vamos a um exemplo com a classe HashMap. // Classe NovoVetor.java import java.util.HashMap; public class NovoVetor{ public static void main(String[] args) { HashMap pessoas = new HashMap(); Pessoa newPessoa = new Pessoa(); newPessoa.nome = "Fulano da Silva"; String chave = "Fulano"; pessoas.put(chave, newPessoa); Pessoa outraPessoa = (Pessoa)pessoas.get(chave); System.out.println("Nome recuperado: "+ outraPessoa.nome); } }

Note que no exemplo anterior, foi instanciado um objeto do tipo HashMap denominado pessoas, no caso um vetor, e por meio do método put( ), foi armazenado um objeto da classe Pessoa. Repare que foi necessária a atribuíção de uma chave para a identificação do objeto, que será utilizado em uma posterior recuperação. Isto, por sua vez, é feito com a utilização do método get( ) da classe HashMap, como visto no código anterior. É importante ainda mencionar que o toolkit Java possui ainda uma classe que disponibiliza métodos para a realização de operações nos vetores. Essa classe não é denominada por acaso de Arrays.


5.4.3 Classe Arrays A classe Arrays fornece suporte para as principais manipulações que um vetor pode sofrer, no caso a comparação, ordenação ou mesmo pesquisas binárias, além de outras. Para verificarmos o funcionamento da classe Array, transcreva o código e execute para verificar seu resultado. // Classe ManipulandoArrays.java import java.util.Arrays; public class ManipulandoArrays { public static void main(String[] args) { String[] nomes = new String[3]; nomes[0]= "Fulano"; nomes[1]= "Ciclano"; nomes[2]= "Beltrano"; Arrays.sort(nomes); for(int i=0;i
A classe Array, como pode ser observado, consiste em uma classe que manipula vetores estáticos. Além disso, é uma classe abstrata que não precisa ser instanciada para a utilização, sendo utilizada sua própria referência. Ela, como já dito, possui uma série de métodos, entre eles, provê o método sort( ) que foi utilizado no exemplo, responsável por ordenar o array passado como parâmetro, realizando internamente um mecanismo de comparação entre as strings e ordenando-as. Note que utilizamos o atributo length para que a impressão ordenada dos nomes fosse realizada através da estrutura de repetição for. Isto abre espaço para que seja comentado que mesmo os vetores sendo estruturas estáticas, estes possuem alguns atributos e métodos que auxiliam em sua manipulação, como, por exemplo, o método equals( ). Com isso, chegamos ao final de mais um capítulo. Nosso próximo compromisso é a necessidade de trabalharmos com o tratamento de exceções no Java, o que nos abrirá caminho para elementos mais avançados, tais como, o trabalho com arquivos ou a manipulação de streams.

Capítulo 6 Tratamento de exceções e entrada de dados ! " # $ #%& # # & ' & $ ( $ ( $ ) ! * $ # # & $ $ # # + ! ( % , $ / ( # ! # ( + ! & 011 #! $ 0 % ( $ $ 23 $ ( $ $ Como mencionado, diversas classes fornecidas pelo JDK podem ser utilizadas para fornecer tal suporte para as aplicações desenvolvidas, diminuindo o tempo de possíveis manutenções que venham a ocorrer e aumentando a capacidade dos programas em Java.


6.1 Tratadores de exceções A exceção na linguagem Java é uma indicação de que um erro ou um problema aconteceu durante a execução de uma aplicação. Isto se torna mais suscetível considerando que a linguagem Java fornece uma grande quantidade de bibliotecas, no caso, APIs, ou mesmo classes próprias. A ideia nem chega perto da perfeição, mas, ao menos, tenta garantir à tecnologia, que as classes de exceção tratem as situações de erros moderados que podem ser encontrados e visualizados em seus programas e, então, recuperados. Uma maneira interessante de interpretar essas exceções é sempre trabalhar os trechos de código que apresentam um grau maior de possibilidade de que um erro possa vir a acontecer e geralmente, isto está vinculado à utilização de recursos externos à tecnologia. Isto, em um contexto mais recente e atualizado, no qual os sistemas são construídos sem critérios, torna a tecnologia Java um elemento diferenciado e um porto seguro para o desenvolvimento de soluções complexas na construção de aplicações críticas, tais como, sistemas hospitalares, de aviação e até mesmo espaciais e de robótica. O tratamento de exceções no Java nada mais é que um processo de gatilho, que ao ser disparado um erro como mensagem para o sistema, possibilita que seja trabalhada a exceção. Este processo demonstra ao sistema o erro, além de relatá-lo para o entendimento e o tratamento da melhor solução para a recuperação e a continuídade das próximas rotinas do programa. Assim, o tratamento de exceções geralmente deve ser utilizado ao: Processar situações excepcionais, nas quais um método seja incapaz de terminar sua função por razões que fogem ao seu controle; Processar exceções de componentes que não estão projetados para realizarem tais tarefas diretamente; Em projetos de grande porte para tratar as exceções de maneira uniforme em todo o projeto. A manipulação das exceções em Java é feita da mesma maneira como na linguagem C++, com a utilização das claúsulas try e catch. A cláusula try é utilizada para indicar o trecho de código que será executado e no qual poderá ocorrer uma exceção, no caso, um pedaço de código onde a possibilidade de que possíveis erros ocorram é maior, tal como a abertura de um arquivo ou mesmo a abertura de uma conexão de rede com outro computador, e como já mencionado, a conexão com um banco de dados.

Capítulo 6 - Tratamento de exceções e entrada de dadost103

Já na declaração da cláusula catch, define-se o código a ser executado, caso algum erro ou, no caso, uma exceção venha a acontecer durante a execução da instrução principal, presente na cláusula try. O quadro abaixo demonstra a organização das cláusulas try/cath que devem ser utilizadas dentro do escopo de um programa Java. ... try{ ... // trecho do código a ser executado }catch(Classe que trata a excecao){ ... // tratamento da exceção } ...

Um detalhe importante a ser considerado está na possibilidade de existirem quantas cláusulas catch forem necessárias para o melhor desempenho da aplicação. Isto se deve ao fato de poderem existir vários tipos de possíveis exceções e obviamente, é interessante que exista um tratamento específico para cada um desses gargalos do que, por exemplo, apenas um tratamento generalista que possa vir a comprometer sua recuperação e continuídade na execução do programa. Além disso, podem ocorrer situações nas quais é necessária a execução de alguma tarefa ou instrução, ocorrendo ou não uma falha no trecho de código principal, ou seja, com o perfeito funcionamento da aplicação ou não. Aqui, entra em cena a cláusula finally, na qual é definido o bloco de código que será executado havendo ou não o lançamento de uma exceção. Sua utilização deve ocorrer após a declaração das cláusulas try e catch. Assim, temos uma nova estrutura para o tratamento das exceções nos Java, como apresentado no trecho a seguir. ... try{ ... // trecho de código a ser executado


}catch(Classe que trata a excecao){

... // tratamento da exceção }catch(Classe que trata a excecao){ ... // tratamento da exceção ... /*código a ser executado com ou sem exceção */ } ...

Aqui, é necessário que façamos algumas considerações para entendermos o tratamentos de exceções. Conforme você deve ter observado nos quadros, a cláusula catch obriga-nos a adotar uma classe que será responsável por tratar os possíveis erros que venham a ocorrer. As cláusulas vistas até aqui de nada serviriam se não existissem classes responsáveis pela identificação dos erros lançados pela JVM, além de possuir métodos que possibilitem o entendimento do problema e dos elementos para a sua recuperação. Existem algumas classes que devem ser conhecidas para a sua manipulação, em conjunto com as cláusulas para tratar as exceções mais comuns, sendo apresentadas na Tabela 6. Tabela 6. Principais exceções. Classe

Função

ArithmeticException

Classe utilizada para tratar as exceções em operações aritméticas e lança uma exceção quando estas são impossíveis de ser realizadas.

NullPointerException

Utilizada para o controle de instâncias e ocorre quando um objeto é instanciado.


NegativeArraySizeException

Classe utilizada para o controle de vetores e ocorre quando um valor nulo é atribuído a uma posição do array.

ArrayIndexOutOfBoundsException

Utilizada para o controle de vetores e ocorre quando se tenta acessar uma posição do array que não existe.

IOException

Utilizada para tratar as exceções nas operações de entrada e saída de dados.

Exception

Classe geral para o tratamento de exceções, ou seja, qualquer que seja o erro. Além disso, utilizada pelas demais classes que tratam os erros por meio da herança.

Bom pessoal, assim como qualquer classe, as de exceção devem ser importadas para a utilização dentro de um programa. Como feito nos demais capítulos trabalhados até aqui, nada como implementar alguns exemplos para a fixação dos novos e essenciais conceitos da linguagem Java vistos em nosso sexto capítulo. Assim, transcreva o código observando a utilização das cláusulas para o tratamento de exceções, então ao final, execute o programa para visualizar o resultado. // Classe Excecao.java public class Excecao{ public static void main(String[] args){ int a = 20; int b = 0; int c = 0; try{ c = a/b; }catch(ArithmeticException e){ System.out.println(“Problemas na operação”); System.out.println(e); }


$ ! &!YZ ?' } } }

No exemplo apresentado, foi criado um programa que contém um problema matemático, com a divisão por 0. Assim, obrigamos que a cláusula catch seja executada. Verifique que todas as informações necessárias para o entendimento do problema são disponibilizadas pela instância da classe ArithmeticException. Além disso, a cláusula finally é executada ao final do programa com o lançamento da exceção. Nos últimos anos, várias tecnologias têm contribuído para o avanço da tecnologia Java, tornando-a mais interessante em diversos aspectos, incluindo também o tratamento de exceções. Um novo conceito que vem ganhando espaço é a Programação Orientada a Aspectos. A orientação a aspectos é um paradigma de programação que vem sendo desenvolvido para somar valor à POO (Programação Orientada a Objetos) e assim, tornar todo o processo de programação mais eficiente. Fica a dica de uma leitura complementar sobre a Programação Orientada a Aspectos, que é algo facilmente encontrado na Web. Outro detalhe sobre o tratamento de exceções que deve ser comentado é que a tecnologia Java permite outra forma de realizar o tratamento. Este consiste na utilização da cláusula throws. 6.1.1 Throws Assim como nas cláusulas try/catch, a throws é a responsável por tratar os possíveis erros que venham a acontecer, porém a cláusula throws exige que sejam listadas as classes que tratam as possíveis exceções que podem ser disparadas na assinatura de um método. Para ter uma melhor compreensão, vamos à sintaxe da cláusula throws. ... tipoDeRetorno nomeDoMetodo() throws ClasseDeExcecao1, ClasseDeExcecao2, ...{ // corpo do método } ...


Aqui, cabe dizer que a única diferença entre as duas sintaxes apresentadas é que as cláusulas try/catch definem seu bloco de código que será tratado, caso ocorra alguma exceção. A cláusula throws, por sua vez, é sempre definida para um método de uma classe, logo, a qualquer momento dentro do método ao ocorrer um erro, as classes definidas são executadas para tratá-lo. Vamos a um exemplo para o conceito apresentado. // Classe ExcecaoThrows.java public class ExcecaoThrows{ public static String divisao(int a, int b)throws ArithmeticException{ return “O valor da divisão é “ + a/b; } public static void main(String[] args){ int a = 20; int b = 0; int c = 0; divisao(a,b); } }

Bom, conforme mencionado, o método de divisão da classe ExcecaoThrows.java utiliza a palavra reservada throws para invocar a classe ArithmeticException para realizar o tratamento do erro matemático. Com o conhecimento adquirido para o tratamento de erros, abrimos espaço para também apresentarmos uma nova maneira de obter os dados oriundos do teclado, que é por meio da utilização das classes BufferedReader e InputStream. 6.2 Entrada de dados Conforme você já deve ter percebido, o método apresentado, e que você conhece desde o início da leitura de nosso livro, no qual utilizamos objetos da classe Scanner, possui suas limitações,.além de ser instável e inviável para as grandes quantidades de dados digitados. Pois bem, agora iremos verificar uma nova forma de realizar a manipulação dos dados vindos do teclado.


Como já foi mencionado no início de nosso livro, a classe System é responsável por controlar todas as funções do sistema. E por meio de System.in, estamos lidando diretamente com as entradas de dados. Até aqui, nenhuma novidade. Porém, existem outras classes que substituem a classe Scanner na manipulação dos dados, no caso, InputStream e BufferedReader. A primeira é reponsável pela leitura do fluxo de entrada. A segunda, pela manutenção no buffer dos dados que foram digitados até que seja pressionada a tecla Enter. Pois bem, para que você possa compreender e verificar o funcionamento dessa modalidade de entrada de dados, vamos a um exemplo. // ManipulacaoDados.java import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; public class ManipulacaoDados { public static void main(String args[]){ String dados = new String(); BufferedReader entr = new BufferedReader( new InputStreamReader(System.in)); try { System.out.println(“Entre com a sua frase:”); dados = entr.readLine(); System.out.println(“A frase digitada foi:”+dados); } catch (IOException e){ System.out.println(“Erro ao ler string”); e.printStackTrace(); } } }

Você deve estar perguntando: Mas, por que isso não foi apresentado antes? No caso, esta metodologia de entrada de dados não foi demonstrada anterioremente, pois necessitava do tratamento de exceções, uma vez que estamos lidando com alguns elementos critícos, tais como, a manipulação de streams, buffer, e isso nos força a lidar com um tratamento prévio dos riscos que podem ser impostos à nossa aplicação.


Entendendo o que foi feito em nosso exemplo, verifique que inicialmente foi declarada uma variável de dados do tipo String, que receberá os valores oriundos do teclado. Para isso, no entanto, foi necessária a utilização dos objetos da classe BufferedReader e InputStream. A primeira, como mencionado, apenas armazena os dados oriundos do teclado, obtidos por meio da InputStrem, que é responsável por recuperar os dados de entrada do sistema, no caso, o teclado, por meio de System.in. O método readLine( ), do objeto da classe BufferedReader, faz com que o sistema passe a esperar a entrada de dados e armazená-los na memória durante a execução. Encerrando este capítulo, vale resaltar que as duas classes citadas nesta seção também são úteis para a manipulação de arquivos, característica essa que consideraremos em nosso próximo capítulo.

Capítulo 7 Manipulação de arquivos de texto Bom pessoal, chegamos ao nosso último capítulo e para finalizarmos os conceitos e as tecnologias introdutórias da tecnologia Java, nada como aprendermos a criar, realizar a entrada e a leitura de dados nos arquivos texto. Os conceitos trabalhados até aqui nos demais capítulos serão essenciais para uma melhor compreensão dos conceitos relacionados ao trabalho com arquivos, principalmente os referentes ao tratamento de exceções, considerados no capítulo anterior. Estudar a manipulação de arquivos é de extrema importância, pois geralmente todas as aplicações trabalham com algum tipo de persistência de dados, uma vez que todos os exemplos realizados e apresentados até aqui somente fazem uso da memória volátil de seu computador. Ou seja, todos os dados são perdidos assim que finalizamos nossa aplicação, como você já deve ter percebido. Diante de tais fatos, a maneira mais básica e simples de realizar a persistência dos dados é por meio da utilização de arquivos. Isso possibilita que as informações das aplicações possam ser recuperadas após sua finalização, abrindo novas possibilidades para seus programas. Obviamente, existem formas mais profissionais de manter os dados, como, por exemplo, a utilização de Sistemas Gerenciadores de Banco de Dados (SGBD), mas, em diversos momentos, a manipulação de arquivos é útil e interessante, mantendo, na maioria das vezes, neutralidade dos dados. Neste primeiro livro, não iremos abordar a manipulação do banco de dados, uma vez que o objetivo aqui é fazer com que este livro seja um referencial para as disciplinas introdutórias de programação. A tecnologia Java fornece diversas classes e com isso, formas para o trabalho com arquivos, no caso, a criação, armazenamento e recuperação de dados. Então, vamos apreciá-las. 7.1 Arquivos A primeira coisa que devemos tratar sobre a manipulação de arquivos


com Java é a oferta de um pacote destinado a manipulá-los, denominado java.io. É esse pacote que mantém a maioria das classes que podem ser utilizadas para o trabalho com arquivos. Um detalhe importante que deve ser mencionado é que, em sua maioria, os programadores tratam a leitura e a escrita, respectivamente, como operações de entrada e saída de dados em um arquivo. Tal notação é uma formalização do processo e também é comum em outras linguagens de programação, tais como C e C++. Além disso, a notação apresentada demonstra uma relação do ponto de vista da aplicação, na qual o arquivo a ser lido passa ser uma fonte de entrada de dados a serem processados e depois, saindo da aplicação, eles são escritos e mantidos novamente no arquivo. O java.io é um dos pacotes mais extensos da tecnologia Java, com mais de 50 classes que fornecem suporte para o trabalho com arquivos, além de funcionalidades como, por exemplo, a compactação de arquivos, mas, em sua maioria, tais classes são classificadas nos dois grandes grupos já mencionados, no caso, a entrada e a saída de dados. É importante mencionar que as operações irão depender do tratamento de exceções para a realização da manipulação dos arquivos. Geralmente, para estes casos, é utilizada a classe IOException que também faz parte do pacote java.io e traz funcionalidades que auxiliam na recuperação dos erros que possam vir a acontecer. Outro importante detalhe a ser mencionado sobre o pacote java.io é o fato de que as classes oferecidas permitem também o trabalho com arquivos especiais como binários, de buffer, como vimos no capítulo anterior, ou mesmo stream de vídeo e som. Aqui, não iremos considerar tais classes, mas uma boa gama deste material pode ser encontrada na Web. Diante de tantas possibilidades, é necessário que façamos uma seleção das principais para que concentremos nossos esforços. No caso, estaremos trabalhando com FileReader, Scanner, PrintWriter, FileInputStream, FileOutputStream, RandomAccessFile e IOException. 7.2 Entradas Indo ao que realmente interessa, no caso, a leitura de dados em arquivos, que é considerada uma forma de entrada de dados para uma aplicação, a linguagem Java fornece uma classe que possibilita este processo - a FileReader. Sua utilização não apresenta nada fora do normal das demais classes consideradas até aqui. Assim, devemos realizar a criação de um objeto da FileReader

Capítulo 7 - Manipulação de arquivos de textot113

que fornece atributos e métodos para manipulação do arquivo. Entretanto, a classe FileReader necessita da utilização de uma classe já conhecida para realizar o acesso e a manipulação dos dados vindos do arquivo. Essa classe consiste na Scanner, classe com a qual já trabalhamos no início de nosso livro. Pois bem, se você lembra, a Scanner é responsável por auxiliar na manipulação dos dados que vêm do teclado, acessando o atributo de entrada de dados da System.in. Em nosso caso, só mudaremos a fonte dos dados, que antigamente consistia no teclado e agora, é o arquivo. Iremos, agora, utilizar a classe Scanner para realizar operações no objeto da classe FileReader, que faz referência ao local onde se encontra o arquivo de texto. Nada como um bom exemplo para entender o processo. Transcreva o código abaixo e execute-o para verificar seu funcionamento. // LerArquivo.java import java.io.IOException; import java.io.FileReader; import java.util.Scanner; public class LerArquivo{ public static void main(String[] args) { FileReader arq = null; try { arq = new FileReader( "c:\\programas\\Arquivo.txt"); } catch (IOException e) { e.printStackTrace(); } Scanner leitor = new Scanner(arq); while(leitor.hasNextLine()){ String linha = leitor.nextLine(); System.out.println(linha); } } }


É bom mencionar que, para nosso programa funcionar, o arquivo ao qual fizemos a referência com o objeto da classe FileReader deve estar no mesmo local onde a classe se encontra. Uma forma de resolver este problema é passando o caminho de referência completo para o local no qual o arquivo se encontra, no caso, “C:\programas\Arquivo.txt”. É importante citar que foi necessária a realização do tratamento de exceção que possa vir a acontecer, como, por exemplo, o fato do arquivo não ser localizado. Isso obviamente foi realizado com a utilização das cláusulas try/catch, além da classe IOException. Ainda em nosso exemplo, um objeto da classe Scanner foi instanciado, sendo passada, como parâmetro, a instância da classe FileReader, denominada arq, que define o caminho do arquivo, como já analisado. Após, é utilizada a estrutura de repetição while para a leitura linha a linha do arquivo e uma posterior impressão do conteúdo. Conforme vimos, a manipulação de arquivos no Java trata-se de uma rotina simples, sem muitos segredos, isso graças ao suporte que a tecnologia fornece. Entretanto, vale ressaltar que tais funcionalidades dependem da correta utilização das classes do pacote java.oi. Apresentado o conceito de entrada de dados, ou seja, a leitura de um arquivo, vamos ao processo de criação e escrita ou, conforme já é de seu conhecimento, à saída de dados utilizando a classe PrintWriter do pacote java.io. 7.3 Saídas Após verificarmos como funciona o processo de entrada de dados, iremos trabalhar com a criação e a gravação de dados em um arquivo no formato de texto, utilizando para isso, a classe PrintWriter. Tal classe fornece atributos e métodos para a manipulação de arquivos, entretanto, aqui também é necessária a utilização da classe IOException para o tratamento das exceções, assim como é feito para a leitura de dados. Mas aqui, trataremos os erros que venham a ocorrer no processo de criação e escrita dos dados. Vamos colocar a mão na massa e escrever mais um exemplo. Neste caso, um no qual iremos criar um arquivo e escrever uma mensagem dentro deste. // EscreverArquivo.java import java.io.IOException; import java.io.PrintWriter;


public class EscreverArquivo{ public static void main(String[] args) { PrintWriter arq = null; try { arq=new PrintWriter("dados.txt"); arq.println("Mensagem escrita"); arq.close(); } catch (IOException e) { e.printStackTrace(); } } }

Vários detalhes devem ser mencionados sobre o processo de criação e escrita em arquivos. Inicialmente, um importante detalhe a ser descrito, e que você deve levar em consideração sobre a criação e a escrita, é que se seu arquivo já existir, ele será recriado e com isso, todos os dados existentes anteriormente serão perdidos. Outro detalhe é que para que todos os dados sejam persistidos em um arquivo, é necessário que sempre ao final do processo de escrita, ou seja, ao final da utilização da instância da classe PrintWriter, seja feita a invocação do método close( ). Tal processo pode ser contemplado no exemplo anterior. Finalmente, no programa anterior, note que foi utilizado para a escrita do conteúdo, o método println( ), também da classe PrintWriter. Então, vamos tornar nosso exemplo mais interessante. Para isso, iremos, com a utilização da classe Scanner, capturar os dados do teclado e persisti-los em um arquivo. Este será nomeado com o nome definido pelo usuário. Então, transcreva o código e execute-o para verificar seu adequado funcionamento. // CriandoArquivo.java import java.io.IOException; import java.io.PrintWriter; import java.util.Scanner; public class CriandoArquivo{ public static void main(String[] args) {


Scanner entrada=new Scanner(System.in); PrintWriter arq = null; System.out.println("Nome do arquivo"); String nome = entrada.nextLine(); System.out.println("Entre com os dados"); String dados = entrada.nextLine(); try { arq = new PrintWriter(nome); } catch (IOException e) { e.printStackTrace(); } arq.println(dados); arq.close(); } }

Note que no exemplo, por meio do operador new e o construtor da classe PrintWriter, foi passado o nome do arquivo a ser criado. Entretanto, esse arquivo só será efetivamente criado após a execução do método close( ), ou seja, ao finalizar o programa. Com isso, verificamos o processo de criação e escrita em arquivos, sendo algo bem mecânico. 7.4 Streams Outra possibilidade de trabalhar com a manipulação de entrada e saída de dados consiste na utilização das classes FileInputStream e FileOutputStream. Essas classes são extremamente úteis, pois nem só de arquivos com texto natural vivem nossos programas. Estas são úteis para as manipulações de todos os tipos de arquivos. Assim como nas demais classes vistas até aqui, a FileInputStream e a FileOutputStream são fornecidas pelo pacote java.io. Elas são utilizadas para manipular fluxos de bytes, ou seja, possibilita uma manipulação em um nível mais baixo. Estes dados, na maioria das vezes, se alterados, comprometem sua estrutura e possível utilização. Ou seja, para uma manipulação mais segura e da qual dependemos de uma maior segurança, as classes são recomendadas. Como os próprios nomes sugerem, a FileInputStream é utilizada para a entrada de dados e a FileOutputStream, para a saída. Um aspecto


importante a ser colocado aqui é o fato de que assim como nas classes FileReader e PrintWriter, já vistas, para as classes que auxiliam na manipulação de streams também é necessária a utilização do tratamento de exceção. Para ter uma melhor compreensão do que foi considerado, veja o exemplo a seguir e execute-o. // Classe ExemploStream.java import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; public class ExemploStream{ public static void main(String[] args) { FileOutputStream saida = null; FileInputStream entrada = null; try { saida = new FileOutputStream(“dados.txt”); saida.write(1010); entrada= new FileInputStream(“dados.txt”); System.out.print(entrada.read()); } catch (IOException e) { e.printStackTrace(); } } }

No exemplo anterior, foi criado um arquivo e escrita uma linha de stream com a utilização do método write( ) da classe FileOutputStream. Logo após, é realizada a leitura dos dados escritos e a impressão destes por meio do método read( ) da classe FileInputStream. Repare que o processo de criação dos objetos para a manipulação dos arquivos de stream é semelhante aos realizados até aqui com outras classes pertencentes ao pacote java.io.


7.5 Acessos aleatórios em arquivos Em todos os exemplos apresentados até aqui, toda a leitura é realizada de maneira sequencial, ou seja, do início do arquivo até seu fim, sempre nessa ordem. No entanto, em diversas situações, assim como no caso dos vetores, isso pode ser caro computacionalmente. Imagine que você esteja buscando uma informação em um arquivo extenso e essa informação esteja apenas no final do arquivo. Pois bem, para que você chegue a essa informação, deve percorrer todo o arquivo. Isso muitas vezes complica todo o processo. No caso, é muito mais econômico computacionalmente realizar a leitura de uma posição especifica no arquivo ou mesmo a escrita em determinado ponto. Para isso, a tecnologia Java fornece a classe RandomAccessFile, que possibilita o trabalho de acesso aleatório a posições dentro dos arquivos. A RandomAccessFile é mais uma classe que também faz parte do pacote java.io. Bom, neste caso, a vantagem de manipular seus arquivos com as instâncias dessa classe é nítida, indo pontualmente no local no qual se deseja escrever ou ler. Para tanto, são utilizados métodos para as operações nos arquivos, tais como seek( ), length( ), read( ) e write( ), entre os principais. Aqui, oriento que o exemplo seja transcrito e executado. // Aleatorio.java import java.io.IOException; import java.io.RandomAccessFile; public class Aleatorio{ public static void main(String[] args) { try {

~ ~& “dados.txt”,”rw”);

&'

$ ! &&'' } catch (IOException e) { e.printStackTrace(); } } }


Alguns aspectos do código anterior devem ter chamado a sua atenção. No caso, a classe RandomAccessFile trabalha com o conceito de definição do tipo e acesso, sendo que tal definição é realizada no momento da instanciação do objeto com a utilização de seu construtor. Obviamente, são utilizados parâmetros no momento da abertura do arquivo para a definição das permissões no arquivo. Os tipos de acesso que podem ser trabalhados consistem, respectivamente, nos atributos ‘r’ e ‘rw’, que indicam que o arquivo deve ser aberto somente para a leitura e quando podem ser realizadas operações tanto de leitura quanto de escrita, respectivamente. Para o posicionamento do cursor no arquivo na posição na qual se deseja realizar a escrita ou a leitura, é necessária a utilização do método seek( ). Para a leitura, continuamos a trabalhar com o método read( ), conforme demonstrado no exemplo. Da mesma forma, podemos realizar a escrita, sendo que para isso, utilizamos o método write( ) da própria classe RandomAccessFile. Aqui, entretanto, é importante mencionar que existem diversas vertentes do método write permitindo que sejam trabalhados vários tipos de dados disponibilizados pela tecnologia Java. Existem métodos, tais como writeInt( ), writeBoolean( ) e writeChars( ), que possibilitam o tratamento de cada tipo de dado. Isso auxilia o desenvolvedor, pois evita que seja perdido tempo realizando sua conversão ou mesmo manipulação para persistir os dados. Para visualizar o resultado destas operações, altere o exemplo anterior conforme é demonstrado a seguir. // Classe Aleatorio.java import java.io.IOException; import java.io.RandomAccessFile; public class Aleatorio{ public static void main(String[] args) { try {

~ ~& “dados.txt”,”rw”);

&'

$ ! &&''

&` '

&'


} catch (IOException e) { e.printStackTrace(); } } }

No caso em específico, a estrutura continua a mesma e deve ser realizado o tratamento de exceções, já que sua manipulação pode acarretar problemas para a aplicação. Caro amigo, assim finalizamos nossa leitura. Espero que este manuscrito tenha sido de proveito para que você entenda os detalhes e os conceitos básicos da programação baseada na tecnologia Java, principalmente os vinculados ao paradigma da programação orientada a objetos. Obviamente que a tecnologia não se restringe somente aos tópicos mencionados até aqui. Poderíamos citar a criação de aplicações desktop com a utilização da API Swing, além do acesso ao banco de dados com a JDBC (Java Database Connection) ou ainda a criação de programas para dispositivos móveis ou Web, tudo baseado no Java. Mas, obviamente que minha intenção até aqui sempre foi garantir que fossem apresentados os elementos que possam subsidiar o conhecimento dessas novas ferramentas que estão à sua disposição. Sinceramente, desejo-lhe sucesso nos seus desafios e espero revê-lo em breve.

Referências Bibliográficas BOENTE, Alfredo. Aprendendo a Programar em Java 2: Orientado a Objetos. Rio de Janeiro: Brasport, 2003. ANSELMO, Fernando. Aplicando Lógica Orientada a Objetos em Java. 2. ed. Florianópolis: Visual Books, 2005. CARDOSO, Caíque. Orientação a Objetos na Prática: Aprendendo Orientação a Objetos com Java. Rio de Janeiro: Ciência Moderna, 2006. DEITEL, Harvey M. Java: Como Programar. 6ª ed. São Paulo: Pearson Prentice Hall, 2005. SANTOS, Rafael. Introdução à Programação Orientada a Objetos Usando Java. Rio de Janeiro: Campus, 2003. PUGA, Sandra; RISSETTI, Gerson. Lógica de Programação e Estruturas de Dados: com Aplicações em Java. São Paulo: Pearson Prentice Hall, 2004. Horstmann, Cay; Cornell, Gary. Core Java, Volume 1 – Fundamentos. 8 Edição. São Paulo: Pearson, 2010. Block, Joshua. Java Efetivo - 2ª Edição. Rio de Janeiro: Alta Books, 2008. Furgeri, Sergio. Java 7 - Ensino Didático. São Paulo: Editora Érica, 2010. Sierra, Kathy; Bates, Bert. Use a Cabeça Java. Rio de Janeiro: Alta Books, 2005.

Apêndice I Instalação do Sdk e Configuração das Variáveis de Ambiente (Windows Xp) Para o download do JDK, siga os seguintes passos: 1. Acesse por meio de um navegador o endereço: http://java.oracle. com 2. Após acessar o endereço, clique no link Java SE em “Downloads” ou em “Top downloads”. 3. Logo em seguida, clique no botão “Java Platform” para selecionar a versão “Standard Edition” da tecnologia.

4. Após isso, aceite o termo e selecione o tipo de Sistema Operacional no qual a tecnologia será executada. No caso do Windows, selecione conforme apresentado a seguir.


5. Caso tudo tenha ocorrido conforme o esperado, será aberta a janela para o download do arquivo. 6. Depois, basta seguir as orientações do software no momento de sua instalação. Para as variáveis de ambiente, siga os seguintes passos: 1. Selecione Iniciar > Painel de Controle > Sistema.

Apêndice It125

2. Selecione Avançado > Variáveis de Ambiente.

3. Clique em Nova.


4. Em “Nome da Variável”, digite JAVA_HOME. 5. Em “Valor da Variável”, digite o caminho onde foi instalado o Java em seu computador. Copie o caminho literalmente como é exibido, por exemplo, no Explorer.

6. Clique em OK. 7. Procure a variável PATH, selecione-a e escolha “Editar”.

Apêndice It127

8. Em “Valor da Variável”, acrescente ao valor já existente em seu final: “;%JAVA_HOME%\bin”.

9. Clique em OK. 10. Selecione Avançado > Variáveis de Ambiente > Nova, assim como foi feito para a criação da variável JAVA_HOME. Se estiver em dúvida, observe o processo feito anteriormente. 11. Em “Nome da Variável”, digite CLASSPATH. 12. Em “Valor da Variável”, digite “.;%JAVA_HOME%\lib\tools.jar”.

13. Clique em OK. 14. Clique novamente em OK. Para que você tenha certeza dos efeitos das mudanças, reinicie o sistema.

Apêndice II JAVADOC 1. Inicialmente, é necessário realizar o comentário de documentação em sua classe definindo e seguindo os elementos definidos pela tecnologia Java. Existem diversas tags especiais definidas pela tecnologia, que auxiliam na definição de informações importantes e na formatação padrão, tais como, @author, @see e @return. Veja o exemplo: /** * @see java.lang.Object * @author Alex Coelho */ public class Carro{ public String cor; public String marca; public String modelo; /** * Construtor Carro * @param Carro * @throws Sem Exceções */ public Carro(Carro novo){ this.cor = novo.cor; this.marca = novo.marca; this.modelo = novo.modelo; } /** * Método andar que imprime * o valor String na tela * @see java.lang.String


*/ protected void andar(){ ligar(); System.out.println(“Carro andando”); } /** * Método parar que imprime * o valor String na tela * @see java.lang.String */ protected void parar(){ System.out.println(“Carro parado”); } /** * Método ligar que imprime * o valor String na tela * @see java.lang.String */ private void ligar(){ System.out.println(“Carro ligado”); } }

2. Feitos os comentários necessários, digite o comando javadoc em seu prompt de comando para sua classe, como segue o exemplo: javadoc NomeDaClasse.java Veja o funcionamento:

Apêndice IIt131

Se tudo correu conforme o esperado, você deve ter acesso a uma página html na mesma pasta onde se encontra sua classe, como é demonstrado a seguir.

É importante mencionar que a maioria das IDEs disponíveis no mercado possui algum tipo de suporte para agilizar e garantir a documentação com Javadoc. Para obter maiores informações, acesse: http://www.oracle.com/technetwork/java/javase/documentation/ index.html.

Java na Web $XWRU$QW¶QLR1HWR S£JLQDV lHGL©¥R )RUPDWR[ ,6%1

A complexidade e o crescimento da Internet fez com que surgissem vários modelos e propostas para a comunicação entre aplicações e que esses fossem apresentados como opções de computação distribuída. Este livro aborda as principais tecnologias da plataforma Java 2 Enterprise ! " ! !!#$%&'''%( vêm se tornando uma das mais bem sucedidas para desenvolvimento em ambiente Web. ) ' '* +, +! / +0/ !1 314 !!5*67 8'(9 !:';*<'! =>$<sentados.

À venda nas melhores livrarias.

Impressão e acabamento

<=>?@BFBGFHJK=B&HLM@HB0KFN=MB/JFB Tel: (21) 2201-6662

Java com Orientação a Objetos

Recommend Documents