You are on page 1of 128

JAVA

SUMÁRIO
Capítulo 1: LÓGICA DE PROGRAMAÇÃO ..................................................................................7 Introdução à Lógica de Programação ...................................................................................7 SEQUÊNCIA LÓGICA...........................................................................................................7 INSTRUÇÕES ......................................................................................................................7 ALGORITMO ......................................................................................................................8 PROGRAMAS .....................................................................................................................8 Capítulo 2: DESENVOLVENDO ALGORITMOS .........................................................................10 PSEUDOCÓDIGO ..............................................................................................................10 FASES ...............................................................................................................................10 Algoritmo.........................................................................................................................12 TESTE DE MESA ...............................................................................................................12 Capítulo 3: DIAGRAMA DE BLOCO ..........................................................................................14 O QUE É UM DIAGRAMA DE BLOCO? .................................................................................14 SIMBOLOGIA....................................................................................................................14 Constantes, Variáveis e Tipos de Dados..........................................................................16 Operadores Relacionais...................................................................................................19 Operadores Lógicos .........................................................................................................21 Operações Lógicas ...........................................................................................................22 Estrutura de Decisão e Repetição .......................................................................................23 CASO SELECIONE / SELECT ... CASE .................................................................................26 COMANDOS DE REPETIÇÃO ............................................................................................29 Capítulo 4: ESTRUTURAS DE CONTROLE DE FLUXO ...............................................................33 switch … case ......................................................................................................................33 Array ................................................................................................................................35 CAPÍTULO 5: INTRODUÇÃO ....................................................................................................38 Aspectos técnicos ............................................................................................................38 Aspectos conceituais .......................................................................................................38 Java é o mesmo que JavaScript ? ....................................................................................41 Programação para a Internet ? ...........................................................................................42 Integração Java-HTML .....................................................................................................42 A difusão de Java .............................................................................................................43 Origem da Linguagem .........................................................................................................44 Características da Linguagem ..........................................................................................45 CAPÍTULO 6: JAVA MACHINE ..................................................................................................46

Java Virtual Machine ...........................................................................................................46 Java Virtual Machine .......................................................................................................46 Compiladores e Interpretadores .....................................................................................46 Arquitetura Java ..............................................................................................................47 “Turbinando” o interpretador .........................................................................................47 Vantagens ........................................................................................................................48 Desvantagens ..................................................................................................................48 Arquitetura Java Machine ...................................................................................................49 A arquitetura da Máquina Java .......................................................................................49 Java e suas edições .............................................................................................................49 CAPÍTULO 7: AMBIENTE DE DESENVOLVIMENTO ..................................................................51 Java Development Kit .........................................................................................................51 Eclipse .................................................................................................................................52 Instalação ........................................................................................................................52 Execução do Eclipse ........................................................................................................52 Criando um projeto .............................................................................................................52 Perpectivas ......................................................................................................................53 Acrescentando uma classe ..............................................................................................53 Executando um programa ...............................................................................................53 Depurando um programa................................................................................................53 Depurando um programa ...................................................................................................54 Mudando a versão do JDK ..................................................................................................54 CAPÍTULO 8: ESTRUTURA DE UM PROGRAMA JAVA..............................................................55 Requisitos Básicos ...............................................................................................................55 Requisitos Básicos – exemplo .........................................................................................55 Tipos Básicos .......................................................................................................................56 Classes Básicas ....................................................................................................................57 Variáveis ..............................................................................................................................58 Declaração e inicialização................................................................................................59 Variáveis locais ................................................................................................................59 Conversão de tipos ..........................................................................................................59 Operadores e expressões ...................................................................................................60 Operadores aritméticos ..................................................................................................60 Operadores conjugados com atribuição de valores .......................................................60 Operadores de incremento e decremento .....................................................................61

.......................................................................................................................................................................................................................................................................................62 Condicionais ......................................................................................61 Operadores lógicos......................................................................................77 ..........................................................................................................................................................................................................................................................................75 API Java ...............................................66 Conceito de classe......................................................67 Atributos..................................................................................................................64 Interrompe a execução de um bloco indicado ...........................................................................................................69 Definição de uma classe e alocação ..............69 Construtor ......................................................................................................................63 Definir o pacote ao qual pertence a classe sendo definida ...................................Operadores de comparação ........72 Sobrecarga de Métodos ...........64 Parâmetros de entrada ......................................................................................................................................................71 Notação UML ......................................................................................................................................................................................................................................69 Método Abstrato ....................62 Comentários .............................................................................................................................74 Classes e métodos abstratos ..........63 Importar para o arquivo fonte as classes ou pacotes indicados .............................................................................. métodos e interfaces ...................................................................66 Programação orientada a objetos ....................................................................73 Sobrecarga de construtores .................................................................................................................66 Classes e Objetos ................68 Regras gerais ...........68 Métodos Especiais ......................................................................................................64 Forçar a próxima iteração do laço indicado ..................................................................................................................................................62 Laços .................61 Operadores bit a bit ...............69 Destrutor ....................................................................................................................................................................................................................................................................................................................................64 CAPÍTULO 9: CLASSES E OBJETOS ................70 Referências a objetos..............................................................................75 Atributos e métodos estáticos ........71 Declaração de métodos .....................61 Comandos básicos ........................................................................................................................................................................70 Construtores e instanciação ...................................................................66 O que é ? ..........................................................................76 CAPÍTULO 10: ARRAYS E STRING ....................................64 Pacotes ............................................................................................................................................................................................................................................................................................................................

....................Calendar) .....................................................................................................................................................................Definição da interface ............................................................util...................94 Modificadores de acesso ..........................................................................85 Sobrescrita de métodos .........91 Exemplo ..................................Redefinição da classes .............................................................................................................Definição das classes derivadas .............................................................................................................103 CAPÍTULO 14: ENTRADA E SAÍDA ...............................87 Interface ..............81 Anatomia da herança ...........................................90 Exemplo ...........................................................................................................................97 Calendar(java.........................................................................................................................................................81 Herança .....................................................102 Polimorfismo e Herança .........................................................................................................92 Exemplo .........................................................................106 Entrada ......................................................................................................................................................................................................................................................................................................................................................................................97 Date(java............................81 Herança e hierarquia de classes .......................................................................93 CAPÍTULO 12: ENCAPSULAMENTO ..............................................................................96 Manipulando datas em Java ..Alocação de arrays ...............................................................................................................................90 Definição das classes bases .........102 Exemplo conceitual ........................................................................................................................................................83 Definição de subclasses .........................................................................87 Declaração de interfaces ....................util.............................................................................................................................................................................................................................................................text.................................94 Modificadores de acesso ...........................Date) .....95 Exemplo ......98 CAPÍTULO 13: POLIMORFISMO ................Redefinição das classes bases ...............107 Classes herdadas de InputStream .................108 .............85 Herança e construtores .........................................................................................................DateFormat) .............92 Modificador final ..............................................................................................................................106 InputStream ...78 Arrays multidimensionais .............................................................................................................................................................97 DateFormat(java.....................84 Chamada de métodos na herança .................................................................................................................................79 String .......................................................................................................................................................................................80 CAPÍTULO 11: HERANÇA E INTERFACES ..........................................................89 Exemplo do uso de interfaces .......................91 Exemplo .........exemplo ........................................................................................

110 A classe File .......................................................................................................Saída ..........................................................................................................................123 Coleções ................................................................118 Tratamento.................................................................................................117 Modificador throws .......115 CAPÍTULO 16: EXCEÇÕES E ERROS ...................120 Tratamento múltiplo ......................121 Definindo exceções ..........................................................................................................................................................................................................................113 Sincronização de threads ...............................................................................................................119 Passando o tratamento adiante ..126 ...............................................................109 Readers e Writers .......................................................................122 CAPÍTULO 17: TÓPICOS AVANÇADOS .............................................................................................................................116 Tratamento em Java .............................................................................................................................................................................................................112 Diagrama ......................................................................................................................................................................................OutputStreams .....................................................................................................................125 Generics ...................111 CAPÍTULO 15: THREADS ........................................................................................................................................................123 Networking ..............................113 Implementação .............................................................................121 A cláusula finally ....................................................................................................116 Maneira comum de tratar exceções/erros .............................................................................................................................................................................................

etc. se quisermos fazer uma omelete de batatas.. que devem ser seguidas para se cumprir uma determinada tarefa. precisaremos colocar em prática uma série de instruções: descascar as batatas. entende-se por instruções “um conjunto de regras ou normas definidas para a realização ou emprego de algo”. para obtermos o resultado. INSTRUÇÕES Na linguagem comum.CAPÍTULO 1: LÓGICA DE PROGRAMAÇÃO INTRODUÇÃO À LÓGICA DE PROGRAMAÇÃO A lógica de programação é necessária para pessoas que desejam trabalhar com desenvolvimento de sistemas e programas. precisamos colocar em prática o conjunto de todas as instruções. fritar as batatas. Sequência Lógica são passos executados até atingir um objetivo ou solução de um problema. Por exemplo. porém.. Em informática. ela permite definir a sequência lógica para o desenvolvimento. instrução é a informação que indica a um computador uma ação elementar a executar. uma instrução tomada em separado não tem muito sentido. Convém ressaltar que uma ordem isolada não permite realizar o processo completo. Instruções é um conjunto de regras ou normas definidas para a realização ou emprego de algo. para isso é necessário um conjunto de instruções colocadas em ordem sequencial lógica. é o que indica a um computador uma ação elementar a executar. É evidente que essas instruções têm que ser executadas em uma ordem adequada – não se podem descascar as batatas depois de fritá-las. SEQUÊNCIA LÓGICA Estes pensamentos podem ser descritos como uma sequência de instruções. na ordem correta. Dessa maneira. Então o que é lógica? Lógica de programação é a técnica de encadear pensamentos para atingir determinado objetivo. Em informática. bater os ovos. 7 .

Por exemplo: “Chupar uma bala”. por exemplo. no caso um computador. um programa é por natureza muito específica e rígida em relação aos algoritmos da vida real. Notem que dada esta interpretação rigorosa. que explicam passo-apasso como. multiplicação. Como exemplos de algoritmos podem citar os algoritmos das operações básicas (adição. Podemos pensar em algoritmo como uma receita. como um videocassete. Outros exemplos seriam os manuais de aparelhos eletrônicos. podem ser descritas por sequências lógicas. Pegar a bala Retirar o papel Chupar a bala Jogar o papel no lixo “Somar dois números quaisquer”. gravar um evento. Escreva o primeiro número no retângulo A Escreva o segundo número no retângulo B Some o número do retângulo A com número do retângulo B e coloque o resultado no retângulo C + Triangulo A Triangulo B = Resultado PROGRAMAS Os programas de computadores nada mais são do que algoritmos escritos numa linguagem de computador (Pascal. 8 . Cobol. Fortran.ALGORITMO Um algoritmo é formalmente uma sequência finita de passos que levam a execução de uma tarefa. Estas tarefas não podem ser redundantes nem subjetivas na sua definição. Até mesmo as coisas mais simples. Visual Basic entre outras) e que são interpretados e executados por uma máquina. C. divisão e subtração) de números reais decimais. devem ser claras e precisas. uma sequência de instruções que dão cabo de uma meta específica.

4. Faça um algoritmo para trocar uma lâmpada. Descreva com detalhes a sequência lógica para Trocar um pneu de um carro. Faça um algoritmo para somar dois números e multiplicar o resultado pelo primeiro número 3. Crie uma sequência lógica para tomar banho: 2. Descreva com detalhes: 9 .EXERCÍCIOS 1.

Para isso utilizaremos algumas técnicas: 2. precisamos primeiro dividir o problema apresentado em três fases fundamentais. Ao contrário de uma linguagem de programação não existe um formalismo rígido de como deve ser escrito o algoritmo. Procurar usar palavras que não tenham sentido dúbio. Ou seja. Ser objetivo. 10 . por exemplo. 4. Entretanto ao montar um algoritmo. Este nome é uma alusão à posterior implementação em uma linguagem de programação. quando formos programar em uma linguagem. Imaginar que você está desenvolvendo um algoritmo para pessoas que não trabalham com informática. É importante ressaltar que qualquer tarefa que siga determinado padrão pode ser descrita por um algoritmo. 6. como por exemplo: COMO FAZER ARROZ DOCE ou então CALCULAR O SALDO FINANCEIRO DE UM ESTOQUE.CAPÍTULO 2: DESENVOLVENDO ALGORITMOS PSEUDOCÓDIGO Os algoritmos são descritos em uma linguagem chamada pseudocódigo. Visual Basic. estará gerando código em Visual Basic. REGRAS PARA CONSTRUÇÃO DO ALGORITMO 1. Por isso os algoritmos são independentes das linguagens de programação. Usar somente um verbo por frase. ou seja. 5. de maneira simples e objetiva. Usar frases curtas e simples. Para escrever um algoritmo precisamos descrever a sequência de instruções. O algoritmo deve ser fácil de interpretar e fácil de codificar. ele deve ser o intermediário entre a linguagem falada e a linguagem de programação. FASES No capítulo anterior vimos que ALGORITMO é uma sequência lógica de instruções que podem ser executadas. 3.

P3 e P4. P3 e P4 11 . Onde: Média Final = P1 + P2 + P3 + P4 4 Para montar o algoritmo proposto. P2.Onde temos: ENTRADA: São os dados de entrada do algoritmo PROCESSAMENTO: São os procedimentos utilizados para chegar ao resultado final SAÍDA: São os dados já processados Analogia com o homem Exemplo de Algoritmo Imagine o seguinte problema: Calcular a média final dos alunos da 3ª Série. P2. faremos três perguntas: a) Quais são os dados de entrada? R: Os dados de entrada são P1. Os alunos realizarão quatro provas: P1.

Veja o exemplo: Nota da Prova 1 Nota da Prova 2 Nota da Prova 3 Nota da Prova 4 Utilize a tabela abaixo: P1 P2 P3 P4 MÉDIA 12 . seguir as instruções do algoritmo de maneira precisa para verificar se o procedimento utilizado está correto ou não. Este teste é chamado de TESTE DE MESA.b) Qual será o processamento a ser utilizado? R: O procedimento será somar todos os dados de entrada e dividi-los por 4 (quatro) P1 + P2 + P3 + P4 4 c) Quais serão os dados de saída? R: O dado de saída será a média final ALGORITMO Receba a nota da prova1 Receba a nota de prova2 Receba a nota de prova3 Receba a nota da prova4 Some todas as notas e divida o resultado por 4 Mostre o resultado da divisão TESTE DE MESA Após desenvolver um algoritmo ele deverá sempre ser testado. que significa.

sendo que ESTOQUEMÉDIO = (QUANTIDADE MÍNIMA + QUANTIDADE MÁXIMA) /2 3) Teste o algoritmo anterior com dados definidos por você. 13 . processamento e saída no algoritmo abaixo      Receba código da peça Receba valor da peça Receba Quantidade de peças Calcule o valor total da peça (Quantidade * Valor da peça) Mostre o código da peça e seu valor total 2) Faça um algoritmo para “Calcular o estoque médio de uma peça”.EXERCÍCIOS 1) Identifique os dados de entrada.

Veja no quadro abaixo alguns dos símbolos que iremos utilizar: Dentro do símbolo sempre terá algo escrito. portanto. com significado bem definido. sua principal função é a de facilitar a visualização dos passos de um processamento. SIMBOLOGIA Existem diversos símbolos em um diagrama de bloco.CAPÍTULO 3: DIAGRAMA DE BLOCO O QUE É UM DIAGRAMA DE BLOCO? O diagrama de blocos é uma forma padronizada e eficaz para representar os passos lógicos de um determinado processamento. Veja no exemplo a seguir: Exemplos de Diagrama de Bloco “CHUPAR UMA BALA” “CALCULAR A MÉDIA DE 4 NOTAS 14 . Com o diagrama podemos definir uma sequência de símbolos. pois somente os símbolos não nos dizem nada. No decorrer do curso apresentaremos os mais utilizados.

Desenvolva um diagrama que: Leia 4 (quatro) números Calcule o quadrado para cada um Somem todos e Mostre o resultado 3. levando-se em consideração que sua comissão será de 5% do total da venda e que você tem os seguintes dados: 15 . EXERCÍCIOS 1. já no segundo exemplo da média utilizamos cálculo e exibimos o resultado do mesmo.Veja que no exemplo da bala seguimos uma sequência lógica somente com informações diretas. Construa um algoritmo para pagamento de comissão de vendedores de peças. Construa um diagrama de blocos que : Leia a cotação do dólar Leia um valor em dólares Converta esse valor para Real Mostre o resultado 2.

Identificação do vendedor Código da peça Preço unitário da peça Quantidade vendida E depois construa o diagrama de blocos do algoritmo desenvolvido. Exemplos de variáveis. VARIÁVEIS E TIPOS DE DADOS. reais. Um programa deve conter declarações que especificam de que tipo são as variáveis que ele utilizará e às vezes um valor inicial. Uma variável é um espaço reservado na memória do computador para armazenar um tipo de dado determinado. a constante é classificada como sendo numérica lógica e literal. durante a execução de um programa. Cada variável corresponde a uma posição de memória. etc. As expressões combinam variáveis e constantes para calcular novos valores. e por fim faça um teste de mesa. Tipos podem ser. cujo conteúdo pode se alterado ao longo do tempo durante a execução de um programa. Conforme o seu tipo. Constantes Constante é um determinado valor fixo que não se modifica ao longo do tempo. 16 . caracteres. ela só pode armazenar um valor a cada instante. Exemplos de constante Variáveis Variável é a representação simbólica dos elementos de certo conjunto. por exemplo: inteiros. Embora uma variável possa assumir diferentes valores. Variáveis e constantes são os elementos básicos que um programa manipula. Variáveis devem receber nomes para poderem ser referenciadas e modificadas quando necessário. CONSTANTES.

Faça um teste de mesa no diagrama de bloco abaixo e preencha a tabela ao lado com os dados do teste: 17 . Pode em determinados momentos conter somente dados numéricos ou somente literais. caracteres. O que é uma variável? Dê dois exemplos. Ex: nomes. Caracteres Específicos para armazenamento de conjunto de caracteres que não contenham números (literais). EXERCÍCIOS 1. Declaração de Variáveis As variáveis só podem armazenar valores de um mesmo tipo. de maneira que também são classificadas como sendo numéricas lógicas e literais. que posteriormente poderão ser utilizados para cálculos.Tipos de Variáveis As variáveis e as constantes podem ser basicamente de quatro tipos: Numéricas. Podem ser ainda classificadas como Inteiras ou Reais. Alfanuméricas Específicas para dados que contenham letras e/ou números. 2. não poderá ser utilizada para operações matemáticas. Numéricas Específicas para armazenamento de números. Lógicas Armazenam somente dados lógicos que podem ser Verdadeiro ou Falso. 3. As variáveis do tipo inteiro são para armazenamento de números inteiros e as Reais são para o armazenamento de números que possuam casas decimais. O que é uma constante? Dê dois exemplos. Se usado somente para armazenamento de números. Alfanuméricas ou lógicas.

decrementamos.4. comparamos e avaliamos dados dentro do computador. Sabendo-se que José tem direito a 15% de reajuste de salário. Temos três tipos de operadores: Operadores Aritméticos 18 . complete o diagrama abaixo: Operadores Os operadores são meios pelo qual incrementamos.

Os valores a serem comparados podem ser caracteres ou variáveis. Os símbolos para os operadores aritméticos são: Hierarquia das Operações Aritméticas 1 º ( ) Parênteses 2 º Exponenciação 3 º Multiplicação. divisão (o que aparecer primeiro) 4 º + ou – (o que aparecer primeiro) Exemplo OPERADORES RELACIONAIS Os operadores relacionais são utilizados para comparar String de caracteres e números. multiplicação e divisão. podem utilizar também o operador para exponenciação. subtração. Além da adição. Estes operadores sempre retornam valores lógicos (verdadeiro ou falso/ True ou False) Para 19 .Operadores Relacionais Operadores Lógicos Operadores Aritméticos Os operadores aritméticos são os utilizados para obter resultados numéricos.

utilize os parênteses. Os operadores relacionais são: Exemplo: Tendo duas variáveis A = 5 e B = 3 Os resultados das expressões seriam: Símbolo Utilizado para comparação entre expressões 20 .estabelecer prioridades no que diz respeito a qual operação executar primeiro.

retornando se o resultado final é verdadeiro ou falso. se verdadeira inverte para falsa e vice-versa. Os operadores lógicos são: E OU NÃO AND OR NOT E / AND Uma expressão AND (E) é verdadeira se todas as condições forem Verdadeiras OR/OU Uma expressão OR (OU) é verdadeira se pelo menos uma condição for verdadeira NOT Um expressão NOT (NÃO) inverte o valor da expressão ou condição. A tabela abaixo mostra todos os valores possíveis criados pelos três operadores lógicos (AND. 21 .OPERADORES LÓGICOS Os operadores lógicos servem para combinar resultados de expressões. OR e NOT).

Pegar a bala A bala é de morango? Se sim. continue com o algoritmo Retirar o papel Chupar a bala Jogar o papel no lixo Exemplo: Algoritmo “Chupar Bala” utilizando diagrama de Blocos 22 . não chupe a bala Se não. neste caso teremos que modificar o algoritmo para: “Chupar uma bala”. toda decisão terá sempre como resposta o resultado VERDADEIRO ou FALSO. Num diagrama de bloco. B = 8 e C =1 Os resultados das expressões seriam: OPERAÇÕES LÓGICAS Operações Lógicas são utilizadas quando se torna necessário tomar decisões em um diagrama de bloco. Imaginemos que algumas pessoas não gostem de chupar bala de Morango. Como no exemplo do algoritmo “CHUPAR UMA BALA”.Exemplos: Suponha que temos três variáveis A = 5.

Exibir P e I no final do processamento. de acordo com as decisões lógicas tomadas em função dos dados ou 23 . ESTRUTURA DE DECISÃO E REPETIÇÃO Como vimos no capítulo anterior em “Operações Lógicas”. Essas decisões interferem diretamente no andamento do programa. verificamos que na maioria das vezes necessitamos tomar decisões no andamento do algoritmo. em B. se for negativo. Construa um diagrama de blocos para ler uma variável numérica N e imprimi-la somente se a mesma for maior que 100. Quando for par armazenar esse valor em P quando for ímpar armazená-lo em I. 3. Se positivo armazene-o em A. Com as instruções de SALTO ou DESVIO pode-se fazer com que o programa proceda de uma ou outra maneira. Ler um número e verificar se ele é par ou ímpar. No final mostrar o resultado. Trabalharemos com dois tipos de estrutura. caso contrário imprimi-la com o valor zero. Elabore um diagrama de blocos que leia um número.EXERCÍCIOS 1. A estrutura de Decisão e a estrutura de Repetição Comandos de Decisão Os comandos de decisão ou desvio fazem parte das técnicas de programação que conduzem a estruturas de programas que não são totalmente seqüenciais. 2.

diferente de “SE/SENÃO” pois sempre um comando será executado independente da condição. Imagine um algoritmo que determinado aluno somente estará aprovado se sua média for maior ou igual a 5. “Se então Senão” e “Caso Selecione”.. se determinada condição for satisfeita pelo comando SE/IF então execute determinado comando...0 ENTÃO ALUNO APROVADO Em diagrama de blocos ficaria assim: Em Visual Basic IF MEDIA >= 5 Then Text1 = “APROVADO” ENDIF SE ENTÃO SENÃO / IF . caso contrário o comando da con dição “falsa” será executado Em algoritmo ficaria assim: 24 . ou seja. com apenas uma diferença.. em “SE” somente podemos executar comandos caso a condição seja verdadeira.0. veja no exemplo de algoritmo como ficaria. THEN .. As principais estruturas de decisão são: “Se Então”. SE MEDIA >= 5. ELSE A estrutura de decisão “SE/ENTÃO/SENÃO”. funciona exatamente como a estrutura “SE”. THEN A estrutura de decisão “SE/IF” normalmente vem acompanhada de um comando. SE ENTÃO / IF .resultados anteriores. ou seja.. caso a condição seja “verdadeira” o comando da condição será executado.

Como no exemplo abaixo: 25 . caso contrário executa o segundo comando “REPROVADO”. executa o comando “APROVADO”. Podemos também dentro de uma mesma condição testar outras condições.SE MÉDIA >= 5. se for verdadeira.0 ENTÃO ALUNO APROVADO SENÃO ALUNO REPROVADO Em diagrama Em Visual Basic IF MEDIA >= 5 Then Text1 = “APROVADO” ELSE Text1 = “REPROVADO” ENDIF No exemplo acima está sendo executada uma condição que.

na condição.. é recebido uma variável “Op” e testado seu conteúdo. caso uma das condições seja satisfeita. o valor de uma variável. o resultado obtido no teste com os valores fornecidos em cada cláusula “Caso”.Em Visual Basic IF MEDIA >= 5 Then IF MEDIA >= 7. é atribuído para a variável Titulo a String “Opção X”. em que está armazenado um determinado conteúdo. caso contrário é atribuído à String “Opção Errada”. No exemplo do diagrama de blocos abaixo. CASE A estrutura de decisão CASO/SELECIONE é utilizada para testar.0 then Text1 = “Aluno APROVADO” ELSE Text1 = “Aluno Necessita fazer outra Avaliação” ENDIF ELSE Text1 = “Aluno REPROVADO” ENDIF CASO SELECIONE / SELECT .. então. Compara-se. então. que produz um resultado. ou. uma única expressão. 26 .

CAPTION = TITULO 27 .Em Visual Basic utilizamos a seguinte sequência de comandos para representar o diagrama anterior. TITULO = “” OP = INPUTBOX(“DIGITE A OPÇÃO”) SELECT CASE OP CASE 1 TITULO = “OPÇÃO 1” CASE 2 TITULO = “OPÇÃO 2” CASE 3 TITULO = “OPÇÃO 3” CASE 4 TITULO = “OPÇÃO 4” CASE 5 TITULO = “OPÇÃO 5” CASE ELSE TITULO = “OPÇÃO ERRADA” END SELECT LABEL1.

E calcule o salário sabendo-se que ele ganha R$ 10. Se o valor resultante do quadrado do terceiro for >= 1000. se o índice crescer para 0. Caso contrário. 3.00 por quilo excedente.25.5 todos os grupos devem ser notificados a paralisarem suas atividades. Caso contrário mostrar tais variáveis com o conteúdo ZERO. João precisa que você faça um diagrama de blocos que leia a variável P (peso de peixes) e verifique se há excesso. No final do processamento imprimir o salário total e o salário excedente. Elabore um diagrama de bloco que leia as variáveis C e N. imprima-o e finalize. homem de bem. comprou um microcomputador para controlar o rendimento diário de seu trabalho.EXERCÍCIOS 1. Quando o número de horas exceder a 50 calcule o excesso de pagamento armazenando-o na variável E. e se é positivo ou negativo. Elabore um algoritmo que dada a idade de um nadador classifique-o em uma das seguintes categorias: Infantil A = 5 a 7 anos 28 . João Papo-de-Pescador.00 por hora.05 até 0. imprima os valores lidos e seus respectivos quadrados. se o índice atingir 0.3 as indústrias do 1º grupo são intimadas a suspenderem suas atividades.00. Faça um diagrama de bloco que leia o índice de poluição medido e emita a notificação adequada aos diferentes grupos de empresas. Toda vez que ele traz um peso de peixes maior que o estabelecido pelo regulamento de pesca do estado de São Paulo (50 quilos) deve pagar uma multa de R$ 4.4 as industrias do 1º e 2º grupo são intimadas a suspenderem suas atividades. 5. Se o índice sobe para 0. 4. respectivamente código e número de horas trabalhadas de um operário. O índice de poluição aceitável varia de 0. Faça um diagrama de bloco que leia um número inteiro e mostre uma mensagem indicando se este número é par ou ímpar. A hora excedente de trabalho vale R$ 20. caso contrário zerar tal variável. A Secretaria de Meio Ambiente que controla o índice de poluição mantém 3 grupos de indústrias que são altamente poluentes do meio ambiente. 2. gravar na variável E (Excesso) e na variável M o valor da multa que João deverá pagar. 6. Se houver. Desenvolva um diagrama que:     Leia 4 (quatro) números. Calcule o quadrado de cada um.

Elabore um algoritmo que gera e escreve os números ímpares dos números lidos entre 100 e 200.. Seguinte (For .... Enquanto x (Do . Trabalharemos com modelos de comandos de repetição: Enquanto x. Até . Até que x (Do . Em diagrama de bloco a estrutura é a seguinte: Exemplo de Contador 29 ... o bloco de operações será executado enquanto a condição x for verdadeira.... (Do Until .... Até que x. COMANDOS DE REPETIÇÃO Utilizamos os comandos de repetição quando desejamos que um determinado conjunto de instruções ou comandos sejam executados um número definido ou indefinido de vezes. O teste da condição será sempre realizado antes de qualquer operação. Processar .... Enquanto a condição for verdadeira o processo se repete.. To . Next) Enquanto x.. processar (Do While .. Loop). Loop Until) Para ..Loop). Podemos utilizar essa estrutura para trabalharmos com contadores.. ou enquanto um determinado estado de coisas prevalecer ou até que seja alcançado.. processar ... Loop While). Loop) Neste caso. Processar .Infantil B = 8 a 11 anos Juvenil A = 12 a 13 anos Juvenil B = 14 a 17 anos Adultos = Maiores de 18 anos 7.. Processar (Do While ...

. Em diagrama de bloco Exemplo de Até . somente executará os comandos enquanto a condição for falsa.Diagrama Em Visual Basic Nr = 0 Do Until Nr = 100 Nr = Nr + 1 Loop Label1.Caption = Nr 30 . Loop) Neste caso. ou seja. o bloco de operações será executado até que a condição seja satisfeita.Em Visual Basic: Nr = 0 Do While Nr <= 100 Nr = Nr + 1 Loop Até que x.. (Do Until ... processar .

else Comando condicional: executa um bloco de comandos se uma condição for verdadeira. e somente depois é realizado o teste da condição. A cláusula else (condição falsa) é opcional...Processar .. 31 .. Em diagrama de bloco Em Visual Basic Nr = 0 Do Nr = Nr + 1 Loop While Nr <= 100 Label1.Caption = Nr Estruturas de controle de fluxo if .. caso seja falso é encerrado o comando DO. Se a condição for verdadeira. os comandos são executados novamente. Enquanto x (Do .. Loop While) Neste caso primeiro são executados os comandos..

")."). Response. } else { Response.Write("Sua idade é: " + idade). 32 .Write("Menor de 18 anos."). } else if (idade > 15 && idade < 18) { Response.").Write("Somente com os pais.Write("Autorizado. Response.if (idade >= 18) { Response.Write("Não autorizado.

Condição de parada. for (int i = 0. Response.CAPÍTULO 4: ESTRUTURAS DE CONTROLE DE FLUXO SWITCH … CASE     Estrutura de decisão que seleciona um comando com base no valor de uma variável. i++) { Response. i < 10.Write(i). } Estruturas de repetição while Estrutura de repetição que realiza as operações indicadas enquanto a condição especificada for verdadeira.Write("<br />"). A cláusula default é opcional. 33 . Estruturas de repetição for Estrutura de repetição composta por três expressões:    Inicialização. Atualização.

Necessita do caractere “.. while Estrutura de repetição semelhante à anterior. Conversão de tipos 34 .” ao final da estrutura. porém as condições são verificadas ao final da execução..Estruturas de repetição do . As operações especificadas são executadas pelo menos uma vez.

ARRAY Array é um tipo que permite o armazenamento de uma coleção de valores de um mesmo tipo. Não podem ter seu tamanho alterado depois de instanciados. Para declarar um Array. basta adicionar um par de colchetes logo após a declaração do tipo dos elementos individuais. Arrays são indexados a partir de zero (0). Instanciando arrays Preenchendo um array Arrays podem ser:    Unidimensionais Bidimensionais Jagged Unidimensionais Bidimensionais Jagged 35 .

Enumerações Definindo tipos enumerados Namespaces Declarando um namespace 36 . Especifica uma variável auxiliar e a coleção ou array cujos elementos serão percorridos.Estruturas de repetição foreach Esta estrutura de repetição é uma variação do for.

Namespaces em cadeia Instrução Using Comentários e regiões Criando comentários e regiões: 37 .

Este conceito nada mais é do que tornar a Internet um meio de interação não apenas entre as pessoas. de forma que os recursos estarão compartilhados nesta grande rede e o seu uso ficará transparente ao usuário final. enriquecimento e agregação de recursos. Tecnicamente. e ao mesmo tempo de fácil programação. Pode comportar o desenvolvimento de uma aplicação de grande porte.CAPÍTULO 5: INTRODUÇÃO ASPECTOS TÉCNICOS Java já nasceu adulto. No entanto pode ser eficientemente usada para aplicações de poucas linhas. A segurança oferecida ao programador em tempo de compilação e execução permite a geração de aplicativos com menos “bugs” e com menos riscos de perda de controle da execução. representa também um novo modelo de computação e desenvolvimento sobre a Internet. o conceito que Java carrega consigo já é amplamente explorado pelas linguagens de programação para a Internet que estão surgindo. ou adaptações. Java apresenta características peculiares. Consegue ser verdadeiramente orientada a objetos.  Java e seus vários aspectos • • • Aspectos conceituais introduzidos com Java Novo paradigma de computação e redes Novo mercado de serviços ASPECTOS CONCEITUAIS Java não representa apenas uma linguagem. Em termos de ambiente de desenvolvimento. Com isso não se percebe na linguagem estruturas acomodadas a posteriori. por razões mercadológicas. Este conceito de rede e computação gera uma série de outros serviços e faz com que as empresas de desenvolvimento norteiem seus esforços neste sentido. gerando “executáveis” bem reduzidos e enxutos. Java é bem homogênea em termos de estrutura e sintaxe. mas entre as aplicações e objetos de programação. que para o programador representam verdadeiras armadilhas. ou seja. 38 . e oferece recursos para tal. não foi uma linguagem que passou pelo processo tradicional de avaliação. acelerando o processo de desenvolvimento. Java otimiza a geração de código em função do tamanho da aplicação. tal como C++. mesmo que Java não seja a linguagem do século XXI. Podemos dizer que.

   Padrão ? • Código aberto X proprietário ? Portabilidade X eficiência ? Economicamente viável ? • Custo X benefício 39 . tais como ponteiros. Dessa forma. destrutores e herança múltipla não a qualifica como inferior nestes aspectos. com o uso de técnicas específicas e desenvolvidas especialmente para isto. o desempenho de uma aplicação Java depende essencialmente do interpretador utilizado. podemos afirmar que Java será sempre menos eficiente ou pelo menos igual a uma mesma aplicação em C. esta simplificação do ponto de vista do programador representou uma enorme complicação para os idealizadores da linguagem. vê-se aplicações idênticas.O que é realmente Java ?   Limitada ? • • Simplicidade ou incapacidade ? Interpretada X compilada ? Ineficiente ? Java é uma linguagem limitada? O fato de Java não apresentar alguns recursos disponíveis em outras linguagens de alto nível. No entanto o limite superior deve ser o limite imposto por C. Veremos mais a fundo esta questão posteriormente. Sob este ponto de vista. Com Java é possível realizar praticamente as mesmas coisas que qualquer outra linguagem que utiliza esses recursos. Para chegar a isto o código binário em Java é na realidade um código interpretado. que tiveram que garantir que Java fosse igualmente eficiente com estes recursos a menos. com a vantagem de ter eliminado grande parte das fontes de erros e bugs que prejudicam e atrasam um desenvolvimento. em máquinas iguais rodando com diferenças de velocidade. A tendência verificada nos interpretadores Java é atingir níveis de performance iguais ao C. Desta forma. Java é ineficiente? Java é independente da plataforma. Com isto.

mas que são especificas para determinadas plataformas. o esforço de seu aprendizagem e seu poder. com ampla participação de comunidades de usuários e com processos de definição e evolução muito parecidos com os procedimentos adotados pelos softwares de código aberto. C# da Microsoft. a real utilidade da linguagem.Java é um novo padrão ? Java não é um padrão aberto. No entanto tem-se verificado que surgiram ferramentas que convertem Java para C. Palms. e Java suporta. Java pretende oferecer o mesmo que C++ em termos de poder de código e ao mesmo tempo oferece um ambiente de desenvolvimento mais “bug free” e conciso que C. almejando exigir menos esforço que programar em C. sem no entanto compartilhar todas as características de Java. a fim de se ganhar em performance. as considerações sobre portabilidade em Java passam as ser as mesmas que as aplicadas a C. semelhantes ao VB. Java é economicamente viável ? Vários fatores devem ser levados nesta consideração. Java é portável ? A característica multiplataforma de Java torna desnecessária. por exemplo. Celulares. etc 40 . Neste caso. a preocupação com sua portabilidade. é muito simular conceitualmente e em termos de linguagem. no entanto. Esta última característica é muito importante porque possibilita o uso de ferramentas de desenvolvimento mais poderosas e automatizadas. a inclusão de rotinas em C nos programas (código nativo). Existem soluções alternativas a Java. em níveis diferentes. Utiliza-se também. por exemplo. em princípio. O sucesso de uma ferramenta depende do que se pode fazer com ela e com que esforço. mas sim uma linguagem definida e controlada pela Sun. entre eles. Com isto surgem aplicações desenvolvidas em Java.   JavaScript ? Programação para desktop ? • • Executáveis linha de comando Programas gráficos – – • • • AWT Swing Games Programação para dispositivos ? Cartões.

especialmente os de pequeno porte. telefones celulares. Java possui todos os recursos para o desenvolvimento de aplicações completas. e que tem um nome similar simplesmente porque compartilha os modelos de dados e objetos de Java. e não a objetos. Para a programação de dispositivos é utilizado um subconjunto das bibliotecas da linguagem. Assim. que é uma linguagem puramente interpretada e portanto goza deste benefício em sua estrutura de programação. muito pouco do que se aplica a Java pode ser aplicado a JavaScript. Pode ser considerado como uma espécie de HTML procedural.  Programação para a Internet ? • • • • • Applets Servlets EJB StoredProcedures Web Services 41 . etc. Programação para desktops ? Java é utilizada para o desenvolvimento de aplicações para desktop.JAVA É O MESMO QUE JAVASCRIPT ? JavaScript é uma outra linguagem. e interage diretamente com as diretivas da página. Programação para dispositivos ? Java é amplamente utilizada para o desenvolvimento de aplicações em dispositivos. A construção de programas gráficos pode ser feita com bibliotecas gráficas simples (AWT) ou mais ricas (Swing). para a execução de um programa Java num desktop é necessário que este possua uma Java Virtual Machine instalada. tais como cartões. o que geralmente não é levado em conta quando se estuda Java. como veremos logo mais. Unix. inclusive jogos. e pode substituir Java em muitas aplicações. especialmente pelas empresas que desejam ter uma única ferramenta para diferentes plataformas (Windows. A grande vantagem da utilização de Java é que um mesmo programa pode rodar em dispositivos diferentes devido a característica multiplataforma dos programas. No entanto. Linux. chamado JME (Java Micro Edition). orientada a modelos. JavaScript é utilizado para acrescentar processamento local às páginas HTML. Mac. Convém ressaltar que JavaScript é muito poderosa. computadores de mão e até mesmo robôs.).

que transcende a simples integração com o HTML e não se baseia em nenhum padrão formal. Os componentes que são executados nos navegadores são chamados de Applets. Muitos banco de dados permitem a construção de Stored Procedures escritas em Java. Independente do tipo de componente. Além desses componentes que rodam no servidor. a linguagem é a mesma. Applets são programas em Java que rodam em uma parte da página HTML delimitada por um diretiva específica. Java consegue manipular recursos da própria janela de browser. Outro aspecto a ser considerado é a integração Java-browser. Os componentes que rodam nos servidores podem ser do tipo Servlets ou do tipo Enterprise Java Beans (EJB). A linguagem Java pode ser utilizada para a construção de todos esses tipos de componentes.   Integrada ao HTML • • • Applets são programas que rodam dentro de uma página tempo recorde de difusão busca dos principais fornecedores pela compatibilidade e suporte à Java Amplamente difundida INTEGRAÇÃO JAVA-HTML Java encontra-se totalmente integrado ao HTML nas aplicações chamadas Applets. como por exemple forçar a abertura de uma nova instância do browser. Existem ainda os componentes que rodam em servidores que implementam um ou mais WebServices. uma aplicação Web pode depender de componentes que são executados no cliente (navegador) e mesmo componentes que são executados no banco de dados. Java portanto introduziu novas diretivas à linguagem HTML. banco de dados ou navegadores suportam a execução desses componentes. Não só o espaço alocado na página é definido por diretivas HTML. diferindo apenas a forma como os programas são construídos e a forma como os diferentes servidores. Este tipo de interação é mais forte e torna Java mais do que um parceiro do HTML. mas um parceiro do browser.PROGRAMAÇÃO PARA A INTERNET ? Uma aplicação Web normalmente possui componentes que são executados num servidor Web (ou num servidor de aplicação). 42 . mas também a passagem de parâmetros para o applet.

Java pode ser aprendida facilmente Este ponto é controverso. garantindo que programas construídos para um servidor possa rodar em qualquer outro. 43 . I/O e rede Inúmeras bibliotecas e ferramentas de terceiros ou em código aberto Fácil aprendizado • • • • Constantemente aprimorada geração de pacotes e bibliotecas papel de outras companhias Sun não deseja manter o controle Java é rico em recursos Java apresenta todos os recursos para programação de interfaces com usuário. Todo este conjunto de recursos dá à linguagem uma enorme potencialidade de aplicações. fácil manipulação de I/O e capacidade de interação em ambientes de rede. Existem certificações de ferramentas que atestam a sua compatibilidade à linguagem. grande parte delas de uso livre. Java é muito fácil de ser aprendido para quem já conhece uma linguagem de programação. Java é mais fácil de ser aprendida por quem já conhece uma linguagem orientada a objetos. Todos os browsers buscam compatibilidade e grande parte dos servidores de aplicação e banco de dados suportam a linguagem. grupos ou empresas que colaboram com o desenvolvimentos de ferramentas ou bibliotecas. Mas podemos dividir a afirmação acima em três que são mais amplamente aceitas:    Java é fácil de ser aprendida por quem não conhece nenhuma linguagem de programação.A DIFUSÃO DE JAVA Nenhuma outra linguagem conseguiu se difundir em tempo tão curto quanto Java. Adicionalmente. é crescente o número de usuários.  Enorme potencialidade • • •  multimídia recursos de IU.

Dessa forma. O grande trunfo de Java é permitir que se programem aplicações que utilizam os recursos da Internet. e os recursos concisos. ORIGEM DA LINGUAGEM  Concebida e desenvolvida pela SunSoft . poderosos e práticos do C. Quem conhece C++ percebe que Java se encaixa mais corretamente nos conceitos de OOP e quem conhece Smalltalk percebe que Java permite um controle maior dos recursos do sistema. A SunSoft vinha trabalhando há muito tempo no desenvolvimento de ambientes Smalltalk.braço da Sun •     Suporte e compatibilidade nos produtos da Netscape . Além da iniciativa de companhias. Portanto é um casamento feliz. Outras companhias estão acrescentando novos recursos através do fornecimento de novas bibliotecas. Com a proliferação dos web servers e a popularização da Internet. como C.importância fundamental na difusão da linguagem Herança do C++ e Smalltalk . 44 . A Sun desenvolveu um conjunto de bibliotecas para Java bem completo e que definiu como implementação básica da linguagem. O fascínio causado pelos primeiros applets foi fator de conquista de adeptos em toda a Internet. braço da companhia Sun na época e responsável pelo desenvolvimento do software básico dos equipamentos Sun e que atuava também na área de desenvolvimento de compiladores para outras linguagens.orientação a objetos Aplicações Internet Applets e Applications Ambiente destino: Java Machine A linguagem Java foi concebida e desenvolvida inteiramente pela SunSoft.Java é constantemente aprimorada Aprimoramento de Java não significa suprir deficiências. mas acrescentar potencialidades cuja necessidade é sentida quando se deseja programar para a Internet. O suporte oferecido desde o início pela Netscape em seus browsers foi decisivo para a divulgação e difusão de Java. Java ocupou um espaço que estava vazio. Java herdou a fidelidade do Smalltalk aos conceitos de Programação Orientada a Objetos (OOP). A Sun estimula este tipo de atividade e sabe que dele depende o crescimento da linguagem. o esforço de grupos de usuários e de comunidades baseadas no código aberto enriquecem o uso da linguagem constantemente.

Orientada a Web Preenche uma lacuna existente para criação de aplicações Web. safe and secure Orientada a objetos Implementa os principais conceitos da orientação a objetos. Formato semelhante ao C++ O formato da linguagem semelhante ao C++ é fator importante no reaproveitamento de profissionais de desenvolvimento. pois elimina grande fonte de erros. 45 . Pode gerar alguma dificuldade na criação de rotinas que utilizariam (em C) aritmética de ponteiros. as diferenças devem ser cuidadosamente estudadas pois são significativas. A capacidade da linguagem de fazer um gerenciamento preemptivo deste recurso otimiza e torna geral o seu uso. Multithread A facilidade de programar multithreads habilita Java para o desenvolvimento de grandes aplicações e de IU poderosas. No entanto.CARACTERÍSTICAS DA LINGUAGEM     Totalmente orientada a objetos Multithread (paralelização de processos) Sintaticamente e morfologicamente quase idêntica ao C++ (existem diferenças fundamentais) Ausência de ponteiros • •    redução de bugs aumento da segurança Independente da plataforma Orientada à aplicações de rede (especialmente Web) Quatro S’s : small. Ausência de ponteiros Aumenta a produtividade dos profissionais de desenvolvimento. simple. e disto decorre sua característica multiplataforma.

que é interpretado e executado em diferentes plataformas JAVA VIRTUAL MACHINE Denominação dada ao interpretador Java rodando sobre o sistema operacional de qualquer máquina. caracteriza-se como uma máquina virtual que executa seu código binário Java.CAPÍTULO 6: JAVA MACHINE JAVA VIRTUAL MACHINE Código fonte é compilado para código binário Java. chamados também de bytecodes. Dessa forma. 46 . Esta combinação (interpretador+OS) tem um comportamento idêntico para qualquer OS suportado por Java. COMPILADORES E INTERPRETADORES Java Virtual Machine é um conceito implementado hoje por um conjunto razoável de interpretadores para as plataformas mais comuns.

Verifica-se que existe uma série de compiladores Java para cada plataforma distinta. Cache: código de maquina interpretado é armazenado em “cache” . Possibilidade de uso de código nativo. mas no entanto existe também um único compilador Java. Parâmetros extras: informações relativas à máquina onde o código esta sendo interpretado podem acelerar este processo. ou seja. Acelera execução de loops.    47 . Existem tradutores para C. evitando a repetição da interpretação de partes repetitivas do código. A parte do interpretador que “interage” com o OS varia em simplicidade conforme o ambiente. O Java Runtime Environment (JRE) é um interpretador Java que suporta a execução de aplicações Java em desktops. Informação extra pode ser passada ao interpretador. ARQUITETURA JAVA Os bytecodes Java são destinados a uma máquina de estrutura simples e poderosa. escrito em Java. Dentre estes podemos citar:  Compilação “just-in-time”: código é compilado para código nativo a medida que é carregado por download. Uso de “pedaços” de código nativo dentro do código Java. no tocante a parte que “interage” com o código Java. os bytecodes “ajudam” o interpretador sob determinada plataforma. isto resulta em um interpretador simples e reduzido. exige-se apenas interpretadores distintos.técnica usada em aplicações que trafegam pela rede.       Interpretador Java segue modelo simples e estruturado permitindo grande desempenho. utilizado em todas as plataformas. “TURBINANDO” O INTERPRETADOR Uma série de artifícios são utilizados para melhorar a performance de um código Java. Causa perda da característica multiplataforma de uma aplicação que utiliza este recurso. Para programas bem estruturados o ganho de velocidade de execução pode ser de 10 vezes. Assim. para se sustentar o conceito de Java Virtual Machine. “Compilação ‘just-in-time’” “Cache” de execução.

A utilização de código nativo em programas Java vincula a sua exceção às plataformas para as quais o código nativo foi construído.VANTAGENS      Multiplataforma Compatibilidade Portabilidade Verificação da segurança do código Toda máquina pode ser Java Virtual por software Além das vantagens clássicas de utilizar um interpretador Java (compatibilidade. multiplataforma. O interpretador Java sempre precisa estar instalado na máquina. portabilidade. cuja origem pode eventualmente ser ignorada. Assim. Pode também limitar a ação de objetos não corretamente identificados e delimitados criados por programadores experientes . o que dificulta a execução dos programas de desktop nos sistemas operacionais que não vêm originariamente com o interpretador instalado. etc. Isto significa que o interpretador realiza rigorosa verificação a fim de certificarse que o programa Java é confiável em termos de utilização dos recursos da máquina. esta característica significa um nível a mais de segurança oferecido ao usuário de aplicações Java. pelo interpretador.plataforma específica A interpretação dos bytecodes.queda de desempenho Duas ferramentas: compilador e interpretador Código nativo .cuja atuação pode significar riscos para o usuário. O interpretador é capaz de verificar se um programa está “mal intencionado” alocando recursos excessivos ou indevidos e bloqueá-lo. O interpretador pode bloquear também o acesso ao disco local de programas carregados via Internet. da “confiabilidade” do programa sendo executado. por mais que se seja otimizada. No entanto. tem um custo de performance.) um outro ponto deve ser considerado como positivo: a verificação. o crescente desenvolvimento do hardware e os benefícios de segurança trazidos pela interpretação compensam esse custo adicional. 48 . DESVANTAGENS    Interpretação .

O Garbage Collector implementado em Java é eficiente e seguro.ARQUITETURA JAVA MACHINE     Conjunto de instruções • Bytecodes em geral com 2 operandos e 32 bits Conjunto de registradores (apenas 5) Pilha ilimitada mas “imune” a overflow Garbage Collector • • roda em background compressão de memória A ARQUITETURA DA MÁQUINA JAVA A máquina Java é ao mesmo tempo simples e poderosa. JAVA E SUAS EDIÇÕES 49 . O conjunto de registradores extras é bem reduzido e o controle da pilha é rigoroso. e está se aprimorando a cada nova versão da linguagem. Simples porque os bytecodes são de tamanho fixo (32 bits) e poderosa porque é uma stack-machine. cuja performance tende a ser alta.

etc. 50 .Java 2 Standard Edition É a edição de Java feita para rodar em desktops. Oferece um conjunto completo de bibliotecas que implementam as rigorosas necessidades de um ambiente de execução seguro e crítico. eletrodomésticos. Está disponível em uma série de sub-edições. etc).) e máquinas de controle em tempo real (robôs de precisão. que pode ser utilizada em qualquer computador que irá apenas executar os programas Java. cada uma mais adequada a um determinado tipo de dispositivo. tais como celulares e palms. Java 2 Micro Edition É a edição para rodar em dispositivos de pequeno porte. servodispositivos. dispositivos embarcados (robôs. O JRE (Java Runtime Environment) é a maquina virtual sem as ferramentas de compilação. Java 2 Enterprise Edition É a edição com todo o suporte para rodar aplicações em servidores web e servidores de aplicação.

pois apresenta recursos pobres. um kit de desenvolvimento que. NetBeans e Outros) Proprietários (JBuilder da Borland. Distribuída livremente e desenvolvida pela Sun. é de difícil uso e não satisfaz as necessidades de um desenvolvedor de médio porte ou maior. outras empresas. o Java Development Kit (JDK) Existe um grande conjunto de ferramentas de desenvolvimento disponíveis no mercado – – Livres (Eclipse. embora bem poderoso. Ao longo do tempo. dispõe de um conjunto mínimo de recursos suficientes para gerar qualquer aplicação. JDev da Oracle e Outros) A Sun lançou. JAVA DEVELOPMENT KIT O Java Development Kit é a primeira ferramenta para desenvolvimento de Java. Hoje existem dezenas de ferramentas de código livre e uma outra dezena de boas ferramentas proprietárias. Studios da IBM. ou grupos/comunidades de usuários desenvolveram outras ferramentas.CAPÍTULO 7: AMBIENTE DE DESENVOLVIMENTO   A Sun lançou juntamente com a linguagem um kit de desenvolvimento. 51 . BEA e Sun. juntamente com a linguagem.

sun.com (siga o link de downloads) Faça o download da ultima versão do binário do Eclipse no site http://www. faça o download e instale a última versão do JDK no site http://java. CRIANDO UM PROJETO     Cada programa Java pode ser composto por várias classes. ele pede que seja indicado um diretório de trabalho (workspace). INSTALAÇÃO Se não estiver instalado na máquina.1win32\eclipse\eclipse. por exemplo) EXECUÇÃO DO ECLIPSE Para rodar o Eclipse basta apenas executar o arquivo C:\soft\eclipse-SDK-3.eclipse..ECLIPSE • • • • Ferramenta de edição.. A grande vantagem do Eclipse é a sua arquitetura de plugins. onde ficarão os arquivos Java editados nele. Menu File >> New >> Project. basta apenas descomprimir o arquivo de download do Eclipse num diretório qualquer (C:\soft. compilação.1.exe Sempre que o Eclipse for aberto.org Na máquina. que permite que possa ter seus recursos expandidos indefinidamente.eclipse. Essas classes e as suas configurações ficam agrupados num PROJETO. Criação de um projeto Selecionar Java Project Acrescentar o nome do projeto Selecionar Wizard “java Project” e completar com o nome do projeto 52 . depuração e execução de programas Java Código aberto Extensível por plugins http://www. sem pagamento de licenças.org O Eclipse é uma ferramenta de desenvolvimento de aplicações Java que pode ser utilizada livremente.

PERPECTIVAS   O Eclipse trabalha com perspectivas. >> Class public static void main(String[] args) Criar uma nova classe Atribuir um nome e solicitar a criação do método main Acrescentando uma classe  Adicionar a seguinte linha de código ao método main System. Selecionar classe Java e com o botão direito do mouse escolher Debug as >> Java Application. (o Eclipse pedirá para você mudar a perspectiva para Debug. Adicionar código ao método main EXECUTANDO UM PROGRAMA  Rodar o programa • Selecionar o arquivo Java e com o botão direito do mouse escolher Run As >> Java Application (o Eclipse pedirá para você salvar o arquivo. mas não é necessário fazer isso neste exemplo)  Executar linha a linha com a tecla F6 Disparar o depurador 53 . que nada mais são do que visões de seu ambiente de trabalho.out.. Abrir a Perspectiva Java para editar código Abrir a perspectiva Java ACRESCENTANDO UMA CLASSE   Criar uma nova classe e adicionar ao projeto No Wizard definir o nome da classe e marcar para criar o método Menu File >> New....println(“Hello Word”). selecione-o e salve-o) Selecionar o projeto e disparar a execução como Java Application DEPURANDO UM PROGRAMA   A depuração é um recurso necessário para dar produtividade a qualquer desenvolvimento.

..4 ou 5..0) 54 . Se não estiver instalada a versão desejada clicar em – – Add.4 ou 5. (e selecionar o folder onde está instalado o JDK ou JRE) Abrir a configuração do Eclipse Selecionar o nível de compatibilidade do compilador (1. 1.DEPURANDO UM PROGRAMA     Para observar o valor de uma variável coloque o ponteiro do mouse sobre ela Ou mude a perspectiva para Debug (todas as variáveis podem ser inspecionadas nessa perspectiva) Menu Window >> Open Perspective >> Debug Para voltar para o programa Java e a execução do depurador linha a linha mudar a perspectiva pra Java Menu Window >> Open Perspective >> Java Mudando a perspectiva para Debug MUDANDO A VERSÃO DO JDK   No Eclipse pode-se trabalhar com várias versões do JDK ou JRE Menu Window >> Preferences • • No item Java/Compiler selecionar a compatibilidade do compilador com a versão do Java (compiler compliance level 1. 1.3.3.. Browse.0) No item Java/ Installed JREs selecionar a versão do JDK ou JRE.

java que depois de compilado gera o arquivo HelloWorld.class 55 . O nome do arquivo principal do programa deve ter o mesmo nome que a classe principal (aquela que contém o método main()) O método de partida de um programa Java é chamado de main. O método main() de partida do execução do programa deve pertencer à classe principal do programa. que deve necessariamente pertencer a uma classe.CAPÍTULO 8: ESTRUTURA DE UM PROGRAMA JAVA REQUISITOS BÁSICOS    Um programa Java é uma coleção de classes que interagem entre si de forma totalmente orientada a objetos. é a classe que dá nome ao programa. Esta classe (a qual pertence main). REQUISITOS BÁSICOS – EXEMPLO   A assinatura de main() deve ser como a mostrada acima O nome do arquivo deve ser HelloWorld.

4E_38 -1.147.7E+308 Faixa de valores dos tipos primitivos 56 .648 a 2.147.807 -3.808 a 9.854.7E-308 a 1.775.372.Exercícios 1 – Digitar.767 -2.854.036.4E-38 a 3. compilar. e depurar o programa HelloWord no Eclipse TIPOS BÁSICOS  Tipos primitivos • Inteiro: – – – – • – – • •    byte short int long float double byte short int long float 8 bits 16 bits 32 bits 64 bits 32 bits Ponto-flutuante double 64 bits caracter (unicode) – char 16 bits boleano – boolean true ou false São tipos primitivos Não são objetos Independem da máquina em termos de precisão e tamanho -128 a 127 -32.768 a 32.647 -9.223.223.036.372.483.775.483.

de forma mais precisa e clara do que um array de caracteres System .println(……). • curso=“Meu primeiro”+curso. é interessante citar duas:  String • • • Não são arrays de caracteres. System • • contém maioria dos métodos que interagem com o sistema operacional Ex. Ex.realiza parte da interação do programa com o sistema operacional nativo Algumas classes em Java assumem um papel especial ou apresentam um comportamento especial. Um objeto da classe String é criado automaticamente quando declara e inicializa uma variável.out.implementa um objeto String. 57 . •  curso+=“Meu primeiro”.CLASSES BÁSICAS  Classes especiais • • String . Ex. Dentre estas. String curso=“curso de Java”. Implementam concatenação (embora Java não implemente sobrecarga de operadores). Uso do operador +=. Dispõe de métodos que facilitam seu uso. System.

VARIÁVEIS     Declaradas antes de serem utilizadas. em qualquer parte do programa (declaração é dar o tipo e o nome) Podem ser inicializadas na declaração Variáveis locais devem ser inicializadas antes de serem utilizadas Podem ser utilizados sufixos para definir o tipo de um literal As variáveis em Java podem ser declaradas em praticamente qualquer parte do programa. a funções ou blocos As restrições aplicadas às variáveis são: Nomes das variáveis:    Não podem começar por número Cuidado com símbolos que representam operadores: *. as variáveis mais “externas” deste programa pertencem a esta classe. etc… Conjunto de caracteres Unicode (existem exceções)  Tipos:    Primitivos Classe ou interface Array  Sufixos    L ou l para long D ou d para double F ou f para float 58 . Uma vez que todo o programa está encapsulado dentro de classes. Existem portanto dois tipos de variáveis:    De classe ou de instância Locais. Lembrar que não existem variáveis globais. +.

double d = 395E+45.756F. int i = (int)l. float f = (float)d. • Explícita: de tipos “maiores” para tipos “menores” (em números de bits do tipo). Deve ser feito casting. CONVERSÃO DE TIPOS • Implícita: de tipos “menores” para tipos “maiores” (em números de bits do tipo) byte b = 5. VARIÁVEIS LOCAIS Podem ser utilizadas dentro do método ou bloco onde foram declaradas • Podem ser utilizadas dentro da classe ou objeto. Os literais. 59 . // 5 é convertido para inteiro float f = 123. int a = b. dependendo de sua acessibilidade. quando digitados na notação octal devem vir precedidos de 0. long l = 12000000L. quando digitados na notação hexadecimal devem vir precedidos de 0X ou 0x. ou até mesmo por outras classes e objetos.DECLARAÇÃO E INICIALIZAÇÃO Os literais. double d = f.

pois uma mesma expressão lógica pode afetar de forma diferente o resultado esperado. . resto da divisão inteira) O sinal menos ( . que é definir junto ao valor original. / (divisão) e % (módulo. o tipo para o qual se quer a conversão. ou seja. . entre parênteses.(subtração). 60 . porque a capacidade do tipo convertido é menor. Para fazer essa conversão basta fazer a atribuição direta dos valores. Portanto 26/7=3.. porque a capacidade do tipo convertido é maior que a capacidade do tipo original. uma vez que o resultado é inteiro OPERADORES CONJUGADOS COM ATRIBUIÇÃO DE VALORES a+=b <=> a-=b a/=b <=> <=> a*=b <=> a=a+b a=a-b a=a*b a=a/b Cuidado com a ordem de avaliação das expressão. Conversão explícita é aquela onde o valor do tipo original corre o risco de ser alterado. *.) pode ser usado como operador unário a=a+b a=a-b a=a*b a=a/b Operadores conjugados com atribuição de valores a+=b <=> a-=b <=> a*=b <=> a/=b <=>  Cuidado com a ordem de avaliação das expressão ! OPERADORES ARITMÉTICOS    Básicos: + (adição).) pode ser usado como operador unário Tipo do resultado: o mais preciso entre os tipos dos operandos.Conversão implícita é aquela onde o valor não corre o risco de sofrer alguma perda. * (multiplicação). / e % O sinal menos ( . Conversões explícitas somente podem ser feitas com o uso do casting. OPERADORES E EXPRESSÕES  Operadores aritméticos • •  Básicos + .

// resulta em b com valor 5.ou --a <=> <=> a=a+1 a=a-1 Cuidado.OPERADORES DE INCREMENTO E DECREMENTO a++ ou ++a a-. b = ++a. quando colocado antes da variável. faz com que a o valor da variável seja utilizado antes do incremento. b=a++ não fornece o mesmo resultado que b=++a !!! O operador de incremento. e entre | e || !!! Os operadores && e || somente podem ser aplicados a tipos booleanos. int b = a++. O operador de incremento quando colocado depois. a = 5. OPERADORES DE COMPARAÇÃO == != < > <= >= igual diferente menor maior menor ou igual maior ou igual OPERADORES LÓGICOS & ou && <=> | ou || ! <=> <=> AND OR NOT Existem diferenças entre & e &&. faz com que ela seja incrementada antes de ser utilizada. sendo que nesse caso ele realiza a operação bit a bit entre os bits dos operandos. Os operadores & e | podem ser aplicados a qualquer tipo primitivo. int a = 5. OPERADORES BIT A BIT & | ^ <=> <=> <=> AND OR XOR 61 . // resulta em b com valor 6.

<< >> ~ >>> <=> <=> deslocamento à esquerda deslocamento à direita <=> <=> complemento desl. O uso do else é opcional. switch(expressao) { case valor: // bloco de código break. à direita. preenchimento com zero COMANDOS BÁSICOS COMENTÁRIOS   Comentários de uma linha Comentários de múltiplas linhas // linha comentada /* Linhas comentadas linhas comentadas */  Comentários que aparecem na geração automática de código (javadoc) /**Linhas comentadas linhas comentadas */ CONDICIONAIS if (condição) { // bloco de código } else { // bloco de código }  Comando if else • • • A condição sempre deve ser um literal. // outros cases default: // bloco de código }  Comando switch 62 . não são necessárias as chaves. Quando o bloco de código possuir apenas uma linha. variável ou expressão booleana (incluem-se aí também os retornos de métodos).

IMPORTAR PARA O ARQUIVO FONTE AS CLASSES OU PACOTES INDICADOS import <classe ou pacote>. • • • LAÇOS while(condição) { // bloco de código } do { // bloco de código } while (condição). A importação de arquivos ou pacotes deve ser feita sempre no início do arquivo Java. No caso de nenhum case ser igual a expressão. 63 . i++. O break não é obrigatório. } do { .. Nesse caso a execução do programa prossegue para o próximo bloco de código. short e char). O valor deve ser sempre um literal inteiro. i++. } while (i<10). O default não é obrigatório.  Comandos while e do while • • A condição sempre deve ser um literal. Exemplos: while(i<2) { ...• A expressão deve ser uma variável ou expressão que resulte num número inteiro ou num número que possa ser convertido para inteiro (byte. nenhum código é executado.. Quando o bloco de código possuir apenas uma linha. não são necessárias as chaves. variável ou expressão booleana (incluem-se ai também os retornos de métodos).

 Programa para testar parâmetros de entrada public class TesteParametro { public static void main(String[] args) { for(int i=0. O parâmetro String[] do main é que recebe os valores passados pela linha de comando. INTERROMPE A EXECUÇÃO DE UM BLOCO INDICADO break [label]. Caso o label seja especificado. esses comandos interrompem o laço identificado pelo label. com relação aos laços. o bloco mais interno e próximo do break que é o interrompido.println(args[i]). Como a definição desse label é opcional. i< args.length. FORÇAR A PRÓXIMA ITERAÇÃO DO LAÇO INDICADO continue [label]. na sua ausência. O break somente pode interromper bloco que o englobem. O mesmo vale para o continue. i++) { System. PARÂMETROS DE ENTRADA Um programa de linha de comando pode receber parâmetros pela própria linha de comando. } } } PACOTES      Define o nome completo da classe (“fully qualified name class”) Uso da palavra reservada package Primeira linha “útil” do programa Uma outro arquivo fonte referencia uma classe pelo seu nome completo ou com o uso de import O import também pode importar atributos estáticos de classes 64 . A definição do pacote deve sempre ser feito antes da definição de qualquer classe ou interface no arquivo Java.out.DEFINIR O PACOTE AO QUAL PERTENCE A CLASSE SENDO DEFINIDA package <nome do pacote>.

No entanto..com. Num arquivo fonte qualquer.util.empresa. Date dt = new Date().Date dt = new java.Date. do Java.lang. está no pacote java.util.util. import java.NomeClasse 65 . tem o nome completo br.lang é automaticamente importado por todos os arquivos fontes.} Essa classe. A classe Date.nomepacote. O nome completo de uma classe compreende o nome do pacote ao qual ela pertence junto com nome com o qual ela foi declarada. . portanto seu nome completo é java.Date. o pacote java. portanto o nome completo dessa classe é java.PI..nomepacote. por exemplo. // importa todas as classes do pacote . Date dt = new Date(). está no pacote java.String.util. A classe String.lang..util. A definição do pacote ao qual pertence uma classe é feita usando package br. Ou java. para se utilizar a classe Date ou importamos o pacote no início do fonte ou a referenciamos pelo seu nome completo.empresa.com. do Java.Math. Ou import java.. import java.lang.*.util... public class NomeClasse {.Date().

66 . Classes são definidas a fim de que a partir delas possam ser gerados os objetos que assumem aquelas propriedades e executam aquela funcionalidade definida na classe. Podem existir portanto vários objetos de uma única classe. Classes são definições genéricas de objetos (moldes de objetos).variáveis e métodos • variáveis e métodos internos podem não ser visíveis externamente • classes podem ser definidas de forma incremental (herança) Para que serve ?    Metodologia eficiente Programas grandes e desenvolvidos por equipes Grande índice de reaproveitamento do código CLASSES E OBJETOS   Objetos são entes Classes são definições Objetos são modelados como os objetos do mundo real. possuem existência “física” dentro de um programa. ou seja. ocupando espaço de memória e armazenando as informações pertinentes.CAPÍTULO 9: CLASSES E OBJETOS PROGRAMAÇÃO ORIENTADA A OBJETOS O QUE É ?   Unidades de código que interagem são os objetos Classes • atributos e comportamento .

Portanto. uma classe é definida por seus atributos (variáveis) e comportamento (métodos ou funções). fatores externos à classe não podem afetá-la. Partir de classes mais genéricas . Definir claramente que elementos compõem a interface .Importante   Definir cuidadosamente uma classe levando-se em conta aspectos de funcionalidade. Nomenclatura de linguagem: classes são definidas e objetos são instanciados (ou seja. Este encapsulamento é utilizado com uma 67 . todo objeto criado ocupa espaço no seu programa ou na máquina rodando o programa. Assim. além do permitido por ela.torna mais lógico o encapsulamento. • • CONCEITO DE CLASSE Conceito de classe Uma classe contém uma definição de um conjunto de variáveis e funções que são encapsuladas conjuntamente e compartilham o mesmo escopo de definições. generalidade e acessibilidade Nomenclatura: classes definidas e objetos instanciados (ou seja. um objeto é uma instância de uma dada classe). Estas características permitem que a classe assuma em papel dentro de um programa unicamente em termos de suas propriedades.permite que outros usem seus objetos de forma simples e correta. um objeto é uma instância de uma dada classe) • • • • Definir funcionalmente as classes .facilita reaproveitamento do código ao mesmo tempo que define o alcance da classe. ou seja. Considerar aspectos de segurança na definição da acessibilidade da classe. e deve-se evitar criar objetos não utilizados. Ter em mente que as classes são definidas e os objetos declarados.

série de benefícios em relação ao conceito convencional de programação não orientada a objetos. ou como suas propriedades se relacionam. como com o mundo exterior. “todo” o comportamento desejado da classe. Interface: são métodos ou variáveis visíveis ao mundo exterior ao objeto. Métodos: são locais ao objeto e implementam o conceito de comportamento do objeto. ATRIBUTOS. tanto entre si. por definição. ou que devem ser implementados por subclasses Interfaces  Mais segurança se implementada apenas com métodos 68 . A figura a seguir ilustra esse conceito. inclusive aqueles ainda não implementados. MÉTODOS E INTERFACES  Métodos: comportamento do objeto <Modificadores> <tipo de retorno> <nome do método>(<lista de parâmetros>) { //blocos de comandos }  Interface: métodos ou variáveis visíveis ao mundo exterior Variáveis: são locais ao objeto e implementam o conceito de atributos ou propriedades de um objeto. É a parte do objeto que interage com os outros objetos de um programa REGRAS GERAIS    Atributos: • clareza Métodos • abrangência Interfaces • Atributos:   Claras e significativas com respeito às propriedades que representam Podem ser outras classes segurança Métodos  Deve abranger. Toda classe é definida em termos de sua interface e sua implementação.

  Verificação de parâmetros de entrada Mínima. por exemplo) Deve ter o mesmo nome da classe. não possui valor de retorno e podem existir em qualquer número para uma mesma classe (diferem pelo número de argumentos)   MÉTODO ABSTRATO  Método declarado mas não definido. Deve-se buscar o compromisso ideal entre estas características. MÉTODOS ESPECIAIS  Construtor • •   • • inicializa o objeto deve ter o mesmo nome da classe Método declarado mas não definido Finaliza objeto Métodos Abstratos Destrutor CONSTRUTOR  Método que inicializa o objeto. É o primeiro método chamado quando o objeto é criado (instanciado) e somente pode ser chamado nesta situação Usado para inicializar atributos do objeto e executar os métodos de inicialização (abrir um arquivo. mas funcional. 69 . usado para forçar a implementação de um comportamento desejado nas subclasses que herdarem este método DESTRUTOR  Finaliza objeto. Em Java não pode ser invocado diretamente. É invocado na dealocação do objeto. Chama-se finalize e tem o mesmo nome pra todos as classes. “limpa” variáveis e libera recursos.

saida. this. saida = new Biometrica (). int peso. os objetos não estão ainda instanciados. idade. mas apenas nomeados. idade. } }  Instanciação de objetos 70 . }    Declaração do objeto Instanciação do objeto Biometrica entrada. que invoca um construtor da classe. peso.idade = idade. o construtor default foi utilizado. public Biometrica (int altura. Declaração da classe A classe Biometrica possui três atributos públicos. entrada = new Biometrica (). Instanciação de objetos Os objetos sempre são instanciados pelo operador new. Na declaração. int idade) { this. Ele é um construtor que não recebe argumento nenhum. this. CONSTRUTORES E INSTANCIAÇÃO  Definir um construtor mais útil public class Biometrica { public int altura.peso = peso. O construtor default é definido implicitamente a todas as classes que não possuem construtor definido. peso.DEFINIÇÃO DE UMA CLASSE E ALOCAÇÃO  Declaração da classe public class Biometrica { public int altura.altura = altura. Declaração do objeto A declaração do objeto nada mais é do declarar as variáveis que apontarão para as instâncias. Nesse exemplo.

dentro de uma classe. 42. REFERÊNCIAS A OBJETOS Declaração de recebem outra instâncias objetos que entrada = new Biometrica (120. desde que difiram entre si na lista de argumentos que recebem. Assim. Objetos declarados (mas não instanciados) podem ser atribuídas a objetos instanciados. 15).entrada = new Biometrica (120. 34. 12). 34. Construtores podem ser definidos em qualquer número. tem-se duas referências para o mesmo objeto.altura refere-se ao atributo altura da classe. aux1. 12).peso = 35. enquanto a variável local altura não é referenciada por ela. Quando não possuir tipo de retorno deve ser utilizada a palavra chave void. refere-se à instância corrente dessa classe. Qualquer alteração feita através de qualquer referência afeta o objeto em questão. Nesse caso. 42. Biometrica aux1 = entrada. A palavra reservada this. saida = new Biometrica (134. this. saida = new Biometrica (134. 15). public void incrementarIdade() { 71 . DECLARAÇÃO DE MÉTODOS  Métodos são funções internas à classe Um método é uma função definida dentro de uma classe e que implementa um comportamento desta classe.

além da acessibilidade.idade++.para atributos privados Os métodos são especificados com seus tipos de retorno e lista de argumentos. O diagrama de classes é um dos mais utilizados.this. outro com os seus atributos e um terceiro com os seus métodos ou construtores.altura += aumento. public void acrescentarAltura(int aumento) { this. } NOTAÇÃO UML    UML: Unified Modeling Language Padrão para especificação de sistemas orientado a objetos Classe Nome da classe Atributos Métodos / Construtores A notação UML é um padrão utilizado amplamente para especificar sistemas orientados a objetos. Os atributos são especificados com seus tipos e sua acessibilidade: + para acesso público . } Os argumentos de um método devem ser definidos pelos seus tipos. 72 . como os atributos. A notação para especificar uma classe é um retângulo que possui três regiões: um com o nome da classe.

int d) {. } public void setPeso(int peso. um conjunto de métodos chamados soma pode ser definido para executar a soma entre inteiros. e o emprego do mesmo nome facilita a programação e a leitura do código. A identificação de qual método foi invocado é feita pelos argumentos. 5).} 73 . int dy) { this. this. int b. this. int redutor) { this. int c. dx=x2-x1. int y2) { x=x1. y=y1.. } Tipo de retorno não diferenciam métodos int calc(int a.peso = peso.setPeso(55). int x2. int c. } void resize(int x1. dy=y2-y1. this.setPeso(48.dx=dx. int dx. int d) {.  Métodos com mesmo nome mas lista de argumentos diferentes public void setPeso(int peso) { this. floats e strings.setPeso(peso – redutor).. Isto se torna muito útil quando empregado para prover o “mesmo” comportament o para conjunto de parâmetros diferentes. entrada. int b.x=x.dy=dy.} float calc(int a. int y1.  Métodos com mesma assinatura causam erro de compilação void resize(int x. Métodos sobrecarregados devem possuir listas de argumentos diferentes em quantidade e ou tipos. } Invocação dos diferentes métodos entrada. int y.SOBRECARGA DE MÉTODOS Definição de múltiplos métodos com o mesmo nome mas tipos de parâmetros diferentes Polimorfismo de métodos ou sobrecarga de métodos permite que métodos com o mesmo nome sejam implementados de forma diferente. Por exemplo.y=y.

. A invocação de um construtor dentro de outro utiliza a notação this(. 17). altura – 110. Da mesma forma que métodos. pela lista de argumentos. pela lista de argumentos passados é identificado o construtor invocado.. 21). 74 . int idade) { this(altura. idade). int peso. Construtores sobrecarregados devem possuir listas de argumentos diferentes em quantidade e ou tipos. A identificação de qual construtor foi invocado é feita pelos argumentos. A diferenciação ocorre da mesma forma.idade = idade. mas com nomes diferentes não são sobrecarregados e geram um erro de compilação.). saida = new Biometrica(180. CUIDADO: os nomes dos argumentos não diferenciam um construtor do outro. construtores também podem ser sobrecarregados. portanto dois construtores com lista de argumentos em igual número e tipos.peso = peso. SOBRECARGA DE CONSTRUTORES  Construtores com lista de argumentos diferentes public Biometrica(int altura. portanto dois métodos com lista de argumentos em igual número e tipos. this. } public Biometrica(int altura. mas com nomes diferentes não são sobrecarregados e geram um erro de compilação. this.altura = altura. 49. int idade) { this.CUIDADO: os nomes dos argumentos não diferenciam um método do outro. onde. }  Invocação dos diferentes construtores entrada = new Biometrica(155.

quando for tratado o tema Polimorfismo. Uma classe abstrata serve para estabelecer uma interface cuja subclasses. uma vez que “falta” parte de sua implementação. ficará claro a vantagem do uso de classes abstratas. Nos capítulos seguintes. em contraposição aos atributos e métodos de instância. ATRIBUTOS E MÉTODOS ESTÁTICOS    Atributos e métodos de classe Alocação na classe Compartilhados entre todos os objetos da classe Atributos e métodos estáticos são também chamados de atributos ou métodos de classe. se precisarem ser instanciadas.CLASSES E MÉTODOS ABSTRATOS    Métodos abstratos são aqueles que não possuem implementação Uma classe com apenas um método abstrato não pode ser instanciada e é também chamada de classe abstrata Pertence a interface da classe. que assumem um valor para cada instância (objeto). 75 . impondo um contrato para as subclasses (no próximo capítulo isso será estudado) Classes abstratas não podem ser instanciadas. necessariamente terão que implementar.

outras classes e objetos também utilizam a sua única alocação em memória.html de “J2SE(TM) Development Kit 76 . e permanecem alocados enquanto a classe estiver carregada.com Procurar pelo download Documentation” Abaixar o arquivo comprimido Descomprimir num diretório e abrir o index. API JAVA     A documentação de todas as classes Java que vem junto com a JVM deve ser abaixada separadamente no site java.São alocados uma única vez em memória.sun. Um atributo estático é compartilhado entre todos os objetos da classe. Se o atributo for público.

• Tamanho int l = arrVal. Isso pode ser feito numa mesma linha: Data[] vencimentos =new Data[10]. “formam”. Data[] vencimentos. int arrVal[]. os casos de referência a índices não existentes não podem ocorrer. “a”. “frase”). 5.“Estas”. Assim. que dá o tamanho o array. int[] intervalos = {2. int[] arrVal.CAPÍTULO 10: ARRAYS E STRING  Arrays • Declaração String palavras[]. pode ser indexado de 0 a N-1. 2005). // x recebe 2 int y = intervalos[3]. Assim. vencimentos =new Data[10]. Isso garante uma forma segura. Data vencimentos[]. No caso de array de objetos convém notar que a instanciação do array não instancia os objetos que ele pode conter. Em Java um array é delimitado na sua instanciação. String s = frase[2]. 6}. Ele precisa ser declarado e instanciado. direta e simples de uso de arrays. int x = intervalos[0].length. • Acesso arrVal[0]=23. vencimento[8] = new Data(23. “palavras”. ou • Instanciação do Array arrVal=new int[200]. // ERRO! //Array de 3 elementos tem //índices de 0 a 2 Arrays podem ser de tipos primitivos ou de objetos. String*+ frase = . Esse “objeto” array tem um único atributo já pré-definido chamado length. um array de N elementos. 4. ou ou String[] palavras. 77 . Um array é muito semelhante a um objeto em Java. Os índices dos arrays sempre se iniciam em 0.

Expressões do tipo vctos[1]. mascara = new byte[5]. mascara[2] = 5. e todos valores alocados são inicializados com null. vctos[1] = vctos[2]. byte[] aux = mascara. Um array de tipos primitivos. Um array. Mais de uma referência podem apontar para o mesmo array.setDia(23).setDia(23) servem para acessar os objetos de cada posição do array. vctos = new Data[3]. apenas reserva uma referência que pode apontar para um “objeto” array. 3. ao ser instanciado. mascara e aux apontam para o mesmo array. mascara é apenas uma referência. vctos[1]. 2004).ALOCAÇÃO DE ARRAYS  Array de tipos primitivos byte[] mascara. 12. ao ser instanciado. No exemplo. vctos[2] = new Data(10. e todos valores alocados são inicializados com 0. 78 . Cada elemento do array precisa ser instanciado individualmente e comporta-se como uma referência para o objeto alocado para ele. 2003). Arrays de objetos Um array de objetos. tem o seu espaço alocado em memória. assim como ocorrem para referências de objetos.  Data[] vctos. vctos[0] = new Data(2. No exemplo. aux[0] = 7. tem o seu espaço alocado em memória. ao ser declarado.

 Arrays de dimensões heterogêneas int[][] amostras = new int[3][]. para cada posição da primeira dimensão devem ser alocadas as demais dimensões. As dimensões podem ser obtidas separadamente: matriz. passando-se as duas dimensões. amostras[2] = new int[2]. amostras[0] = new int[3]. matriz[0][2] = 67. amostras[0] = new int[3]. as demais são deixadas sem valor. cubo[2][5][1] = new Ponto(34. amostras[1][2] = 31. Arrays com dimensões heterogêneas precisam ter cada dimensão alocada separadamente. amostras[1] = new int[4]. E depois.ARRAYS MULTIDIMENSIONAIS  Arrays de dimensões homogêneas int[][] matriz = new int[5][3]. Na instanciação da primeira dimensão. int[][] amostras = new int[3][]. amostras[2] = new int[2]. amostras[1] = new int[4].lenght resulta em 5 e matriz[0]. 79 . Arrays multidimensionais com dimensões homogêneas podem ser instanciados numa única linha de comando. amostras[0][1] = 56. amostras[2][1] = 15.length resulta em 3. int[][] matriz = new int[5][3]. 65). Ponto[][][] cubo = new Ponto[3][6][2].

evitando a múltipla instanciação de Strings iguais.   Strings são sempre constantes Strings devem ser comparadas como objetos (usar método Equals da classe String) str1. • Concatenação s = “um outro” + “ teste”. Essa operação de concatenação gera uma outra String. Isso só é possível porque Strings são constantes. da própria classe.STRING   String é uma classe. não um tipo primitivo String tem alguns comportamentos especiais. ou seja. O operador == ao ser aplicado sobre Strings compara as referências e não os conteúdos. típicos de tipos primitivos • Instanciação é semelhante a inicialização String s = “teste”. Strings podem ser concatenadas com o operador +. Esse método compara caractere a caractere duas Strings. um objeto é criado em memória. Strings devem ser comparadas através do método Equals. Uma String pode ser instanciada da mesma forma que um tipo primitivo é inicializado. isso porque a Java Virtual Machine procura compartilhar as Strings iguais. Muitas vezes esse operador tem resultado semelhante ao método Equals.Equals(str2) String em Java é uma classe que tem alguns comportamentos diferenciados das demais classes. 80 . Reparar que continua sendo uma instanciação.

preservando sua interface e acrescentando ou alterando sua implementação      Forma pela qual novas classes são definidas de forma incremental Definição de uma nova classe especificando uma classe mãe e um conjunto adicional de atributos e/ou métodos A classe definida desta forma herda todas os atributos e métodos da classe mãe A acessibilidade da interface da classe mãe não pode ser redefinida na classe herdada Java não permite herança múltipla com classes. mas apenas com interfaces.CAPÍTULO INTERFACES HERANÇA 11: HERANÇA E Forma pela qual uma nova classes é definida a partir de outra. ANATOMIA DA HERANÇA 81 .

82 .

vemos que uma classe filha pode ser definida com sua interface e sua implementação a partir da classe mãe com as seguintes características:    A interface original da classe mãe é mantida. no entanto parte dessa implementação pode ser sobrescrita pela classe filha. Notação UML 83 . A classe filha pode estender a interface.  HERANÇA E HIERARQUIA DE CLASSES      Cl1 é a superclasse de Cl1_1 e Cl1_2 Cl1_1 e Cl1_2 são subclasses de Cl1 Cada classe pode possuir uma única superclasse Cada classe pode possuir qualquer número de subclasses Cl1_1_1 e Cl_1_2 são classes distintas. sob a interface herdada da classe mãe podem estar implementações completamente diferentes. A implementação da classe mãe é totalmente herdada pela filha. A herança nunca “perde” interface.Dada uma classe mãe com sua implementação e sua interface. bem como Cl1_2_1. Nesse caso. A classe filha pode estender a implementação.

A utilização destas relações especiais dá um grande poder a um programa orientado a objetos. por sua vez. 84 . uma subclasse tem um relacionamento diferenciado com sua superclasse e esta por sua vez engloba várias características comuns a todas as suas subclasses. O esquema hierárquico de classes permite estabelecer relações especiais entre determinadas classes. Na figura acima pode-se ver como é a notação UML para indicar herança. onde as classes primárias são mais genéricas e as classes finais são mais específicas. Note que a relação estabelece que todas as propriedades de Funcionário são herdadas por Gerente. Gerente é subclasse de Funcionário. é superclasse de Gerente. e Funcionário. DEFINIÇÃO DE SUBCLASSES  Uso da palavra reservada extends A palavra chave extends é usada para estabelecer uma relação de herança entre duas classes. que também pode definir propriedades adicionais.A aplicação de herança cria uma hierarquia de classes. ou seja.

CHAMADA DE MÉTODOS NA HERANÇA Uma das relações especiais entre superclasse e subclasse é o compartilhamento de métodos. mas em um de seus ancestrais. SOBRESCRITA DE MÉTODOS  Classe Funcionario com método para calcular custo mensal total do Funcionario Sobrescrita de métodos 85 . O esquema de herança é responsável pela determinação do local exato da definição de um método. não definida na subclasse.

 Classe Gerente com o mesmo método

Na classe Gerente a implementação do método obterCusto() deve ser diferente, pois deve levar em conta o bônus que somente o gerente recebe. Quando uma subclasse reimplementa um método da superclasse, diz-se que esse método foi sobrescrito na subclasse. Nesse caso, a implementação que veio por herança de Funcionario foi descartada.  Gerente com sobrescrita de métodos, mas utilizando o método da superclasse

Ao sobrescrever um método, uma subclasse deve reaproveitar o método original, a fim de não reescrever regras. A sobrecarga de métodos deve preferencialmente prover um comportamento adicional à nova classe. Sendo assim, o comportamento original, herdado da superclasse, deve colaborar para compor também o novo comportamento.

86

A palavra reservada super tem a função de referenciar membros definidos na superclasse. Assim, super.obterCusto() referencia o método definido na superclasse (Funcionario).

HERANÇA E CONSTRUTORES
 Construtores não são herdados • Construtor de Funcionario
public Funcionario(String nome, double salario) { this.nome = nome; this.salario = salario; } Construtor de Gerente public Gerente(String nome, double salario, double bonus) { super(nome, salario); this.bonus = bonus; }

Os construtores de uma classe não são herdados pelas suas subclasses. No entanto, as regras definidas nos construtores das superclasses podem e devem ser reutilizadas nos construtores das subclasses. Na classe Gerente, o uso de super(...) invoca o construtor da superclasse e portanto utiliza o comportamento já definido em Funcionario.

INTERFACE
 Interfaces são conjunto de atributos estáticas ou métodos abstratos que estabelecem uma série de comportamentos que se espera da classe que a implementa  Classes e interfaces são equivalentes, exceto pelo fato que interfaces não podem ser instanciadas  Interface é uma classe abstrata com todos os métodos abstratos  Herança múltipla em Java • Cada classe pode ter apenas UMA superclasse e implementar VÁRIAS interfaces. Interfaces são conjunto de atributos estáticos (variável única compartilhada por todos os objetos de uma mesma classe) e/ou métodos abstratos (métodos com assinatura definida, mas corpo não definido) que estabelecem uma série de comportamentos que se espera da classe que a implementa.

87

Ausência de herança múltipla em Java é uma limitação amenizada pelo emprego de interfaces. Java permite que uma classe implemente uma ou mais interfaces.

88

 Vantagem: • Duas classes distintas que implementam a mesma interface respondem a um conjunto idêntico de funções (embora não necessariamente da mesma forma) Classes e interfaces são equivalentes, exceto pelo fato que interfaces não podem ser instanciadas. Interface é uma classe abstrata com todos os métodos abstratos.

DECLARAÇÃO DE INTERFACES
 
public interface Colaborador { public double obterCusto(); }

Declaração de uma interface

Implementação de uma interface

public class Consultor implements Colaborador { public double valorHora; public int totalHoras; public double obterCusto() { return this.valorHora * this.totalHoras; } }

Uma interface é declarada com o uso da palavra reservada interface, que elimina a necessidade de declarar os métodos como abstratos. Numa interface, todos os métodos são necessariamente abstratos. Uma classe pode implementar uma ou mais interfaces. Para a classe ser concreta (não abstrata) é necessário que todos os métodos das interfaces que ela implementa sejam implementados. Na notação UML uma interface é representada como uma classe, mas marcada com o estereótipo de interface (um círculo no canto superior direito do retângulo da classe)

89

uma relacionadas a bens móveis e outra a bens imóveis. 90 . A solução. então. No exemplo dado.EXEMPLO DO USO DE INTERFACES  Exemplo: Vamos supor um programa usado por um pais fictício que cobra um imposto único anual sobre todas as propriedades e/ou bens de seus cidadãos. as unidades de registro são os bens e não as pessoas (direito à privacidade) Como existem vários tipos de imóveis e automóveis. Como se trata e um país moderno. convém criar as classes básicas a partir das quais são herdados os vários registros (classes) diferentes Vamos simplificar nosso exemplo !    DEFINIÇÃO DAS CLASSES BASES Uma interface é utilizada para se definir um contrato que deve ser obedecido por todas as classes que a implementam. Vamos limitar os bens a imóvies e automóveis e modelar as classes que comporiam este programa. são definidas duas hierarquias de classes. é definir uma interface que força a implementação de um método que se deseja que todas as classes implementem. Como são hierarquias distintas. não existe uma superclasse comum a todas essas classes que forma um contrato para todas ao mesmo tempo.

EXEMPLO .DEFINIÇÃO DA INTERFACE  Imposto único se aplica a todos os bens. portanto a todas as classes anteriores. portanto pode ser implementada uma interface para isto O modificar final quando aplicado a variáveis as tornam constantes. uma vez atribuídas. não podem ser alteradas.DEFINIÇÃO DAS CLASSES DERIVADAS EXEMPLO . O cálculo pode ser distinto. 91 . cálculo e registro. ou seja. mas existe um procedimento único na cobrança.

EXEMPLO .REDEFINIÇÃO DA CLASSES 92 . Como as classes bases não implementam (nesse exemplo) os métodos abstratos da interface. herdados da interface). força-se que todas as suas subclasses devam implementar os métodos definidos na interface.REDEFINIÇÃO DAS CLASSES BASES Ao definir que as classes bases implementam a interface IUSB. elas devem ser declaradas abstratas (pois possuem agora métodos abstratos. EXEMPLO .

uma classe final não pode ser herdada por nenhuma outra classe.As subclasses de Imovel e de Auto que forem concretas (podem ser instanciadas) devem agora implementar os métodos definidos pela interface. impede que elas sejam utilizadas como superclasses. Ou seja. Notar que essas subclasses não são abstratas. Exercícios 1 – Codificar e testar o exemplo de uso de interfaces MODIFICADOR FINAL    O modificador final quando aplicado a variáveis as transformam em constantes. 93 . não podem mais ser alteradas. Uma vez atribuídas. O modificador final quando aplicado a métodos impedem que eles sejam sobrescritos. O modificador final quando aplicado a classes. porque não possuem mais métodos abstratos.

.CAPÍTULO 12: ENCAPSULAMENTO    É a característica da orientação a objetos que permite que uma classe defina a acessibilidade de seus membros Outras classes ou objetos de outras classes somente tem acesso aos membros cuja classe deu acesso Nem mesmo uma subclasse pode ter acesso a membros que a superclasse não deu acessibilidade O encapsulamento é uma característica que confere a classe o poder de determinar como será o acesso a seus membros. MODIFICADORES DE ACESSO  Palavras reservadas que determinam o acesso permitido a classes e seus membros o public o protected o private  Notação UML ( + . Com o uso correto do encapsulamento evita-se que objetos assumam valores de propriedades inconsistentes.e #) o + public o . Os modificadores de acesso são os instrumentos da linguagem para definir o encapsulamento. Evita-se também que comportamentos não públicos de uma classe sejam utilizadas externamente a ela. Essa característica possibilita que atributos sejam corretamente protegidos de acessos indevidos.private o # protected 94 .

. Aplicada a membros: determinam que o membro pode ser utilizado apenas no mesmo pacote. A notação UML emprega os símbolos + para indicar que um membro é público. protected   Não se aplica a classes e interfaces Aplicada a membros: determinam que o membro pode ser invocado ou utilizado apenas por classes do mesmo pacote ou por subclasses. mais o modificador dado pela ausência de palavra chave. protected e private.  public   Aplicado a classes e interfaces: determinam que a classe pode ser utilizada livremente por qualquer uma outra classe ou interface. Em Java existem 4 modificadores de acesso: os três indicados pelas palavras chaves public.para privado e # para protegido. MODIFICADORES DE ACESSO Sem modificador   private   Não se aplica a classes e interfaces Aplicada a membros: determinam que o membro pode ser invocado ou utilizado apenas pela própria classe. 95 . a ausência de modificador de acesso é um definição de acessibilidade também. Aplicada a membros: determinam que o membro pode ser utilizado livremente por qualquer outra classe. Aplicado a classes e interfaces: determinam que a classe pode ser utilizada apenas no mesmo pacote. Ou seja.

Se o usuário de um objeto da classe Data passar como argumento algum valor incompatível. a cada mês é permitido um valor máximo para o dia. evitando datas inconsistentes. o método impede que esse valor chegue ao atributo.dia = 35.EXEMPLO Todos os atributos de Data são privados. Assim. Para atribuir um valor a um atributo de Data deve-se utilizar um método público. não é permitindo. Assim data1. o que impede que eles recebam diretamente valores vindos externamente a classe. Na implementação desses métodos é garantido a consistência dos seus atributos.  Construtor de Data 96 .

CALENDAR) A classe Calendar sendo uma classe abstrata não pode ser instanciada com o operador new.set(ano. Para obter a data atual se basta criar um objeto Date sem nenhum parâmetro.mês.set(ano.setTime(new Date() ).hora.O construtor deve garantir também o encapsulamento. Na maioria das vezes você vai receber uma instância de Java.DATE) A classe Date armazena uma data e hora. Com a data devidamente configurada podemos realizar diversas operações com a data: 97 .hora.UTIL.dia.mês.GregorianCalendar. c. Esta classe é bem simples de se trabalhar. ela deve ser criada utilizando um operador estático sobrecarregado getInstance().mes. A classe Calendar também nos fornece várias constantes que utilizaremos para manipular uma data entre elas. CALENDAR(JAVA.segundo).getIntance(). mas muitos de seus métodos foram depreciados por não trabalhar muito bem com internacionalização e etc. Date d = new Date(). que internamente é armazenada com um inteiro long que é o numero de milissegundos que se passou desde 01/01/1970. Método setTime c. c.set(ano. Calendar c = Calendar. MANIPULANDO DATAS EM JAVA DATE(JAVA.dia.util.minuto).dia). Com a instância de Calendar devemos configurar uma data e podemos fazer isso de duas formas: Métodos set c.UTIL.minuto.

1 ). c.YEAR.getInstance().MONTH Ano: Calendar.SECOND Veja o exemplo abaixo: Date d= new Date().//adicionamos 1 ano a data atual DATEFORMAT(JAVA. Date d = new Date().5 ). etc…) e o segundo quantas vezes será adicionada/subtraída esta unidade. Calendar c = Calendar. mês ou ano utilizamos o método add.add(Calendar.HOUR Calendar. c. A classe DateFormat nos fornece uma maneira simples de formatá-la e permite a internacionalização a partir da classe Locale.getDateInstance(DateFormat.println( df.format(c. A unidade é informada utilizando constantes fornecidas pela classe Calendar que pode ser: Dia: Calendar.TEXT. DateFormat df = DateFormat.DAY_OF_MONTH Calendar.MONTH.SHORT). hora. sendo o primeiro um constante inteira que representa a unidade da data que queremos modificar(dia.YEAR Hora: Calendar. mês .DAY_OF_YEAR Mês: Calendar.add(Calendar.DAY_OF_YEAR.HOUR_OF_DAY Segundos: Calendar.Para adicionar ou subtrair um dia.getTime()) ).out.//adicionamos 5 dias a data aual c.//adicionamos 3 mêses a data atual c. System. agora precisamos formatar a data para apresentação.DAY_OF_WEEK Calendar. O método add aceita dois parâmetros. Calendar c = Calendar.getInstance().DATEFORMAT) Bom agora sabemos como manipula datas. 98 . ano.3 ).setTime(d).add(Calendar.

Date hoje = new Date(). 3 de Junho de 2013 Embora para muitos casos estes formatos serão suficientes algumas vezes necessitamos de uma formato vem personalizado.println( sdf. A saída do exemplo acima será algo como 03/04/10. O construtor de SimpleDateFormat recebe uma String que representa o formato da data.format(hoje)).LONG //3 de Junho de 2013 Dateformat. A classe DateForma nos fornece vários tipos de formato para data como: Dateformat. System.Para obtermos uma String da data utilizamos o método format que retorna uma String no formato especificado no método getDateInstance(). Isso pode ser feio através de um subclasse de DateFormat a SimpleDateFormat.FULL //Segunda. Os símbolos utilizados para cada campo da data pode ser visto na tabela abaixo abaixo: Símbolo G y M d h H m s S E D F w Significado era designator year month in year day in month hour in am/pm (1~12) hour in day (0~23) minute in hour second in minute millisecond day in week day in year day of week in month week in year Apresentação (Text) (Number) (Text & Number) (Number) (Number) (Number) (Number) (Number) (Number) (Text) (Number) (Number) (Number) Exemplo AD 1996 July & 07 10 12 0 30 55 978 Tuesday 189 2 (2nd Wed in July) 27 99 .SHORT // 03/06/13 Dateformat.out.MEDIUM // 03/06/2013 Dateformat. SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy HH:mm:ss").

FULL.// japao O objeto locale de Locale pode ser utilizado tanto com a classe DateFormat quanto com a classe SimpleDateFormat. que língua ele será utilizada? Normalmente o inglês.println( df.format(d)).new Locale("pt". Date hoje = new Date().W a k K z week in month am/pm marker hour in day (1~24) hour in am/pm (0~11) time zone (Number) (Text) (Number) (Number) (Text) 2 PM 24 0 Pacific Standard Time Como vimos o dia da semana pode ser escrito por extenso.format(hoje)).printStackTrace().parse("25/03/2010").out. } System. SimpleDateFormat sdf = new SimpleDateFormat("E dd ".getDateInstance(DateFormat.//portugues do brasil Locale japao = new Locale("ja").new Locale("pt".println( df.out. } catch (ParseException ex) { ex. Para finalizar como covertermos uma String em um objeto Date Date d = new Date()."br"))."br").out. mas se quisermos que seja na língua de um local diferente? Para isso utilizaremos a internacionalização com a classe Locate que recebe em seu construtor a língua e o país que queremos utilizar: Locale brasil = new Locale("pt".println( sdf.format(hoje))."br")). 100 . DateFormat df = DateFormat. System. try { d = df. System. SimpleDateFormat df = new SimpleDateFormat("DD/MM/yyyy").

simpledateformat<> Exercícios 1 – Digitar e testar a classe Data deste capítulo 2 – Encapsular corretamente as classes Conta e ContaEspecial do capítulo anterior. 101 .O métdo parse da classe DateFormat e <strong.simpledateformat< strong=""> recebe uma string e convertepara um objeto Date</strong.

mas com a mesma interface de B) pode substituir esse segundo objeto. não conhece a implementação desse segundo. Assim. São classes polimórficas. Um objeto (da classe A). construído para trabalhar com um segundo objeto (da classe B). mas implementações diferentes são polimórficas. Classes com interfaces semelhantes. Um outro objeto (da classe C. classes diferentes podem implementar a mesma interface. mas apenas a sua interface (IB). Polimorfismo é a característica da orientação a objetos que determina que uma interface e sua implementação são elementos distintos de uma classe. EXEMPLO CONCEITUAL As classes polimórficas dão uma grande flexibilidade para o desenvolvimento de aplicações onde os contratos estabelecidos entre os objetos são muito bem definidos (essas contratos são as interfaces através das quais os objetos interagem entre si). sem necessidade de alterações na classe A.CAPÍTULO 13: POLIMORFISMO   Característica que permite que uma mesma interface assuma implementações distintas. 102 .

. } } A a = new A().public interface IB { . public void setObj(IB obj) { this.obj = obj.setObj(new B())..  Notação UML POLIMORFISMO E HERANÇA   Uma subclasse implementa a interface da superclasse Classes numa mesma hierarquia podem ser polimórficas pela interface mais genérica 103 . a.setObj(new C()).} public class A { private IB obj... a..} public class C implements IB { . } public class B implements IB { ..

Se a classe A é dependente de B. D. E. F ou G pode ser utilizadas nesta dependência Exemplo completo Comentários e código:    No diagrama UML estão indicados apenas os principais atributos e métodos. Um método abstrato. C. então qualquer instância de B. que deverá ser implementado por todas as subclasses. O estereótipo <<abstract>> indica que a classe ou o método são abstratos. Um construtor que recebe o nome. Colaborador    Classe abstrata. A classe DeptoPessoal não está completa. 104 . O código está completo.

abstract public class Colaborador { private String nome; abstract public double obterCusto(); public String obterNome() { return this.nome; } public Colaborador(String nome) { this.nome = nome; } }

105

CAPÍTULO 14: ENTRADA E SAÍDA
• • Conceito de stream Classes básicas o InputSream o OutputStream o são “simétricas” • Podem ser aninhadas (flexibilidade)

Stream é um conceito que representa qualquer caminho de comunicação entre uma fonte de informação e seu destino. Este conceito pode ser empregado para qualquer fonte ou destino de informação, e torna-se útil porque padroniza esta comunicação independentemente destes. Assim, a classe stream implementa os mesmos métodos, seja o stream origirário (ou destinatário) um dispositivo de I/O, a memória, outra aplicação ou outro thread da mesma aplicação. Os streams que implementam I/O são os mais empregados e o escopo maior desta seção. Os streams de entrada e saída são “simétricos” em muitos aspectos. Assim, apenas um dos casos será estudado detalhadamente. A possibilidade de aninhar classes de stream em Java torna seu uso muito flexível e prático.

ENTRADA
• InputStream - métodos o read() o skip() o available() o mark() o reset() o close()

106

A classe básica que implementa streams de entrada é chamada de InputStream. Esta classe incorpora uma série de métodos. Os principais são descritos abaixo: • • • • • • read(): realiza a leitura de bytes do stream; skip(): ignora um número de bytes do stream, passado como seu parâmetro; available(): retorna o número de bytes disponíveis no stream; mark(): marca uma posição sobre o stream; reset(): retorna à posição marcada por mark(); close(): fecha o stream (não é obrigatório).

INPUTSTREAM - EXEMPLO

No exemplo, a primeira chamada a read() realiza a leitura de um único byte. Na segunda chamada, a variável buffer é preenchida com bytes do stream (desde que existam). Na terceira chamada, a leitura é realizada a partir da posição 300 do stream. O método mark() exige como parâmetro o número de bytes do stream onde se estende a sua validade. Assim, se um reset() for chamado após 1024 posições já percorridas, um erro será gerado. Este mecanismo força o progamador a alocar recursos bem definidos para o uso do mark().

107

 FilterInputStream o fornece base para classes de stream que possam ser aninhadas  Subclasses de FilterInputStream o BufferedInputStream : stream com cache o DataInputStream: stream de tipos distintos (e não somente de bytes. O aninhamento de classes torna bem flexível o uso dos streams.CLASSES HERDADAS DE INPUTSTREAM    ByteArrayInputStream e StringBufferInputStream cria um stream a partir de um buffer ou de uma string FileInputString o tipo mais comum de stream o pode abrir e acessar arquivos do sistema o pode tratar como stream arquivos já abertos Exemplo: InputStream filein= new FileInputStream(“/usr/fulano/arquivo”). respectivamente. ByteArrayStream e StringBufferStream criam um stream a partir de buffer de bytes ou a partir de uma string. 108 . como vimos até agora) o PushBackInputStream: implementa o método unread(). Juntamente com FileOutputStream fornecem a base de acesso a arquivos em Java. como pode ser visto nos exemplos abaixo. FileInputString permite a abertura a manipulação de stream originários de arquivos do sistema. que coloca de volta no stream um byte já lido. FilterInputStream é a classe básica que implementa a base para classes de stream que possam ser aninhadas. As demais classes de streams de entrada são herdadas a partir de InputStream. Portanto agem de forma inversa ao mostrado no exemplo anterior.

OUTPUTSTREAMS  Simétrico a InputStream o implementa write() ao invés de read(). Podem ser feitos quantos aninhamentos se desejar. tais como cache e interpretação de tipos.   PipedInputStream o stream que estabelece comunicação entre dois threads SequenceInputStream o executa a concatenação de streams Exemplo: InputStream sin1 = new FileInputStream(“metade1”). SAÍDA .Algumas classes são geradas diretamente de FilterInputString e implementam algumas facilidades básicas no uso de streams. Uma exemplo de aninhamento de stream: InputStream sin= new BufferdInputStream(new FileInputStream(“arquivo”)). Existem outras classes não mencionadas aqui pois são de uso muito restrito. InputString sin=new SequnceInputStream(sn1. em todas as suas subclasses herdeiras o flush() o close() 109 . No entanto. na literatura avançada podem ser encontradas algumas descrições. sn2). Esta declaração cria um stream originário de um arquivo do sistema e ao mesmo tempo utiliza cache. InputStream sin2 = new FileInputStream(“metade2”). desde que as classes aninhada sejam subclasses de FilterInputStream.

110 . OutputStreamReader (ponte entre streams e writers) Para a manipulação de arquivos o uso de Readers e Writers é mais prático.print() o System. PrintStream o não tem InputStream correspondent o System. BufferedReader in = new BufferedReader(isr). com respeito as classes de InputStream. Não convém repetir todo o texto para as classes OutputStream e suas subclasses.println(in. FileInputStream fis = new FileInputStream("C:\\arquivo. READERS E WRITERS  As classes de manipulação de streams trabalham com bytes. InputStreamReader (ponte entre streams e readers) • Superclasse: Writer – BufferedWriter.readLine()). System. Além desse. A classe PrintStream não encontra correspondente nos streams de entrada. InputStreamReader isr = new InputStreamReader(fis).out contém uma instância deste classe.out.txt"). StringReader. Ela já foi usada neste curso.  Para se trabalhar com caracteres utilizam-se os Reader e Writers. FilterWriter. existe o método flush() que força o stream a escrever na saída os dados que eventualmente estejam em cache ou temporariamente em algum lugar. FilterReader. Evidentemente o método read() e seus equivalentes é substituído pelo método write() (e seus equivalentes).println(). que são equivalentes respectivamente aos streams de entrada e saída. É trivial compreender que o seu comportamento é simétrico em relação ao fluxo do stream.out. uma vez que a variável de classe System. StringWriter.out. • Superclasse: Reader – BufferedReader.

Faça uma aplicação que fique esperando strings na entrada padrão e as mostre na saída padrão. createNewFile.Faça uma aplicação em que mostre na tela o conteúdo de um arquivo qualquer. System. length • Manipulação de diretórios – listFiles. BufferedReader in = new BufferedReader(isr). File file = new File("C:\\arquivo. isHidden.out. Para isso foi usada a ponte entre eles. canWrite.Observar que o arquivo foi aberto usando um stream e manipulado usando um reader. getName. mkdir O mesmo exemplo anterior agora utilizando a classe File. isFile. substituindo todas as letras pela sua letra seguinte (a por b. etc). Faça o processo inverso também. isDirectory • Manipulação física – getAbsolutePath. InputStreamReader isr = new InputStreamReader(fis).readLine()).println(in. 111 . Utilize Readers e Writers. Exercícios 1 . renameTo. mostra esta linha. A aplicação espera a entrada de uma linha e após a ENTER.txt"). 2 – Faça uma aplicação que copie o conteúdo de um arquivo de caracteres para o outro. FileInputStream fis = new FileInputStream(file). 3 . b por c. A CLASSE FILE  Manipula arquivos e diretórios (e não seu conteúdo) • Teste dos atributos do arquivo: – canRead.

Um exemplo de uso de multithread são os próprios browsers Internet. mais derivativo e paralelo Usar multithread é uma boa prática.CAPÍTULO 15: THREADS     Possibilidade de executar simultaneamente várias threads de um único programa A execução do programa não segue um padrão linear. ou seja. o que muita vezes ocorre de forma lenta. outros threads permitem que a página sendo carregada já seja exposta na tela. O uso de multithread em Java é fácil e implementado diretamente pela linguagem. no entanto a maioria dos servidores Web e de Aplicação realizam isso implicitamente Situações necessárias: • loops infinitos (animação. Enquanto um thread realiza a busca dos dados na rede. e links ativos. sockets agents) • longs trechos de código sem interação com terceiros • múltiplas instâncias de um mesmo trecho de programa Multithread é a capacidade de um programa de rodar diferentes trechos (ou diferentes instâncias do mesmo trecho) de forma independente. Permite por exemplo que o programa realize tarefas em background enquanto mantém “viva” a interface com o usuário. o controle dos diferentes threads é feito automaticamente. Num ambiente de janelas fica evidente que a programação em threads é fundamental. 112 . com rolagem.

Verifica-se que alguns threads podem ter curta duração (inicialização) e outros podem ficar rodando indefinidamente em loop infinito. IMPLEMENTAÇÃO     Classe deve implementar interface Runnable Classe deve possuir uma variável que contenha um tipo Thread Método start() deve ser invocado para disparar um novo thread O método run() deve conter o código que roda dentro do thread 113 . terminando apenas quando a aplicação finaliza. Um bom procedimento é finalizar todos os threads iniciados antes de terminar a execução do programa. Todas as linhas mostradas são implementadas com threads. mas não seguir esta regra pode compromete recursos do sistema de forma indesejável. tais como processos permanentes em background. Isto não é obrigatório.DIAGRAMA  Fluxo de um programa multi-thread O diagrama acima dá uma ideia do fluxo de execução de um programa multithread. inclusive a linha “principal”. Esta é uma boa política de programação.

É o exemplo de Relógio rodando dentro de um thread. portanto com a assinatura: public class RelogioMultiThread implements Runnable { …. } Esta interface força a implementação um método run() que agora deve passar a conter todo o código a ser executado dentro do thread. enquanto a aplicação principal continua seu fluxo normal de execução.A criação de uma classe para trabalhar com multithreads é muito simples. Uma aplicação com multithread é mostrada nas páginas seguintes. Basicamente deve-se declarar a classe com a interface Runnable. Exemplo 114 .

println( . etc.Date()). Exercícios 1 ..util. Cada um deles deve mostrar na saída padrão. public synchronized void metodo() { . Quando mais de um thread tenta usar os métodos/blocos sincronizados. // acesso a recursos de forma única } // dentro de um método qualquer..println 3 – Crie uma pilha de dados cujos acessos (push e pop) sejam sincronizados 115 .Faça uma aplicação que dispare três threads.out. como por exemplos.. synchronized(this) { .SINCRONIZAÇÃO DE THREADS  Mecanismo para evitar que um mesmo trecho de código seja executado por dois threads simultaneamente • Manipulação de recursos únicos (arquivos.} onde o bloco é executado por um único thread de cada vez. em um loop infinito. suspendendo aqueles que estão esperando sua vez de execução. 2 . o instante que ele roda (com System... A sincronização pode ser feita pela método usando o modificador synchronized..out. o interpretador enfileira-os. ou não podem ter acessos simultâneos. ou pelo bloco synchronized(objeto) {. // acesso a recursos de forma única } A sincronização de acesso a recursos que são compartilhados entre threads é muito útil para evitar erros de acesso simultâneas. + new java. variáveis de controle. variáveis) que não podem ser acessados simultaneamente. entrada e saída.. onde todo o corpo do método somente pode ser executado por um thread de cada vez.. em recursos que não o suportam. arquivos abertos..Coloque um contador em cada thread e verifique quantas vezes cada um deles executa o System.

de forma complexa e extensa.CAPÍTULO 16: EXCEÇÕES E ERROS     Tratamento de situações eventuais mas que comprometem a correta execução do programa Maneira simplificada de extensivamente capturar situações de exceções e erros Situações previsíveis. Muitos dos métodos dos pacotes básicos de Java necessitam que o usuário defina um tratamento de erro específico. Isto pode ser tão simples ou tão complexo. Uma sistemática de tratamento destas condições pode abranger grandes porções de código. nem que seja passar a exceção/erro para o sistema. Ao mesmo tempo que permite a extensão desta sistemática para grande parte do código de forma simplificada. são eventuais. MANEIRA COMUM DE TRATAR EXCEÇÕES/ERROS    repetitiva e extensa dificulta o código alta relação custo benefício. No entanto seu tratamento é necessário para um bom código. é importante salientar que o tratamento de exceções/erros não é um código mágico que vai tornar seu programa error-free. como o próprio nome diz. Normalmente as situações de exceções e erros. O tratamento de exceções e erros em Java é uma forma de tornar o código mais previsível e controlável. mas necessário int valret=metodo_que_preve_exc(). Java provê uma maneira de sistematizar o tratamento destas situações. Por outro lado é também uma forma de facilitar a programação de rotinas necessárias a esse tratamento. As situações tratadas podem ser bem genéricas. mas devem ser previsíveis. mas genéricas Java força o tratamento em muitos casos. a fim de facilitar a programação. tanto quanto queira o programador. switch (valret) { case … … } 116 . Por fim.

Pode também exigir o uso de variáveis globais na passagem de indicadores de erros.A maneira convencional de tratar exceções e erros tende a ser cansativa. • passagem da exceção adiante. declarar a passagem da exceção/erro para uma classe específica e não implementar o seu tratamento. Exige alterações na funcionalidade propriamente dita do código. • tratamento “in loco” da exceção. passa a ser irritante quando necessita ser utilizada em grande parte do código. Cada situação em particular pode exigir uma atitude específica do programador. As exceções e erros são modelados por objetos herdados da classe básica Throwable. 117 . Esta abordagem. Este modelamento em objetos permite estabelecer uma hierarquia de erros. muito útil na definição de tratamento específicos e/ou genéricos. No entanto a alternativa de tratar a condição localmente é a mais esperada normalmente. repetitiva e extensa. por motivos óbvios. capturar e tratar a condição “in loco”. além de pouco prática. capturar e passar a condição para o nível superior de seu código. TRATAMENTO EM JAVA   Exceções e erros são modelados por objetos (classe básica chama-se Throwable) Atitudes do programador: • avisar usuário do método que uma exceção pode ser gerada. Diante de um método que pode gerar alguma condição de exceção ou erro. o programador pode tomar três atitudes:    não capturar. mas no entanto necessária. com benefícios pouco utilizados (já que as ocorrência são raras). Tem-se uma forma de programação de alto custo.

Esta declaração apenas diz ao usuário daquele método que tipo de exceções/erros pode-se esperar de sua execução. Isto acaba forçando o usuário destas interfaces a capturar e tratar os erros passados. 118 . mas não provê uma forma de tratar esta condição. Fornece uma informação muito útil. Este é o esquema básico de indicação de condição de exceções/erros em Java e que muitos métodos das bibliotecas básicas de interfaces implementam.MODIFICADOR THROWS    Uso da palavra reservada throws indica que método pode gerar uma condição de exceção/erro Normalmente deixa o tratamento a cargo de quem utilizar o método Não é muito prático para projetos em equipes A palavra reservada throw aplicado a um método indica que aquele método pode gerar uma exceção/erro do tipo definido pela cláusula throws.

o usuário usa a cláusula try aplicada a um bloco para especificar que espera capturar uma condição de exceção/erro naquele bloco. a cláusula catch captura a exceção/erro específico (indicado entre parênteses) e determina um tratamento. e portanto não desestrutura o código. Como o próprio nome diz. Definir um tratamento passa a ser a parte complexa do código e em geral exige experiência do programador. Este desvio é completamente definido e delimitado pelo cláusula catch. 119 . Esta forma direta permite que condições de exceções/erros gerem apenas um desvio do código para um tratador específico. mas representa a forma mais clara e completa de programar este tipo de tratamento. tratadores específicos são chamados nos blocos seguintes. Ao fim do bloco try.…- O tratamento local de exceções/erros exige um pouco mais de código. Nesta caso. Basicamente devemos nos preocupar com as exceções mais comuns e fornecer um tratamento curto e rápido.…. Em outras palavras: o programa tenta rodar o código dentro do primeiro bloco.catch (Erro e) .TRATAMENTO  Uso de try. caso alguma condição de exceção/erro surja. como alguns poderiam supor. estas são condição especiais e o bom senso diz o quanto de esforço devemos colocar no tratamento de condições que podem comprometer o resultado do nosso código.

Este erro é então passado para o nível imediatamente externo à classe em questão. então este é passado novamente para a próxima classe e assim sucessivamente até chegar ao sistema. Se a classe mais externa não tratar este erro.PASSANDO O TRATAMENTO ADIANTE   Capturar a exceção mas passar o seu tratamento adiante Utilizar com exceções básicas quando se sabe que o nível externo tem condições de tratá-la Uma outra alternativa para tratamento de exceção/erro é capturá-lo e simplesmente passá-lo adiante. onde sabemos ter o sistema condições de tratá-lo. Adoção desta atitude é mais aconselhável para erros básicos do sistema. 120 . É importante observar que as exceções lançadas com o comando throw. precisam ser declaradas no método com o palavra reservada throws.

É necessário que os erros mais específicos sejam declarados primeiros. como no exemplo acima.  O bloco finally sempre é executado. A única ressalva a ser feita é quanto ao ordenamento dos tratadores no cláusulas catch. de um objeto da classe básica Throwable. uma cláusula finally pode ser acrescentado ao tratamento de exceções. Assim. apenas uma condição muito particular e pouco provável iria chamar um tratamento de baixo nível. A CLÁUSULA FINALLY  Além de múltiplos catches.TRATAMENTO MÚLTIPLO Um bloco try pode capturar tantos erros quanto se queira. independente da captura da exceção 121 .

DEFININDO EXCEÇÕES  Erros e exceções podem ser definidas pelo desenvolvedor  Qualquer subclasse de Throwable pode ser definida como um erro ou exceção  Para a definição de exceções normalmente se utiliza como superclasse a classe Exception. mês e ano). dando uma grande flexibilidade de programação. com exceções associadas a regras de execução do programa e não apenas a falhas. para datas inconsistentes. e devolva para uma o usuário uma mensagem amigável caso a data seja inconsistente. 2 – Faça um programa que leia uma data do teclado. O mecanismo de captura e lançamento de exceções pode ser utilizado para trabalhar com exceções definidas pelo desenvolvedor. 122 . Defina exceções e lance-as. no construtor. Exercícios 1 . É muito comum se utilizar esse mecanismo para definir desvios no fluxo de programação.Faça uma classe que represente uma data (dia.

Stack: pilha 123 . As principais classes desse pacote são: • • • • ArrayList e Vector: Arrays de tamanho ajustável aos elementos armazenados. Hashtable: Armazena pares chave-valores. LinkedList: Lista duplamente ligada.CAPÍTULO 17: TÓPICOS AVANÇADOS    Coleções Networking Generics COLEÇÕES  Java oferece uma série de classes que estruturam objetos de uma forma mais prática do que arrays o Listas o Listas ligadas o Hashtables o Características o Sincronizadas para acessos em múltiplos threads o Métodos de ordenação o Estruturas com uso de tipos específicos (generics) No pacote java. com métodos que facilitam a busca dos valores pelas suas chaves.util existe uma série de classes que implementam a interface Collection. Todas as classes concretas que implementam essa interface são estruturas para armazenar um conjunto de objetos com as mais variadas finalidades.

A maioria das classes que manipulam coleções são parametrizadas por tipos. } } }  Iteratores o As coleções podem ser “percorridas” com iteratores.Observar na documentação da API quais dessas coleções permitem acesso sincronizado a seus elementos.add("dois"). A classe Arrays possui uma séria de métodos de ordenação de arrays.println(it.add("dois"). arr.add("um").next()). arr.out.util. while(it.out.add("um"). Iterator it = arr. import java.iterator().println(s). arr. arr. public class Listas { public static void main(String[] args) { ArrayList<String> arr = new ArrayList<String>(). que podem ser obtidos diretamente delas Iterator it = colecao. hasNext() testa se existem elemento ainda next() retorna próximo elemento Exemplo do uso de iteratores: import java.hasNext()) { System. } } } 124 . for(String s: arr){ System.util.iterator().*.*. public class Listas { public static void main(String[] args) { ArrayList<String> arr = new ArrayList<String>().

1".net. BufferedReader reader = new BufferedReader(new InputStreamReader(url.io. import java. 125 . para envio de pacotes TCP/IP sobre a rede. uma única instância de cada data existe em todo o programa. NETWORKING  URLConnection Efetua uma conexão com um servidor Web.0. Permite o envio de dados e recebimento de arquivos de um servidor Web (páginas HTML. retornando-a.htm"). imagens.out.) A classe URLConnection permite uma maneira fácil e simples de abrir uma conexão com qualquer servidor na Internet.*.println(linha). 3 – Liste todas as chaves do Hashtable usando um iterador. todas as datas armazenadas por ela. Escrever um programa que lê uma página da internet cuja URL foi digitada pelo usuário na linha de comando.*. então ele é criada e armazenada no Hashtable. "127.  ServerSocket e Socket Servidor e cliente TCP/IP. Esse método verifica se existe uma Data previamente criada (e armazenada num Hashtable). A cada data que o programa precisar ele pede para um método estático dessa classe. while((linha = reader. 8080. } } Exercício 1. public class Conexao { public static void main(String[] args) throws Exception{ URL url = new URL("http".0.readLine()) !=null) System. Se a data não existir. "/index. String linha = null. import java.openStream())).Exercícios 1 – Faça uma classe que funciona como uma fábrica de Datas. 2 – Faça um método nesse classe que coloque num array. etc. Dessa forma. em ordem cronológica.

byte[] bytes = new byte[100].getOutputStream().accept(). import java. while(true) { Socket socket = servidor. OutputStream saida = socket. System. 10000). entrada. import java. saida. import java. for(int i=0.getBytes()). GENERICS    Declaração de classes e métodos com tipos parametrizados Os tipos são resolvidos em tempo de compilação Eliminação de casting 126 .read(bytes).out. i++) { if(bytes[i]==0) break.write("Conectou!". Escrever um cliente socket que envia dados para um servidor socket.io.*.net. import java. } } } Exercício 1.Servidor fica “escutando” (listening.1".0.io.print((char)bytes[i]). socket.close(). esperando por conexões.*.0.*. saida. InputStream entrada = socket.*. } } } Cliente se conecta na porta do servidor.getInputStream(). i<100.net. public class Servidor { public static void main(String[] args) throws Exception{ ServerSocket servidor = new ServerSocket(10000).close(). em inglês) uma porta TCP/IP. public class Cliente { public static void main(String[] args) throws Exception{ Socket socket = new Socket("127.

for(Dupla d : pilha) { System.out.println(d." + this. this. } } } class Dupla { Dupla(int a.a + ". T t) { this." + t.toString() + ". import java. } 127 . this.e = e. "quarenta")). T t. pilha.add(new Dupla<Integer.add(new Dupla<Integer. String>("tres". int b) { this.util. T> { E e.t = t. public class Generic { public static void main(String[] args) { Stack<Dupla> pilha = new Stack<Dupla>().add(new Dupla(2.34)).add(new Dupla<String.add(new Dupla(1.toString() + ")".*. String>(2.println(d.Exemplo que utiliza uma pilha de uma classe definida pelo desenvolvedor. } } Agora a classe Dupla foi parametrizada para servir como dupla de dois tipos parametrizados quaisquer. pilha. Dupla(E e. pilha. String>(1."sesseta e sete")).b = b. for(Dupla d : pilha) { System.toString()). } public String toString() { return "(" + e."trinta e quatro")). } } } class Dupla<E. b. } int a. pilha. pilha. public class Generic { public static void main(String[] args) { Stack<Dupla> pilha = new Stack<Dupla>(). Notar que na instanciação dos objetos os tipos são passados como parâmetros.out.b + ")". public String toString() { return "(" + this.a = a. Notar que a pilha manipula apenas o tipo parametrizado (Dupla).67)).toString()).

usando o wildcard de tipos <?>.add(new Dupla<Integer."sesseta e sete")). Integer>(1. pilha.out. public class Generic { public static void main(String[] args) { Stack<Dupla> pilha = new Stack<Dupla>(). pilha.} } 128 . } } public static void println(Dupla<?.34)).toString()). String>("tres".?> dupla) { System. String>(2. "quarenta")).} Por fim. pilha.add(new Dupla<String.println(dupla. for(Dupla d : pilha) { println(d).add(new Dupla<Integer.