Java Fundamentos 60f4c

Fundamentos da Linguagem de Programação

Java

Benedito C. A. Petroni Cláudio L. V. Oliveira


Java

Capa: Claudia Baptistella Oliveira http://www.artesclaudia.com.br

Fundamentos da Linguagem de Programação Java

I

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


II


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


III


Lista de Tabelas Tabela 1. Principais tipos de dados na linguagem Java ........................................................................................................... 10 Tabela 2. Principais classes para tipos de dados ..................................................................................................................... 11


IV


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


V



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 ando 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.


1


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 e 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, am 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.


2


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.


3


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 boolean Um bit com contendo valor verdadeiro (true) ou falso (false) byte valor inteiro com sinal de 1 byte short valor inteiro com sinal de 2 bytes char caractere de 2 bytes int valor inteiro com sinal de 4 bytes float valor numérico com precisão decimal de 4 bytes double long

Valores true ou false

Padrão false

-128 a 127

0

-32.768 a 32.767

0

0 a 65.535 -2.147.483.648 a 2.147.483.647 1.40129846432481707e-45 a 3.40282346638528860e+38 (positivo ou negativo) valor numérico com 4.94065645841246544e-324 a precisão decimal de 8 bytes 1.79769313486231570e+308 (positivo ou negativo) valor inteiro com sinal de 8 -9.223.372.036.854.775.808 a bytes +9.223.372.036.854.775.807

'\u0000' 0 0,0f

0,0d

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;


4


Classes para Tipos de Dados Além dos tipos de dados ados 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 String Integer Float Double Date

Objetivo Cadeia de caracteres Definir um objeto para o tipo inteiro Definir um objeto para o tipo de dados float Definir um objeto para o tipo de dados double 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");


5


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.


6


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; } Fundamentos da Linguagem de Programação Java

7


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 ado 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.


8


Encapsulamento: consiste na separação de características internas e externas de um determinado objeto. Este recurso é comumente utilizado para evitar o o 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 ados por outras classes, a classe Pessoa poderia ser escrita da seguinte forma: public class Pessoa { private String nome; private String endereco; private String telefone; 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); } // Demais métodos ... } Fundamentos da Linguagem de Programação Java

9


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 ado o endereço de memória do objeto. public class Veiculo{ private String marca; private String modelo; public String toString(){ return marca+" "+modelo; } // Demais métodos ... }

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.


10


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.


11


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 NetBeans 1 e Eclipse2.

1

Disponível em www.netbeans.org Disponível em www.eclipse.org Fundamentos da Linguagem de Programação Java

2

12


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. Fundamentos da Linguagem de Programação Java

13


O próximo o consiste em criar um objeto pertencente a classe BufferedReader, o qual permitirá receber os dados da System.in que representa o o 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 { public static void main(String[] args) { 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”; Fundamentos da Linguagem de Programação Java

14


int saida = new Integer(entrada).intValue(); A conversão é realizada em dois os: 



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.


15


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.


16


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 é ado com o índice recebendo o valor 0 (zero). Para ar 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;


17




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. Fundamentos da Linguagem de Programação Java

18


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. Fundamentos da Linguagem de Programação Java

19


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 é Fundamentos da Linguagem de Programação Java

20


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 realizase o seu incremento. Em seguida, a condição é verificada e, neste exemplo, será considerada falsa, encerrando a estrutura do-while. int i = 11; do { System.out.println(i); 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. Fundamentos da Linguagem de Programação Java

21


for (int i = 1; i <= 10; i++) { System.out.println(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.


22


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.


23


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 ados 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; } Fundamentos da Linguagem de Programação Java

24


public int ObterCodigo() { return (codigo); } // Demais métodos ... } 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); } // Demais métodos ... } 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.


25


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 ados 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 o 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() + "."); }


26


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 ageiros, 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 issã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.


27


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 s 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 itida é a definição de constantes. Todas as operações de uma interface são públicas, não sendo exigido o modificador public nas s 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(); }


28


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 e 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 { private String nome; private String endereco; private String telefone; 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; } } Fundamentos da Linguagem de Programação Java

29


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 s 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.


30


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 ados 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. Fundamentos da Linguagem de Programação Java

31


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.


32


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 { public static void main(String[] args) { 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 o para o desenvolvimento do exemplo consiste em criar o objeto lista que irá conter um conjunto de valores, neste exemplo, alguns nomes de pessoas.


33


É 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 ar 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 o 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 { public static void main(String[] args) { HashMap<String, String> agenda; TreeMap agendaOrdenada; agenda = new HashMap<String, String>(); Fundamentos da Linguagem de Programação Java

34


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=114522-0023, José da Silva=11-4845-4555, Maria Pereira=114464-1232} TreeMap: {Ana dos Santos=19-3254-4529, José da Silva=114845-4555, Maria Pereira=11-4464-1232, Pedro Rodrigues=114522-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é 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); }


35

da


HashSet A classe HashSet permite armazenar um único valor ou objeto ao conjunto e o seu o 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 { public static void main(String[] args) { HashSet nomes = new HashSet(); nomes.add("João"); nomes.add("Ana"); nomes.add("Pedro"); Iterator item = nomes.iterator(); while (item.hasNext()) { System.out.println(item.next()); } } } 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(); while (item.hasNext()) { System.out.println(item.next()); }


36


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 trycatch. 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.


37


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 { public static void main(String[] args) { 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.


38


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 e 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 Fundamentos da Linguagem de Programação Java

39


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; Matematica instance = new Matematica(); double expResult = 0.0; double result = instance.subtrair(n1, n2); assertEquals(expResult, result, 0.0); } @Test public void testMultiplicar() { System.out.println("multiplicar"); double n1 = 0.0; double n2 = 0.0; Matematica instance = new Matematica(); double expResult = 0.0; double result = instance.multiplicar(n1, n2); assertEquals(expResult, result, 0.0); } @Test public void testDividir() { System.out.println("dividir"); double n1 = 10.0; double n2 = 2.0; Matematica instance = new Matematica(); double expResult = 5.0; double result = instance.dividir(n1, n2); assertEquals(expResult, result, 0.0); } Fundamentos da Linguagem de Programação Java

40


} 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 , 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.


41


Apêndice A: Utilização do NetBeans

O NetBeans é uma opção de IDE para desenvolvimento de aplicações em Java com distribuição gratuita. Está disponível para no endereço http://www.netbeans.org. O NetBeans necessita da instalação do Java Development Kit (JDK). 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.


42


A seguir, conforme Figura 3, o primeiro o 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.


43


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.


44


Apêndice B: Utilização do 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. Após iniciar o Eclipse a seguinte janela de boas vindas será exibida, conforme Figura 6, a seguir:

Figura 6: Interface da IDE Eclipse.


45


O primeiro o 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.


46


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:


47


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.


48


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


49



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

Java Fundamentos 60f4c

Overview 3e4r5l

More details w3441

Related Documents 3m3m1z

Java Fundamentos 60f4c

Java Fundamentos 60f4c

Fundamentos De Programacion Java g62x

Fundamentos De Java 5o4b40

0209 Fundamentos De Java - Herbert Schildt[1] 2d6i60

237528534-fundamentos-de-programacion-java-ricardo-villalobos.pdf 70265

More Documents from "alvarocalacina" 1u6m38

Java Fundamentos 60f4c