Java Fundamentos

Fundamentos da Linguagem de

Programação

Java

Benedito C. A. Petroni

Cláudio L. V. Oliveira

Fundamentos da Linguagem de Programação Java I Benedito C. A. Petroni / Cláudio L. V. Oliveira


Programação

Java

Capa: Claudia Baptistella Oliveira

http://www.artesclaudia.com.br

Fundamentos da Linguagem de Programação Java II Benedito C. A. Petroni / Cláudio L. V. Oliveira

Sumário

Principais Características da Linguagem de Programação Java ................................................................................................. 8

Tipos de Dados ....................................................................................................................................................................... 10

Orientação a Objetos – Parte 1: Introdução ............................................................................................................................. 12

Estrutura Básica de Aplicação em Java ................................................................................................................................... 18

Vetores e Matrizes .................................................................................................................................................................. 23

Instruções de Controle ............................................................................................................................................................ 24

Orientação a Objetos – Parte 2: Herança ................................................................................................................................. 30

Orientação a Objetos – Parte 3: Interfaces e Implementações .................................................................................................. 34

List e ArrayList ....................................................................................................................................................................... 40

Apêndice A: Utilização do NetBeans .................................................................................................................................. 49

Apêndice B: Utilização do Eclipse .......................................................................................................................................... 52

Fundamentos da Linguagem de Programação Java III Benedito C. A. Petroni / Cláudio L. V. Oliveira

Lista de Figuras

Figura 1: Interface da IDE Netbeans ...................................................................................................................................... 19

Figura 2: Construindo novo projeto na IDE NetBeans. ........................................................................................................... 49

Figura 3: Escolhendo o tipo de aplicação na IDE NetBeans.................................................................................................... 50

Figura 4: Interface da IDE NetBeans para programação em Java. ........................................................................................... 51

Figura 5: Resultado de compilação na IDE NetBeans. ............................................................................................................ 51

Figura 6: Interface da IDE Eclipse. ........................................................................................................................................ 52

Figura 7: Criação de um projeto na IDE Eclipse. .................................................................................................................... 53

Figura 8: Interface da IDE Eclipse para programação em Java. .............................................................................................. 54

Figura 9: Criando uma classe na IDE Eclipse .......................................................................................................................... 55

Figura 10: Console de ocorrências de erros de compilação na IDE Eclipse. ............................................................................ 55

Figura 11: Resultado da compilação no console da IDE Eclipse. ............................................................................................. 56

Fundamentos da Linguagem de Programação Java IV Benedito C. A. Petroni / Cláudio L. V. Oliveira

Lista de Tabelas

Tabela 1. Principais tipos de dados na linguagem Java ........................................................................................................... 10

Tabela 2. Principais classes para tipos de dados ..................................................................................................................... 11

Fundamentos da Linguagem de Programação Java V Benedito C. A. Petroni / Cláudio L. V. Oliveira

Sobre os Autores

Benedito Cristiano Aparecido Petroni Mestre em Sistemas de Computação pela Pontifícia Universidade Católica de Campinas

(2006), Pós Graduado em Design e Aplicações para Internet pela Universidade São

Francisco Itatiba (2001), e Graduado em Análise de Sistemas pela Universidade São

Francisco - Itatiba (1998). Possui ampla experiência na área de Ciência da Computação,

com ênfase em desenvolvimento de sistemas em Instituições de Ensino Superior,

plataformas para Ensino à Distância (EAD). Pesquisa a área de Sistemas Inteligentes

através da técnica de Inteligência Artificial, Agentes Inteligentes (AI) e Interação Humano

Computador (IHC). Atualmente desenvolve conteúdos para assessoramento e treinamentos

de ferramentas para análise e desenvolvimento de sistemas. Docente da Faculdade de

Tecnologia de Jundiaí e Bragança Paulista (FATEC), Universidade Paulista (UNIP) e

Sócio-Diretor da TecnologiaEducacional.Com©.

Cláudio Luís Vieira Oliveira Mestre em Sistemas de Computação pela Pontifícia Universidade Católica de Campinas

(2005) e graduado em Análise de Sistemas pela Universidade Metodista de Piracicaba

(1990). Apresenta larga experiência na área de Ciência da Computação, com ênfase em

Sistemas de Computação, atuando principalmente nos seguintes temas: sistemas de bancos

de dados,linguagens de programação Java, C++, C#, programação para a web (HTML,

XML, ASP, PHP, JSP e Servlets), plataforma .NET, desenvolvimento de aplicações para

dispositivos móveis, redes de computadores, sistemas distribuídos, arquitetura orientada a

serviços, agentes inteligentes, redes neurais artificiais e sistemas tutores inteligentes. É

desenvolvedor Microsoft 3 Estrelas. Docente da Faculdade de Tecnologia de Jundiaí e

Bragança Paulista (FATEC), Faculdade Anhanguera de Jundiaí (FAJ), Sócio-Diretor da

TecnologiaEducacional.Com©.

Sobre a TecnologiaEducacional.Com©

A TecnologiaEducacional.Com© é uma empresa voltada ao desenvolvimento de

treinamentos especializados em tecnologia da informação. Com amplo conhecimento

sobre as novas tecnologias utilizadas na educação e capacitação profissional, a empresa

oferece soluções diferenciadas para capacitação nas diversas modalidades e metodologias

de ensino.

Para saber mais sobre a TecnologiaEducacional.Com© visite: www.tecnologiaeducacional.com

http://www.tecnologiaeducacional.com/

Fundamentos da Linguagem de Programação Java 1 Benedito C. A. Petroni / Cláudio L. V. Oliveira


Programação

Java

Breve História

A linguagem de programação Java foi criada pela Sun Microsystems. O objetivo

inicial do projeto era a criação de um software para produtos eletrônicos. Porém, as

linguagens de programação existentes até então não eram adequadas, pois os programas

escritos nestas linguagens têm de ser recompilados para cada microprocessador utilizado.

Quando um novo processador é lançado grande parte dos programas devem ser

recompilados para extrair o máximo de recursos deste novo processador.

Durante o ano de 1993 a World Wide Web estava passando de uma interface

totalmente baseada em textos para uma interface que buscava maior interação dos usuários

de sistemas de computadores; uma interface mais gráfica. A equipe de desenvolvimento

Java observou que a existência de uma linguagem independente de plataforma como a

Java seria ideal para a programação de aplicativos para a web, uma vez que uma aplicação

escrita em Java poderia rodar nas diferentes plataformas existentes nas Internet. O

resultado foi a criação de um navegador inicialmente chamado de WebRunner e depois

hoje HotJava, totalmente escrito em Java.

Quando um programa em Java é compilado gera-se byte-codes. Byte-codes são

similares a código de máquina, entretanto, não são específicos para um tipo particular de

arquitetura de computador, de forma que programas em Java podem ser executados em

arquiteturas distintas sem a necessidade de serem recompilados. No momento da execução

da aplicação os byte-codes são convertidos pela Java Virtual Machine (JVM) em código

de máquina.

Estruturalmente Java é considerada uma linguagem de alto nível, orientada a

objetos, sendo sua sintaxe muito similar ao C++, apresenta tipos de dados estáticos, é

compilada, independente de arquitetura e multithreaded.


Principais Características da Linguagem de Programação Java

A linguagem de programação Java atualmente é amplamente utilizada para o

desenvolvimento dos mais diversos tipos de aplicações e também para uma grande

variedade de plataformas. A seguir citamos algumas de suas principais características:

Orientação a Objetos: O código Java é organizado em classes. Cada classe define

um conjunto de métodos, e a partir destes métodos pode-se formar o comportamento de

um objeto. Uma classe pode herdar comportamentos de outra classe. Com exceção de

tipos simples, como números e variáveis booleanas, a maior parte das coisas em Java são

objetos.

Tipos de Dados Estáticos: Em um programa Java todo objeto dever ser definido

antes de utilizado.

Diversidade de Tipos de Aplicações: A linguagem Java permite a criação de

aplicações console (modo texto), gráficas (AWT e SWING), para a Internet (Applets,

Servlets e JSP Java Server Pages) e para dispositivos portáveis ou móveis (J2ME).

Independência de Arquitetura: Como já explicamos anteriormente os programas

Java são compilados em byte codes, desta forma os programas podem rodar em qualquer

plataforma que suporte Java, sem a necessidade de serem recompilados. A linguagem Java

é a mesma em qualquer computador. Por exemplo, tipos de dados simples não variam: um

inteiro tem sempre 32 bits e um inteiro longo tem sempre 64 bits.

Multithreaded: A maior parte dos sistemas operacionais modernos, como o Unix e

o Windows, suportam multitarefa. Um programa Java pode utilizar mais de uma thread de

execução.

Garbage Collector: Em Java não há a necessidade de se preocupar com o

gerenciamento de memória. O sistema em Java tem um programa embutido chamado de

garbage collector (coletor de lixo), que varre a memória e automaticamente libera

qualquer porção de memória que não esteja sendo utilizada.


Requisitos de Software e Hardware

Para a implementação de todos os exemplos dessa obra, o leitor deverá instalar a

versão atual do Java Development Kit (JDK), disponível em www.javasoft.com. Também

deverá realizar a instalação de uma Integrated Development Environment (IDE) podendo

ser NetBeans (www.netbeans.org) ou Eclipse (www.eclipse.org).

Ressalta-se que ambas as IDE´s e o JDK possuem versões para plataforma Windows

e Linux.

Convenções Adotadas nesta Obra

Visando facilitar a leitura e o entendimento dos conceitos apresentados, esta obra

adotou as seguintes convenções para as diferentes fontes utilizadas no texto:

Itálico: Enfatizar e destacar termos na língua inglesa;

Courier New: Realizar a indicação de palavras reservadas, referência às classes

da linguagem de programação Java ou desenvolvidas pelos próprios autores;

Courier New : Exibição do código-fonte dos programas.

http://www.javasoft.com/

http://www.netbeans.org/

http://www.eclipse.org/


Tipos de Dados

Uma variável, atributo ou até mesmo o valor de retorno de um método, deve ser

previamente declarado devendo apresentar um tipo de dados. Abaixo, na Tabela 1, são

apresentados os principais tipos de dados definidos pela linguagem Java:

Tabela 1. Principais tipos de dados na linguagem Java

Tipo de Dados Descrição Valores Padrão boolean Um bit com contendo valor

verdadeiro (true) ou falso

(false)

true ou false false

byte valor inteiro com sinal de 1

byte

-128 a 127 0

short valor inteiro com sinal de 2

bytes

-32.768 a 32.767 0

char caractere de 2 bytes 0 a 65.535 '\u0000' int valor inteiro com sinal de 4

bytes

-2.147.483.648 a

2.147.483.647

0

float valor numérico com

precisão decimal de 4 bytes

1.40129846432481707e-45 a

3.40282346638528860e+38

(positivo ou negativo)

0,0f

double valor numérico com

precisão decimal de 8 bytes

4.94065645841246544e-324 a

1.79769313486231570e+308

(positivo ou negativo)

0,0d

long valor inteiro com sinal de 8

bytes

-9.223.372.036.854.775.808 a

+9.223.372.036.854.775.807

0L

Desta forma, a declaração de uma variável deve apresentar o seu tipo de dados, o

nome que a variável terá e, opcionalmente, o seu valor inicial.

Por exemplo, para declararmos uma variável inteira que possua o nome “x” teremos

a seguinte sintaxe:

int x;

Caso seja necessário atribuir um valor inicial, podemos realizar a declaração da

seguinte maneira:

int x = 10;


Classes para Tipos de Dados

Além dos tipos de dados suportados pela linguagem, existem também classes que

permitem a implementação de objetos que representam tipos de dados.

A vantagem da utilização dessas classes consiste na possibilidade de utilizar

métodos que permitirão conversões, comparações e verificações aos valores armazenados

nos objetos.

Tabela 2. Principais classes para tipos de dados

Classe Objetivo String Cadeia de caracteres Integer Definir um objeto para o tipo inteiro Float Definir um objeto para o tipo de dados float Double Definir um objeto para o tipo de dados double Date Definir um objeto que permite armazenar data e/ou

hora

Por exemplo para declararmos um objeto que irá armazenar o nome de uma pessoa

devemos declará-lo da seguinte maneira:

String nome = "Maria";

Ou também poderia ser declarado assim:

String nome = new String ("Maria");


Orientação a Objetos – Parte 1: Introdução

“Objeto é uma bolha de inteligência que sabe agir

numa determinada situação”

Steve Jobs, fundador da Apple, Next e Pixar.

O paradigma de Orientação a Objeto trouxe uma nova forma de projetar e de

desenvolver programas de computadores. Enquanto que o projeto e a programação

estruturada focam a redução dos problemas computacionais a apenas três estruturas

básicas, que é seqüência, decisão e interação, e na qual, procedimentos, funções e

estruturas de dados apresentam ligações e relacionamentos tênues. Por outro lado, a

Orientação a Objeto estabelece um forte relacionamento entre os diversos componentes de

um determinado problema computacional através da adoção de dois conceitos chave:

classe e objeto.

Na programação orientada a objetos implementa-se um conjunto de classes que

permitem a definição dos objetos presentes no projeto do sistema.

Cada classe tem por objetivo determinar o comportamento, que são definidos pelos

métodos, e estados possíveis, descritos pelos atributos que compõem e caracterizam os

objetos, além de permitir a definição do relacionamento com outros objetos.

Conforme mencionado acima, a orientação a objeto, pode ser entendida através da

definição de dois dos elementos chave:

O primeiro é o conceito de classe, que pode ser entendido como a descrição

de um ou mais objetos através de um conjunto uniforme de atributos e

métodos;

O segundo conceito é o do próprio objeto, que pode ser definido como uma

abstração de algo que existe dentro do domínio de um problema ou na sua

implementação, sendo que todo objeto é a instância de uma classe. Ilustrando

estes conceitos, considere uma determinada classe chamada pessoa, os objetos

dessa classe são os indivíduos que a compõem, por exemplo, José e Maria

entre outros.


Em síntese:

Classe: determina o comportamento dos objetos, que são definidos pelos métodos, e

estados possíveis, descritos pelos atributos que compõem e caracterizam esses

objetos;

Objetos: pode ser entendido como uma abstração de algo que existe dentro do

domínio de um problema ou na sua implementação, sendo que todo objeto é a

instância de uma classe.

Para um perfeito entendimento da orientação a objeto torna-se necessário definir os

demais conceitos que a compõem:

Atributo: define um conjunto padrão de características específicas para uma

determinada classe. Os valores (estados) que estes atributos recebem, quando a classe é

instanciada, permitem caracterizar um objeto. Considerando uma determinada classe

pessoa, os atributos poderiam ser nome, endereço e telefone entre outros.

Método: solicitação a um objeto invocando um de seus métodos, método este que

ativa um determinado comportamento descrito pela classe que deu origem ao objeto em

questão. Usando como exemplo a classe pessoa, poderíamos definir métodos para alterar o

nome, o endereço ou o telefone de determinado indivíduo.

Método Construtor: é um método especial, que deve apresentar o mesmo nome da

classe, sendo executado somente no momento em que o objeto é criado, ou seja, quando

uma classe é instanciada.

A partir dos conceitos de classes, atributos e métodos é possível realizar a definição

de uma classe utilizando, para isso, a sintaxe da linguagem Java:

public class Pessoa

{ private String nome;

private String endereco;

private String telefone;

public Pessoa()

{

}

public Pessoa(String _nome, String _endereco,

String _telefone)

{ nome = _nome;

endereco = _endereco;

telefone = _telefone;

}


public void DefinirNome(String _nome)

{ nome = _nome;

}

public String ObterNome()

{ return (nome);

}

// Demais métodos ...

}

Palavra-reservada this: é utilizada para referenciar um atributo ou método da

própria classe evitando ambiguidade em relação aos parâmetros ou variáveis declaradas

dentro de um método da classe. Por exemplo, o construtor da classe Pessoa pode utilizar

this para diferenciar os atributos dos parâmetros:

public Pessoa(String nome, String endereco,

String telefone)

{ this.nome = nome;

this.endereco = endereco;

this.telefone = telefone;

}

Ou seja, this.nome faz a referência ao atributo nome enquanto nome identifica o

parâmetro que foi passado no método construtor.

Polimorfismo: permite que um determinado método declarado em uma classe

funcione de maneira diferente de acordo com o contexto no qual o objeto está inserido.

Abstração é a capacidade de permitir a concentração apenas nos aspectos essenciais

de um contexto, mascarando as características menos importantes. Na modelagem

orientada a objetos, uma classe pode ser entendida como uma abstração das entidades

existentes no domínio da aplicação.


Encapsulamento: consiste na separação de características internas e externas de um

determinado objeto. Este recurso é comumente utilizado para evitar o acesso direto aos

atributos desse objeto, permitindo desta forma que apenas os métodos consigam alterar

esses atributos.

O conceito de encapsulamento é implementado através da definição da

“visibilidade” de atributos e métodos através das palavras-reservadas public, private

ou protected.

Getters e Setters: dentro do conceito de encapsulamento é comum definirmos os

atributos como privados, desta forma, para os atributos que precisam receber valores

provenientes de fora da classe é necessário implementar um método de atribuição,

normalmente conhecido como Setter. Por outro lado, atributos que precisam ter o seu

conteúdo consultado por outras classes deverão implementar um método Getter.

Adotando estes conceitos, e considerando que o conteúdo dos atributos nome,

endereço e telefone precisam ser acessados por outras classes, a classe Pessoa poderia ser

escrita da seguinte forma:

public class Pessoa




public Pessoa()

{

}

public Pessoa(String nome, String endereco,

String telefone)

{ this.nome = nome;

this.endereco = endereco;

this.telefone = telefone;

}

public void SetNome(String nome)

{ this.nome = nome;

}

public String GetNome()

{ return (nome);

}


}


Método toString(): esse método é bastante utilizado em programação, sua

principal função é o retorno de uma determinada String. Um detalhe é que String é

uma classe e caso seja necessário receber informações desta classe, esse método permite o

retorno das informações dela mesma.

Seguindo o raciocínio deste método, pode-se observar o exemplo a seguir

considerando que o conteúdo da classe Veículo seja acessado o endereço de memória do

objeto.

public class Veiculo{

private String marca;

private String modelo;

public String toString(){

return marca+" "+modelo;

}


}

Associação: pode ser entendido como um recurso através do qual um objeto

consegue utilizar componentes de um outro objeto. Por exemplo, um usuário de

computador (objeto), ao realizar a digitação em um teclado (outro objeto), pressiona as

teclas, que são uma parte do objeto teclado.

Instâncias: Como abordado anteriormente, uma classe define o comportamento de

um objeto através dos métodos e atributos. Porém, a mesma não realiza o armazenamento

dos atributos e a execução dos métodos. Desta forma, torna-se necessário a criação de

objetos a partir da classe definida, ou seja, os objetos podem ser entendidos como

instâncias de uma determinada classe.


Pessoa pessoa = new Pessoa();

Ou

Pessoa pessoa = new Pessoa(“José”, “Rua das Flores, 100”,

“11-4524-7445”);

É importante observar nos exemplos acima que os métodos construtores definem o

modo como o objeto será instanciado, ou seja, como o objeto será criado.

Exercícios

1) Considerando o funcionamento de uma lâmpada, projetar uma classe que represente os

estados possíveis e respectivos métodos.

2) Uma determinada loja precisa armazenar as seguintes características de seus produtos:

código, descrição e preço. Especificar uma classe, com atributos e métodos, que permita

realizar essa representação.

3) Uma empresa seguradora necessita descrever as seguintes informações dos veículos

segurados: número do chassi, número da placa, fabricante, modelo, ano de fabricação e

cor. Especificar uma classe, com atributos e métodos, que permita caracterizar essa

necessidade.

4) Considerando um DVD especificar uma classe que permita representá-lo.

5) Representar uma classe chamada matemática que permita realizar uma das quatro

operações básicas sobre dois números de ponto flutuante retornando, em seguida, o

resultado.


Estrutura Básica de Aplicação em Java

A primeira aplicação que criaremos será do tipo console, que consiste no tipo de

aplicação mais simples, pois não envolve a adoção de conceitos de aplicações gráficas ou

para a Internet.

Neste exemplo é importante observar, inicialmente, a definição da classe

OlaPessoal e do método main.

O método println, disponível no pacote padrão System.out, deverá ser

utilizado para realizar a exibição de um conteúdo na saída padrão do console.

public class OlaPessoal

{ public static void main(String[] args)

{ System.out.println("Olá pessoal!");

}

}

É importante observar que, devido a linguagem Java ser orientada a objetos, a

mesma é composta por classes que, por sua vez, são compostas por atributos e métodos.

Independente do número de classes que uma aplicação possa implementar, um programa

em Java terá início sempre a partir da classe que possui um método especial chamado

main.

Após a compilação ao executarmos a aplicação, a mensagem “Olá pessoal!” será

exibida na tela.

A Figura 1 a seguir, mostra a execução de um programa no NetBeans IDE, para

obter maiores informações sobre como compilar e executar aplicações em Java consulte os

Apêndices A e B que irão abordar, respectivamente as IDE's NetBeans1 e Eclipse

2.

1 Disponível em www.netbeans.org

2 Disponível em www.eclipse.org




Figura 1: Interface da IDE Netbeans

Entrada de Dados

No exemplo a seguir será mostrado como se efetua uma entrada de dados, ou seja,

permitir que o usuário da aplicação realize a digitação dos dados através do teclado.

import java.io.*;

public class EntradaDados

{ public static void main(String[] args) throws IOException

{ String nome;

BufferedReader teclado = new BufferedReader(

new InputStreamReader(System.in));

System.out.println("Digite o seu nome:");

nome = teclado.readLine();

System.out.println("Olá, " + nome + ".");

}

}

Inicialmente deve-se realizar a importação do pacote java.io, pois, ele contém as

classes necessárias que permitirão a entrada de dados através do teclado.

A utilização dessas classes requer que o tratamento de exceções seja habilitado,

neste exemplo, isso será realizado através da palavra reservada throws. Futuramente

iremos abordar de forma mais detalhada as possibilidades de tratamento de erros que são

oferecidos pela linguagem.


O próximo passo consiste em criar um objeto pertencente a classe

BufferedReader, o qual permitirá receber os dados da System.in que representa o

acesso ao dispositivo de hardware teclado. Concluindo este exemplo, o método

readLine() obtém o conteúdo digitado até que o usuário pressione a tecla Enter.

É importante salientar que toda entrada de dados é recebida pela linguagem como

um objeto pertencente a classe String sendo que, quando necessário, devemos realizar a

conversão para o tipo de dados desejado.

Uma outra possibilidade, que permite simplificar o processo de entrada dos dados, é

a utilização da classe Scanner, por exemplo:

import java.io.*;

public class CalculoIdade


{ Scanner teclado = new Scanner(System.in);

System.out.print("Digite o seu nome: ");

String nome = teclado.nextLine();

System.out.print("Digite o seu ano de nascimento: ");

int anoNascimento = teclado.nextInt();

int idade = 2010 – anoNascimento;

System.out.println("Olá, " + nome +

" você possui " + idade + " anos.");

}

}

Conversões entre Tipos de Dados

Quando utilizamos métodos para obter seqüências através da digitação do usuário

tanto em modo console, quanto em interfaces gráficas e aplicações para a web, deparamos

com a característica de realizar o recebimento dessas seqüências apenas através de cadeias

de caracteres (Classe String).

Porém, em muitos casos, torna-se necessário a utilização desses valores de entrada

como tipos de dados numéricos. Neste cenário é de fundamental necessidade a realização

de conversões entre os tipos de dados.

O exemplo a seguir mostra como realizar a conversão de um objeto pertencente a

classe String para uma variável inteira:

String entrada = “12”;


int saida = new Integer(entrada).intValue();

A conversão é realizada em dois passos:

Primeiro é criado um objeto a partir da classe Integer recebendo, como

parâmetro, o objeto da classe String;

Segundo, o método intValue() é usado para retornar um valor do tipo de

dados inteiro para a variável saída.

Neste próximo exemplo iremos utilizar os conceitos de entrada de dados e também

de conversões entre tipos de dados para criar uma pequena aplicação que receba, através

de digitação, dois números inteiros e, em seguida, faça a exibição a soma dos mesmos.

import java.io.*;

public class Soma

{ public static void main(String[] args) throws IOException

{ int num1, num2, soma;

BufferedReader teclado = new BufferedReader(

new InputStreamReader(System.in));

System.out.println("Digite um número:");

num1 = new Integer(teclado.readLine()).intValue();

System.out.println("Digite outro número:");

num2 = new Integer(teclado.readLine()).intValue();

soma = num1 + num2;

System.out.println("Soma = " + soma);

}

}

Exercícios

1) Criar uma aplicação Java que receba por digitação o nome e o sobrenome e, em

seguida, realize a exibição da seguinte maneira: sobrenome, nome.

2) Elaborar um programa que realize a multiplicação de dois valores numéricos do tipo de

dados float digitados pelo usuário e, depois, exiba o valor da multiplicação dos

mesmos.

3) Escrever uma aplicação que receba quatro números inteiros digitados pelo usuário e, em

seguida, calcule e exiba a valor da soma desses números.


4) Criar uma aplicação que receba três números double digitados pelo usuário e, em

seguida, calcule e exiba a valor da média.

5) Uma determinada loja precisa calcular o preço de venda de um produto. O cálculo

deverá ser efetuado através da multiplicação do preço unitário pela quantidade vendida e,

posteriormente, subtrair o valor do desconto. Considerar todos os campos do tipo de dados

float e que os mesmos serão digitados pelo usuário.

6) Calcular a média final de um aluno considerando que o mesmo irá realizar duas provas

(P1 e P2), sendo que a P1 deverá ter peso 4 e a P2 peso 6. Adotar que as notas são do tipo

de dados double e que elas serão fornecidas pelo usuário.

7) Uma loja precisa armazenar as seguintes características de seus produtos: código,

descrição e preço. Especificar uma classe, com atributos e métodos, que permita realizar

essa representação. Em seguida, criar um programa que instancie um objeto desta classe e

permita que os valores dos atributos sejam digitados pelo usuário.

8) Considerando a classe produto desenvolvida no exercício anterior criar um método que

retorne o preço a vista do produto, sendo que este preço deverá ser calculado como 90%

do valor do atributo preço.


Vetores e Matrizes

Vetores e matrizes, devem ser compostos apenas por elementos de um mesmo tipo

de dados e devem ser declarados da mesma maneira como se cria a maioria dos objetos:

int i[] = new int[5];

Neste exemplo criamos um vetor de inteiros que poderá receber cinco elementos.

Em vetores e matrizes o primeiro elemento é acessado com o índice recebendo o valor 0

(zero). Para acessar um elemento dentro de um vetor devemos referenciar entre colchetes o

índice da posição desejada, por exemplo:

i[0] = 45;

Os elementos de um vetor podem ser inseridos no momento da criação do mesmo

conforme mostrado abaixo:

int i[] = {64, 87, 32, 07, 86};

Quando mostramos os tipos de dados básicos você de ter observado que existe o

tipo char que pode conter um caractere. Desta forma poderíamos definir um vetor de char

para poder armazenar cadeias de caracter da seguinte forma:

char linguagem[] = { 'J', 'a', 'v', 'a' };

Porém, para facilitar a vida dos programadores em Java, a linguagem nos oferece

uma classe projetada especificamente para manusear as cadeias de caracteres: a classe

String. Utilizando esta classe a definição da variável nome poderia ser realizada assim:

String linguagem = new String(“Java”);

A vantagem de se utilizar a classe String está no fato de que a mesma já possui

vários métodos para manipular os objetos criados. Abaixo estão descritos os métodos de

maior utilidade são:

charAt(int indice) - retorna o caracter que está na posição índice;

equals(Object objeto) - retorna true se o objeto String for igual a

objeto;

length() - retorna o tamanho do objeto;

substring(int inicio, int fim) - retorna o objeto com os caracteres

entre inicio e fim;

toLowerCase() - retorna a cadeia de caracteres convertida para minúsculas;


toUpperCase() - retorna a cadeia de caracteres convertida para maiúsculas.

Instruções de Controle

As estruturas de controle, presentes na quase totalidade das linguagens de

programação, permitem determinar a execução ou não de determinado bloco de código,

também são responsáveis pela possibilidade de repetição de um bloco de código.

A estrutura if-else realiza a avaliação da expressão lógica fornecida em condicao,

caso a mesma seja verdadeira o bloco de código associado a instrução if é executado,

caso contrário, o bloco associado à instrução else, que é opcional, será executado.

Também é possível realizar o encadeamento de instruções dando origem a uma estrutura

do tipo if-elseif-else, conforme pode ser observado no quadro abaixo.

if (condicao)

{ comando;

...

}

else if (condicao-1)

{ comando;

...

}

else

{ comando;

...

}

Essa estrutura if-else é utilizada para realizar a execução condicional de um

determinado bloco de código, no exemplo abaixo será utilizada para determinar se um

número é maior que zero. Observe que a instrução else é opcional e, para este caso, não

foi utilizada.

int n = 5;

if (n > 0)

{ System.out.println(“O número é maior que zero”);

}

A estrutura de controle switch pode ser usada como alternativa ao if-else em

situações onde em todas as expressões lógicas realizam sempre o teste de uma mesma

variável. A estrutura funciona através da verificação de uma variavel, caso ela seja igual a

valor-1 então o respectivo bloco de comando é executado até que se encontre a instrução

break, caso contrário verifica-se variavel em relação a valor-2 e assim sucessivamente.


Se todas as condições forem falsas o bloco que contém a instrução default será

executado.

switch (variavel)

{ case valor-1:

comando;

...

break;

case valor-2:

comando;

...

break;

default:

comando;

...

break;

}

Para ilustrar esse conceito, imagine uma situação hipotética em que você precisa

escrever uma aplicação que escreva o valor por extenso dos número inteiros 1, 2 e 3.

Inicialmente, para fins de comparação, vamos realizar a implementação através do uso de

if-else encadeados:

int n = 2;

if (n == 1)

System.out.println(“Um”);

else if (n == 2)

System.out.println(“Dois”);

else if (n == 3)

System.out.println(“Três”);

else

System.out.println(“Não sei!”);

Observe que, neste caso, adotando-se como referência o valor 2 atribuído a variável

n, a primeira verificação (n == 1) será falsa, provocando a execução a cláusula else que

inicia-se com a instrução if testando se n == 2. Agora o resultado da avaliação da

expressão será verdadeiro e o comando System.out.println(“Dois”) será

executado. Sendo esta condição verdadeira os demais testes não são realizados pois estão

associados ao else.

A seguir iremos implementar este mesmo exemplo utilizando a estrutura switch.

A estrutura recebe como parâmetro a variável n, ou seja, a variável que deseja-se testar.

Em seguida, cada cláusula case indica o valor necessário para que o respectivo bloco de

comandos seja executado.


Um bloco de comando deve, obrigatoriamente, ser finalizado com a instrução

break, a qual provoca o término da estrutura switch. Neste exemplo, a instrução case

1 será falsa e o bloco não é executado. Em seguida, case 2 resulta em verdadeiro, a

mensagem será exibida e ao encontrar o comando break a estrutura é finalizada, ou seja,

case 3 não será verificado e o bloco default não será executado.

int n = 2;

switch (n)

{ case 1:

System.out.println(“Um”);

break;

case 2:

System.out.println(“Dois”);

break;

case 3:

System.out.println(“Três”);

break;

default:

System.out.println(“Não sei!”);

}

A estrutura while possibilita realizar a repetição de um bloco de comandos até que

a expressão lógica fornecida em condicao seja avaliada como falsa, neste momento o

while é encerrado e a execução do programa prossegue na linha de código

imediatamente posterior ao comando.

while (condicao)

{ comando;

...

}

Como exemplo de utilização da estrutura while iremos mostrar um fragmento de

programa que permite a exibição dos números inteiros entre 1 e 10:

int i = 1;

while (i <= 10)

{ System.out.println(i);

i++;

}

i = 1;

Observe que o bloco de comandos irá se repetir enquanto a variável i for menor ou

igual a 10. Quando i atingir o valor 11 a condição torna-se falsa, ou seja, a repetição é


encerrada e o valor da variável será ajustado novamente para 1, pois, trata-se da instrução

que está imediatamente após o bloco de comandos relativo à estrutura while.

A estrutura de controle do-while tem funcionamento similar ao while, porém

apresenta uma diferença fundamental: enquanto no while primeiro realiza-se a

verificação da expressão lógica e depois a execução do bloco de comandos; na estrutura

do-while ocorre o contrário, inicialmente é realizada a execução do bloco de comando e

depois é realizada a verificação da expressão lógica.

Desta forma, o bloco de comando sempre é executado pelo menos uma vez,

independente de condicao ser verdadeira ou falsa.

do

{ comando;

...

} while (condicao);

Observe que, neste caso, primeiro será exibido o valor da variável i, depois realiza-

se o seu incremento. Em seguida, a condição é verificada e, neste exemplo, será

considerada falsa, encerrando a estrutura do-while.

int i = 11;

do


i++;

}

while (i <= 10);

A estrutura de repetição for apresenta como características particulares a

possibilidade de realizar tarefas de inicialização e pós-execução no próprio corpo da

instrução, permitindo um código mais conciso e com maior facilidade de entendimento.

for (instrucao-1; condicao; instrucao-2)

{ comando;

...

}

O comando tem início com execução de instrucao-1, em seguida realiza-se a

avaliação da expressão lógica condicao, caso a mesma seja verdadeira o bloco de

comandos é executado, caso contrário a estrutura será encerrada e a execução do programa

irá prosseguir na instrução imediatamente posterior a estrutura for.

Após a execução do bloco de comandos executa-se instrucao-2 e, em seguida, a

expressão lógica é novamente verificada.


for (int i = 1; i <= 10; i++)


}

No exemplo apresentado anteriormente, é possível verificar que o mesmo irá

realizar a exibição dos números inteiros entre 1 e 10. Note que, quando comparado com o

mesmo exemplo que utilizou a estrutura de controle while, a implementação com for é

bem mais concisa.

Exercícios

1) Criar um programa que receba três números inteiros e exiba o maior deles.

2) Especificar uma aplicação que faça a leitura do nome e ano de nascimento de uma

pessoa e exiba a idade da mesma.

3) Escreva um programa que realize a exibição dos números inteiros pares entre 0 e 100.

4) Escreva um programa que realize a exibição, em ordem decrescente, dos números

inteiros entre 0 e 200 e que também sejam múltiplos de 5.

5) Criar um programa em Java que permita ao usuário digitar dois números float e uma

das quatro operações matemáticas básicas e, em seguida, exiba o resultado do cálculo

efetuado. A aplicação também não poderá permitir a tentativa de divisão de um número

por zero.

6) Dada uma seqüência de 10 números inteiros, realizar a exibição na ordem inversa à da

leitura.

7) Dado um vetor com 5 números inteiros, exibir a média.

8) Um dado de jogo foi lançado 20 vezes. A partir dos resultados dos lançamentos,

devidamente armazenados em um vetor, mostrar o número de ocorrências de cada face.

9) Considerando uma moeda lançada 10 vezes, criar uma aplicação em Java para

determinar o número de ocorrências de cada um dos lados.

10) A partir de um determinado vetor v contendo 5 números inteiros, escrever um

programa em Java que imprima soma dos elementos do vetor. Por exemplo, para o vetor v

= {5, 10, 5, 10, 5} o programa deverá imprimir 35.


11) Considerando um vetor do tipo float com tamanho 5, escrever um programa que,

após percorrer todo o vetor, identifique a diferença entre o maior e o menor elemento. Por

exemplo, para um determinado vetor v = {6.5, 4.2, 7.7, 4.1, 2.2}, o programa deverá

mostrar que 7.7 – 2.2 = 5.5.

12) Elabore um programa em Java que, dado um determinado vetor A contendo 10

números inteiros, obtenha a maior diferença entre dois elementos consecutivos deste vetor.

13) Em uma sala de aula há 10 alunos, cada um dos quais realizou 3 provas com pesos

distintos. Sendo que a primeira prova possui peso 3, a segunda possui peso 4 e a terceira

peso 3. Criar uma aplicação em Java que permita o lançamento das notas das três provas

de cada aluno e, em seguida, calcule a média ponderada das provas, exibindo a média para

cada um dos alunos.

14) Tomando como referência uma aplicação em modo console, implementar uma classe

chamada Teclado e que contenha os métodos necessários para realizar a leitura de valores

do tipo de dados String, inteiro e float.


Orientação a Objetos – Parte 2: Herança

O conceito de herança pode ser entendido como o recurso pelo qual uma

determinada classe, denominada sub-classe ou classe filha, pode receber atributos e

métodos presentes em outra classe, neste caso chamada de super-classe ou classe pai.

Uma das características fundamentais da orientação a objetos é a capacidade de

reaproveitamento de código, a qual pode ser implementada através da adoção do conceito

de herança. O exemplo discutido a seguir mostra uma possibilidade de aplicação do

conceito de herança.

Considerar como cenário uma loja, que mantém um registro de todos os produtos

que são vendidos. Estes produtos possuem alguns atributos em comum como, por

exemplo, código, descrição e preço. Porém, alguns produtos possuem algumas

informações específicas:

CD: duração e número de faixas;

DVD: duração, região, idioma e legenda;

Eletrônicos: tensão de operação e garantia;

Livros: autor, número de páginas e idioma.

A primeira etapa consiste na definição da classe Produto, sendo que é importante

observar que os atributos deverão ser declarados como protected para que possam ser

acessados pelas classes filhas:

public class Produto

{ protected int codigo;

protected String descricao;

protected float preco;

public Produto()

{

}

public Produto(int _codigo, String _descricao,

float _preco)

{ codigo = _codigo;

descricao = _descricao;

preco = _preco;

}

public void DefinirCodigo(int _codigo)

{ codigo = _codigo;

}


public int ObterCodigo()

{ return (codigo);

}


}

Agora, como exemplo, criaremos a classe Eletrônico a qual, a partir do

mecanismo de herança, receberá todos os atributos da classe Produto sendo necessário,

desta forma, apenas a definição dos atributos e métodos específicos:

public class Eletronico extends Produto

{ private int tensao;

private String garantia;

public Eletronico()

{

}

public Eletronico(int _codigo, String _descricao,

float _preco, int _tensao, String _garantia)

{ codigo = _codigo;

descricao = _descricao;

preco = _preco;

tensao = _tensao;

garantia = _garantia;

}

public void DefinirTensao(int _tensao)

{ tensao = _tensao;

}

public int ObterTensao()

{ return (tensao);

}


}

Como pode-se observar no código acima, no construtor da classe Eletrônico,

iniciou os atributos da classe pai (Produto) juntamente com os da própria classe filha.


A linguagem Java oferece a palavra reservada super que permite realizar

diretamente a chamada a um método da classe pai. Desta forma, o construtor da classe

Eletrônico poderia ser escrito da seguinte maneira:

public Eletronico(int _codigo, String _descricao,

float _preco, int _tensao, String _garantia)

{ super(_codigo, _descricao, _preco);

tensao = _tensao;

garantia = _garantia;

}

Note que os parâmetros _codigo, _descricao e _preco são passados

diretamente para o método construtor da classe Produto através da palavra reservada

super.

Também é importante salientar que este procedimento pode ser adotado para

executar qualquer método da classe pai dentro da classe filha.

O último passo na elaboração deste exemplo consiste em criar uma nova classe que

irá utilizar a classe Eletrônico.

Neste caso, é necessário apenas a instanciação de um objeto da classe

Eletrônico, observe que os métodos da classe Produto estarão disponíveis graças ao

mecanismo de herança:

public static void main(String[] args)

{ Eletronico eletronico = new Eletronico();

System.out.println(" Código:");

eletronico.DefinirCodigo(Teclado.LerInteiro());

System.out.println("Descrição:");

eletronico.DefinirDescricao(Teclado.LerString());

System.out.println(" Preço:");

eletronico.DefinirPreco(Teclado.LerFloat());

System.out.println(" Tensão:");

eletronico.DefinirTensao(Teclado.LerInteiro());

System.out.println(" Garantia:");

eletronico.DefinirGarantia(Teclado.LerString());

System.out.println("O produto " +

eletronico.ObterDescricao() + " custa " +

eletronico.ObterPreco() + " e possui garantia de " +

eletronico.ObterGarantia() + ".");

}


Exercícios

1) Implementar as demais classes descritas no cenário proposto: CD, DVD e Livro.

2) Uma empresa de aluguel de veículos mantém um banco de dados para todos os veículos

de sua frota. Para todos os veículos, são armazenados o número do chassi, o número da

placa, o fabricante, o modelo, o ano de fabricação e a cor. Algumas informações são

incluídas para determinados tipos de veículos: - caminhões: capacidade de carga, número

de eixos; - carros esportes: potência, capacidade de aceleração; ônibus: quantidade de

passageiros, número de eixos; - off road: altura em relação ao solo, tipo de tração. Realizar

a definição e implementação das classes, com respectivos atributos e métodos, com base

no exposto acima.

3) Considerando os diversos tipos de pessoas que trabalham em uma empresa definir um

conjunto de classes, utilizando o mecanismo de herança, que caracterize os seguintes tipos

de funcionários: a) Todos os funcionários possuem atributos de número de registro, nome,

função, salário e situação; b) Funcionários efetivos possuem atributos de data de admissão

e demissão; c) Os funcionários temporários possuem data de início do contrato e a duração

em meses do mesmo; d) Enquanto que os funcionários terceirizados apresentam data de

início, duração do contrato e o nome da empresa prestadora de serviços.


Orientação a Objetos – Parte 3: Interfaces e Implementações

Em sistemas de computação, o conceito de interface pode ser aplicado de várias

formas. Por exemplo, uma interface com o usuário é a camada de um sistema que tem

como finalidade permitir e facilitar a interação entre o usuário e os diversos processos da

aplicação.

O conceito de interface de programação ou API (Applications Programming

Interface) refere-se a um conjunto de funções que podem ser evocadas por programas

aplicativos para utilizar os serviços oferecidos pelo Sistema Operacional. A utilização de

interfaces bem definidas permite um alto grau de interoperabilidade entre os diversos

componentes de um sistema.

O conceito de interfaces na orientação a objetos é utilizada para definir um tipo

abstrato de dados que descreve o comportamento que é visível externamente de uma

classe, objeto ou qualquer outra entidade.

No caso de uma classe ou objeto, a interface inclui um conjunto de operações e suas

respectivas assinaturas de métodos. Deste modo, é possível conceituar interface como a

especificação de um tipo, que é formado por um nome e um conjunto de métodos, os quais

não podem conter nenhuma implementação.

Normalmente, os nomes de interfaces são criados da mesma maneira que os nomes

de classes, ou seja, utilizando-se substantivos simples ou adjetivados, no singular, com

cada palavra que compõe o nome da interface iniciando com letra maiúscula.

Uma característica essencial da utilização das interfaces em Java é a ausência de

implementação, tanto em relação aos métodos quanto as estruturas de dados, sendo que a

única exceção admitida é a definição de constantes. Todas as operações de uma interface

são públicas, não sendo exigido o modificador public nas assinaturas dos métodos.

A seguir é mostrado um exemplo de interface:

public interface iPessoa

{ public void atribuirNome(String nome);

public String obterNome();

public void atribuirEndereco(String endereco);

public String obterEndereco();

public void atribuirTelefone(String telefone);

public String obterTelefone();

}


A implementação de um tipo especificado por uma interface deve sempre ser

realizada através da definição de uma classe. Sendo que uma classe pode implementar um

número qualquer de interfaces, é possível afirmar que a linguagem Java possui suporte

para o conceito de herança múltipla de interfaces.

Por outro lado, diferentes classes podem realizar a implementação de maneiras

diferentes de uma mesma interface através de construções distintas para os métodos

definidos na interface. A função principal de uma interface é possibilitar a separação, de

forma explícita, das definições dos tipos abstratos de dados ocorridos dentro das suas

possíveis implementações.

No exemplo a seguir é mostrado como realizar uma das possíveis implementações

para a interface Pessoa definida anteriormente, sendo importante observar que, neste

momento, o funcionamento de cada método é explicitado.

public class Pessoa implements iPessoa




public Pessoa()

{ nome = new String("");

endereco = new String("");

telefone = new String("");

}

public String obterNome()

{ return (nome);

}

public void atribuirNome(String _nome)

{ nome = _nome;

}

public String obterEndereco()

{ return (endereco);

}

public void atribuirEndereco(String _endereco)

{ endereco = _endereco;

}

public String obterTelefone()

{ return (telefone);

}

public void atribuirTelefone(String _telefone)

{ telefone = _telefone;

}

}


Desta forma, a implementação consiste na definição das operações especificadas

pelas interfaces, através de métodos que devem obrigatoriamente apresentar as mesmas

assinaturas definidas pela respectiva interface.

Quando uma classe não implementa alguma das operações definidas pela sua

interface, o método correspondente fica implicitamente definido como abstrato e,

conseqüentemente, a classe também se torna abstrata, mesmo que o modificador

abstract não esteja presente na definição da classe.


Coleções de Objetos

No mundo real, freqüentemente torna-se necessário representar e agrupar vários

objetos. Por exemplo, os clientes de uma determinada loja são muitos e não apenas um.

Neste contexto, uma coleção pode ser entendida como um conjunto composto por vários

objetos do tipo cliente, que compartilham o mesmo conjunto de atributos, porém, estes

atributos apresentam estados diferentes.

Além do conceito de vetores e matrizes, na linguagem Java existem várias interfaces

e classes que implementam o conceito de coleções, como as classes Vector, List,

HashSet, HashMap e Hashtable entre outras.

Da mesma maneira que é possível realizar a criação de vetores a partir dos tipos de

dados suportados pela linguagem Java, também pode-se criar vetores a partir de classes.

Neste exemplo será utilizada a classe Pessoa que apresenta nome, endereço e telefone

como atributos, observe que a instanciação da classe irá ocorrer sobre um objeto do tipo

vetor, sendo que cada elemento do vetor deverá ser instanciado antes de ser utilizado:

public static void main(String[] args)

{ Pessoa pessoa[] = new Pessoa[3];

System.out.println("Digite o nome de três pessoas:");

for (int i = 0; i < 3; i++)

{ pessoa[i] = new Pessoa();

System.out.println("Nome N° " + (i + 1) + ":");

pessoa[i].DefinirNome(Teclado.LerString());

}

System.out.println("Nome das pessoas cadastradas:");

for (int i = 0; i < 3; i++)

{ System.out.println(pessoa[i].ObterNome());

}

}

Toda coleção apresenta o atributo length que mostra a quantidade de itens

existentes na coleção, desta forma, as estruturas de repetição utilizadas no exemplo

poderiam ser escritas do seguinte modo:

for (int i = 0; i < pessoa.length; i++)

A utilização do atributo length para determinar o tamanho da coleção favorece a

manutenção do programa pois, no primeiro exemplo, se fosse necessário alterar o tamanho

da coleção, três linhas deveriam ser alteradas: a declaração do vetor e a condição nas duas

instruções for. Com a adoção do atributo length torna-se necessário a alteração apenas

da declaração do tamanho do vetor, ou seja, uma única linha.


Exercícios

1) Alterar o exemplo mostrado acima acrescentando a leitura e exibição do endereço e

telefone das pessoas.

2) Criar uma coleção para representar 5 objetos do tipo veículo e que possuem como

atributos privados: chassis, placa, modelo, cor e ano de fabricação.

3) Desenvolver uma aplicação que permita representar 10 objetos do tipo produto e que

tem os seguintes atributos privados: código, descrição e preço.


List e ArrayList

Os vetores e matrizes são estruturas de alocação estática, ou seja, no momento de

sua declaração é necessário realizarmos a especificação do seu tamanho.

Porém, quando construímos aplicações, em várias situações não é possível precisar

previamente o número de elementos, desta forma, a linguagem Java implementa classes

que permitem a alocação dinâmica de dados.

Nas estruturas com alocação dinâmica, como o próprio nome diz, é possível realizar

o dimensionamento de forma automática, a qualquer momento, durante a execução do

programa, através da inserção ou remoção dos itens da estrutura.

A interface List, disponível no pacote java.util, é uma das classes da

linguagem Java que implementa esse conceito, podendo armazenar tanto tipos de

primitivos como objetos. A seguir é mostrado um pequeno exemplo abordando os

conceitos básicos de utilização de listas:

import java.util.*;

public class Listas


{ List lista = new ArrayList();

lista.add("João");

lista.add("Maria");

lista.add("José");

System.out.println("Tamanho atual da lista: " +

lista.size());

lista.remove("Maria");

System.out.println("Novo tamanho da lista: " +

lista.size());

System.out.println("Elementos da lista:");

Iterator item = lista.iterator();

while (item.hasNext())

{ System.out.println(item.next());

}

}

}

O primeiro passo para o desenvolvimento do exemplo consiste em criar o objeto

lista que irá conter um conjunto de valores, neste exemplo, alguns nomes de pessoas.


É importante observar que o objeto é instanciado através de um ArrayList que é

a implementação com alocação dinâmica da interface List. O método add permite

adicionar um novo elemento a lista, enquanto o método remove realiza a exclusão.

É possível a qualquer momento consultar o número de itens que compõem a lista

através da utilização do método size. Para percorrer os elementos existentes na lista

devemos utilizar a interface Iterator, que consiste em uma forma de acessar

seqüencialmente os elementos de uma coleção sem, com isso, expor a forma de sua

representação interna.

Ao utilizarmos um Iterator devemos empregar o método hasNext() para

verificar se existem elementos a serem recuperados, enquanto o método next() irá obter

o elemento.

HashMap

Neste exemplo serão abordadas as classes HashMap, pois a mesma permite uma

recuperação mais rápida dos dados através da utilização do conceito de chave de pesquisa

e, posteriormente, a classe HashSet.

Uma tabela hash pode ser definida como uma estrutura de dados que permite

associar uma chave a um valor e, posteriormente, ter acesso ao valor a partir da chave que

foi associada. Seu principal objetivo consiste, a partir da utilização de uma chave, realizar

uma busca e recuperar o valor desejado. Em Java, essa estrutura de dados encontra-se

implementada através das classes HashMap e Hashtable.

Essas classes são bastante úteis quando a ordem dos objetos não interessa muito e é

necessário adicionar, recuperar ou excluir os valores.

De modo geral, essas classes são equivalentes, exceto que a HashMap possui uma

especificação mais recente apresentando, como vantagens, a não sincronização e a

possibilidade de utilização de valores nulos. A seguir é mostrado um exemplo da sua

utilização:

import java.util.*;

public class ExemploHashMap


{ HashMap<String, String> agenda;

TreeMap agendaOrdenada;

agenda = new HashMap<String, String>();


agenda.put("José da Silva","11-4845-4555");

agenda.put("Maria Pereira","11-4464-1232");

agenda.put("Ana dos Santos","19-3254-4529");

agenda.put("Pedro Rodrigues","11-4522-0023");

agendaOrdenada = new TreeMap(agenda);

System.out.println("HashMap: " + agenda.toString());

System.out.println("TreeMap: " +

agendaOrdenada.toString());

}

}

Neste exemplo também é importante observar o uso da classe TreeMap que

normalmente é adotada em conjunto com a classe HashMap e permite a ordenação dos

dados a partir da chave definida. Após a execução do programa tem-se o seguinte

resultado:

HashMap: {Ana dos Santos=19-3254-4529, Pedro Rodrigues=11-

4522-0023, José da Silva=11-4845-4555, Maria Pereira=11-

4464-1232}

TreeMap: {Ana dos Santos=19-3254-4529, José da Silva=11-

4845-4555, Maria Pereira=11-4464-1232, Pedro Rodrigues=11-

4522-0023}

Os principais métodos da classe HashMap são:

put - realiza a inserção do um item à coleção:

agenda.put("José da Silva","11-4845-4555");

get - através da chave obtém o objeto armazenado, por exemplo:

String telefone = (String) agenda.get("José da

Silva");

remove - permite através da chave, apagar o objeto:

Agenda.remove("José da Silva");

values – obtém todos os objetos armazenados na coleção:

for (String telefone: agenda.values())

{ System.out.println("Telefone: " + telefone);

}


HashSet

A classe HashSet permite armazenar um único valor ou objeto ao conjunto e o seu

acesso deverá ocorrer de modo seqüencial, através de um Iterator, pois a mesma não

apresenta o conceito de chave de pesquisa, por exemplo:

import java.util.*;

public class ExemploSet


{ HashSet nomes = new HashSet();

nomes.add("João");

nomes.add("Ana");

nomes.add("Pedro");

Iterator item = nomes.iterator();



}

}

}

Os métodos mais utilizados da classe HashSet são:

add - realiza a inserção do um item à coleção:

nomes.add("João");

remove - permite através da chave, apagar o objeto:

nomes.remove("João");

size – obtém a quantidade de itens armazenados, por exemplo:

int tamanho = nomes.size();

iterator – obtém todos os objetos armazenados na coleção:

Iterator item = nomes.iterator();



}


Tratamento de Exceção

Uma exceção provoca o término abrupto da aplicação, sendo que todos os dados,

não armazenados no disco rígido, são perdidos quando isso ocorre. Desta forma, uma

aplicação bem projetada e implementada deverá realizar o tratamento das exceções que

podem ocorrer evitando, desta forma, o encerramento repentino do programa.

A linguagem Java implementa o tratamento de exceção através da classe

Exception, das palavras reservadas throw e throws e da estrutura de controle try-

catch.

A classe Exception consiste na classe pai de qualquer outra classe que implemente

exceções, tanto as definidas pela própria linguagem como as definidas pelo desenvolvedor

da aplicação.

Com o intuito de ilustrar esses conceitos vamos criar um exemplo onde, em uma

hipotética classe chamada Matemática, teremos um método Dividir que deverá gerar uma

exceção sempre que ocorrer uma divisão por zero.

public class Matematica

{ public double Dividir(double x, double y)

throws Exception

{ Exception DivisaoPorZero = new Exception("Não é

possível a divisão por zero.");

if (y==0)

throw DivisaoPorZero;

return (x/y);

}

}

Na declaração do método devemos usar throws para indicar que o método irá

retornar uma exceção no caso de uma falha ocorrer durante a sua execução. Em seguida,

será criado um objeto da classe Exception indicando que ocorreu uma tentativa de

divisão por zero dentro do método.

Dentro da instrução if teremos a condição (y igual a zero) que quando verdadeira

irá gerar a exceção e, desta forma, o código return (x/y) que provocaria o término

inesperado da aplicação não é executado.


Quando for necessário utilizar o método Dividir, será obrigatório que mesmo seja

executado dentro de uma estrutura de controle try-catch para, em caso de erro, poder

realizar o devido tratamento da exceção, por exemplo:

public class Principal


{ Matematica m = new Matematica();

try

{ System.out.println("Resultado: " + m.Dividir(10, 0));

}

catch(Exception e)

{ System.out.println("ERRO: " + e.getMessage());

}

System.out.println("Fim do programa.");

}

}

No try-catch o código que poderá gerar a exceção deverá ficar dentro do bloco

try, em caso de uma execução bem sucedida o bloco catch não será executado, caso

contrário, o mesmo é executado. Também é importante salientar que, em qualquer uma das

situações, a execução da aplicação irá prosseguir. Desta forma, no nosso exemplo, a

mensagem “Fim do programa.” será sempre exibida independente da ocorrência ou não de

exceções durante a execução da aplicação.


JUnit – Testes Unitários

O JUnit3 é um framework que permite a criação de testes unitários em Java,

também denominados testes pontuais. O conceito de testes unitários está relacionado à

verificação isolada de pequenos blocos de código, ou seja, em uma linguagem orientada a

objetos, podemos nos referir a testes das classes que irão compor um programa, e assim

pode-se realizar testes em pequenos blocos ao invés de testar toda a aplicação.

Desta forma, torna-se possível a realização dos testes mesmo durante as fases

iniciais do desenvolvimento e com esse framework não necessariamente necessita-se da

utilização de IDEs como NetBeans e Eclipse. O motivo? O JUnit já possui todo o suporte

necessário para o seu funcionamento.

Considerando a classe Matematica, mostrada abaixo, e que tem como objetivo

implementar as quatro operações aritméticas básicas sobre números do tipo de dados

double, iremos desenvolver um conjunto de testes unitários sobre a mesma.

public class Matematica

{ public double somar (double n1, double n2)

{ return (n1 + n2);

}

public double subtrair (double n1, double n2)

{ return (n1 - n2);

}

public double multiplicar (double n1, double n2)

{ return (n1 * n2);

}

public double dividir (double n1, double n2)

{ return (n1 / n2);

}

}

No JUnit é necessário criar uma nova classe que iremos chamar, neste exemplo, de

MatematicaTest e que irá implementar um conjunto de testes unitários sobre os

métodos implementados na classe Matemática:

import static org.junit.Assert.*;

import org.junit.Test;

3 Disponível em http://www.junit.org

http://www.junit.org/


public class MatematicaTest {

@Test

public void testSomar() {

System.out.println("somar");

double n1 = 10.0;

double n2 = 20.0;

Matematica instance = new Matematica();

double expResult = 30.0;

double result = instance.somar(n1, n2);

assertEquals(expResult, result, 0.0);

}

@Test

public void testSubtrair() {

System.out.println("subtrair");

double n1 = 0.0;

double n2 = 0.0;



double result = instance.subtrair(n1, n2);


}

@Test

public void testMultiplicar() {

System.out.println("multiplicar");

double n1 = 0.0;

double n2 = 0.0;



double result = instance.multiplicar(n1, n2);


}

@Test

public void testDividir() {

System.out.println("dividir");

double n1 = 10.0;

double n2 = 2.0;



double result = instance.dividir(n1, n2);


}


}

Na classe MatematicaTest os métodos responsáveis pelo teste unitário

receberão a anotação @Test e irão fornecer um conjunto de valores a um determinado

método da classe Matematica e, em seguida, comparar o resultado obtido com o

resultado esperado através do método assertEquals.

Todos os métodos de teste devem possuir esta assinatura, ou seja, devem ser

públicos, retornar void e não podem receber valores como argumento. Com a utilização

do JUnit, é possível que os programadores possam testar suas classes individualmente,

durante o desenvolvimento da aplicação, garantindo uma maior qualidade do produto no

processo de desenvolvimento.


Apêndice A: Utilização do NetBeans

Um IDE, do inglês Integrated Development Environment ou Ambiente Integrado de

Desenvolvimento, pode ser entendido como um programa de computador que reúne

características e ferramentas de apoio ao desenvolvimento de programas como, por

exemplo, editor de texto, compilador, debugger e ambiente de execução entre outras.

Após iniciar o programa deve-se criar um projeto. Para isso, é necessário escolher a

opção do menu File e depois New Project, conforme Figura 2 a seguir.

Figura 2: Construindo novo projeto na IDE NetBeans.

O NetBeans é uma opção de IDE

para desenvolvimento de aplicações em

Java com distribuição gratuita. Está

disponível para download no endereço

http://www.netbeans.org. O NetBeans necessita

da instalação do Java Development Kit

(JDK).



A seguir, conforme Figura 3, o primeiro passo consiste em escolher o tipo de

aplicação que será gerada, neste exemplo será criada um Aplicativo Java, em seguida o

botão Próximo deverá ser pressionado.

Figura 3: Escolhendo o tipo de aplicação na IDE NetBeans.

Esta próxima janela irá permitir a definição do nome do projeto, a localização dos

arquivos e a definição da classe principal, ou seja, aquela que irá conter o método Main e

que será executada quando o programa for iniciado.


Após preencher esses campos deve-se pressionar o botão Finalizar. Agora será

exibido um gabarito, conforme Figura 4 a seguir, com a estrutura básica de um programa

Java, a qual deverá ser completada com os comandos desejados:

Figura 4: Interface da IDE NetBeans para programação em Java.

A compilação da aplicação deve ser realizada utilizando-se a opção do menu

Depurar e depois Depurar Projeto Principal (F11).

Para executar a aplicação a opção do menu Executar e Executar Projeto Principal

deverá ser usada, sendo que o resultado da aplicação (F6), quando em modo console, será

exibida na janela posicionada na parte inferior do NetBeans, conforme ilustrado pela

Figura 5 a seguir.

Figura 5: Resultado de compilação na IDE NetBeans.


Apêndice B: Utilização do Eclipse

Após iniciar o Eclipse a seguinte janela de boas vindas será exibida, conforme

Figura 6, a seguir:

Figura 6: Interface da IDE Eclipse.

O Eclipse é uma outra opção de

IDE para o desenvolvimento de

aplicações na linguagem Java, é de

distribuição gratuita e pode ser baixado

a partir do endereço http://www.eclipse.org.

Do mesmo modo que o NetBeans, o

Eclipse também necessita da instalação

do JDK.



O primeiro passo consiste na criação de um projeto, para isso utilizar a opção do

menu File, New e depois Java Project. Neste momento a seguinte janela, conforme Figura

7 a seguir será exibida:

Figura 7: Criação de um projeto na IDE Eclipse.

Deve-se preencher o nome do projeto que, neste exemplo, será OlaMundo e

pressionar o botão Next.


Na próxima janela serão utilizados os valores padrão, neste caso, deve-se pressionar

apenas o botão Finish. A página de boas vindas deverá ser fechada e a IDE para

desenvolvimento da programação em Java será exibida, conforme Figura 8 a seguir:

Figura 8: Interface da IDE Eclipse para programação em Java.

A etapa seguinte consiste em criar os arquivos que irão conter o código-fonte do

programa, na linguagem Java isso é realizado através da adição de classes ao projeto.

Para adicionar uma classe devemos selecionar a opção do menu File e depois New,

em seguida, a opção Classe deverá ser escolhida, conforme Figura 9 a seguir:


Figura 9: Criando uma classe na IDE Eclipse

A janela para definição da classe é mostrada, para o desenvolvimento deste exemplo

preencha o campo Name com o nome da classe que deverá ser criada, ou seja, OlaMundo

e pressione o botão Finish.

Em seguida deverá ser criado um método chamado main e poderá ser observado o

código fonte da classe OlaMundo, conforme mostrado a seguir.

public class OlaMundo

{ public static void main (String[] args)

{ System.out.println("Olá Mundo!");

}

}

Após a digitação do código-fonte da aplicação o projeto deverá ser salvo, para fazer

isso, escolher a opção do menu File e depois Save All.

O projeto neste momento está pronto para ser executado, porém antes disso,

verifique na aba Problems se não existem erros, conforme a Figura 10.

Figura 10: Console de ocorrências de erros de compilação na IDE Eclipse.

A execução do projeto será realizada através da opção Run disponível no menu,

sendo que o resultado poderá ser observado na aba Console, observando a ilustração da

Figura 11.


Figura 11: Resultado da compilação no console da IDE Eclipse.


Programação

Java

A linguagem de programação Java é amplamente utilizada para o desenvolvimento

dos mais diversos tipos de aplicações e também para uma grande variedade de

plataformas. Esta obra é o resultado da experiência adquirida ao longo dos anos dedicados

ao ensino nos cursos de graduação em informática e, tem como objetivo, realizar uma

introdução aos conceitos fundamentais da linguagem de programação Java e também

sobre o paradigma de orientação a objetos.

Benedito Cristiano Aparecido Petroni

Cláudio Luís Vieira Oliveira

Documents

Java Fundamentos