Java Basico

Linguagem de Programação JAVA

© Copyright e-tecnologia.com, 2002

JB100 Java BásicoJB100 Java Básico

Versão: 3.0

Rildo F Santos ([email protected])Rildo F Santos ([email protected])

Revisão 3.0 27/01/09

Autor: Rildo F Santos ([email protected])




Versão: 3.0


2

Estrutura do Curso

Introdução

Programação

Orientada

a Objetos

Características

Avançadas

Introdução

a UML

Utilitários

Apresenta arquitetura da linguagem Java

Apresenta comandos e funcionalidades

básicas

Fundamentos

da linguagem

Principais aspectos da programação

orientada a objetos

Apresentar características avançada da

Linguagem (Threads, networking e etc)

Apresentar uma visa geral da UML e seus

os principais componentes

Demonstrar os principais utilitários da

linguagem Java (Jar, JadaDoc e etc)




Versão: 3.0


3

Conteúdo

Introdução

breve apresentação

gerando aplicações

Instalação do JDK

O primeiro programa

Fundamentos da linguagem Java

Estrutura da linguagem

Palavras Reservadas

Tipos de Dados

Inicialização de variáveis

Operadores

A classe String

A classe StringBuffer

Casting

Fluxo de Controle

Arrays

Passagem de Parâmetros

A classe Math

Empacotamento de Classes

Conversão de Tipos

A referência this

Coleções

Pacotes

Programação Orientada a Objetos

Classes

Objetos

Métodos

Construtores

Atributos e variáveis

Exemplo de classe

Exercício

Abstração de Dados

Relacionamento

Herança

Herança Múltipla

Comparação: Classes vs Interfaces

A referência Super

Associação

Navegação

Rolename

Agregação

Composição

Multiplicidade

Constraint

Encapsulamento

Polimorfismo

Acessibilidade

Características Avançadas

Instanceof

Exception

Formatando Números e Datas

Constantes

Threads

Serialization

TCP/IP

Introdução a UML

Utilitários

JavaDoc

Jar

JDB

Javap

Apêndice

Convenção de Código no Java

Unicode

Notação UML

Versão do JSDK 1.3

Este material foi preparado para trabalhar com a versão JSDK 1.3 (veja: http://java.sun.com/j2se/1.3/index.jsp),

entretanto todos os exemplos funcionam perfeitamente na versão 6 (versão atual)

Nota




Versão: 3.0


4

Apresentar as características básicas da linguagem Java, assim

como, sua estrutura, funcionalidades, métodos, classes, APIs

(Application Program Interface) e recursos avançados.

Você está preparado ?

Para aprendermos uma nova linguagem de programação é necessário ter alguns

conhecimentos como:

- Lógica de Programação;

- Conhecer um Sistema Operacional, por exemplo, Windows, Unix, Linux ou MacOS;

- Saber editar e compilar programas e;

Conhecer uma outra Linguagem de Programação é importante, porém não

imprescindível.

Expectativas após o Curso:

Objetivo deste curso:

Ao final deste curso você deverá estar apto a:

• Utilizar a linguagem Java para criar aplicações simples;

• Descrever e usar as características de linguagem orientada a

objetos com Java, tais como: Herança, Abstração de Dados,

Encapsulamento e Polimorfismo;

• Conhecer o tratamento de exceções;

• Descrever e usar “sockets” para fazer acesso a servidores e

clientes;

• Conhecer UML básica;

Objetivo




Versão: 3.0


5




Versão: 3.0


6

Java

Uma breve apresentação...

Surgimento:

Java é uma linguagem de programação criada em 1995 por James Gosling e sua

equipe. A linguagem é de propriedade da Sun Microsystem.

Logo Java ganhou popularidade, um bom exemplo disto são os “Applets”, aqueles

pequenos aplicativos que executam nos navegadores, que durante muito tempo foi o

foco da linguagem Java.

Com o passar do tempo, o número de desenvolvedores aumentou e a linguagem

amadureceu sendo hoje considerada o principal ambiente de desenvolvimento, tanto

para Internet quanto para ambiente cliente/servidor tradicional.

Algumas das características da linguagem Java:

• Orientação a objetos

• Portabilidade (isto que dizer que o mesmo programa criado no

Windows2000, pode ser executado em Linux, por exemplo, ou qualquer outro

Sistema Operacional, sem a necessidade de fazer ajustes).

Entretanto, a linguagem Java vai além da computadores, sendo executada em

diversos dispositivos como telefone celulares, televisores, cartões inteligentes e etc.

O Java é reconhecido como a principal linguagem no mundo dos Servidores de

Aplicações e ambiente sem fio (wireless).

Introdução a linguagem Java




Versão: 3.0


7

•Orientação a objetos: A linguagem é orientada a objetos a partir

de sua arquitetura, permitindo herança, polimorfismo,

encapsulamento, abstração de dados, persistência de objetos e

reúso de código.;

Independência de plataforma (Portabilidade): Possibilidade do

mesmo código fonte ser executado em diversos sistemas

operacionais, tais como Solaris, AIX, Linux, MacOS, Win32,

PalmOS, OS/390 e etc);

Dinamismo: A natureza dinâmica do Java, sendo uma extensão

natural de seu projeto orientado a objetos, permite a extensibilidade

durante a execução.

Alto desempenho: Suporte a vários recursos, como

multithreading, compilação em Jus-in-time, atomicidade do código e

suporte a protocolos de rede (TCP/IP)

Facilidade de manutenção de programas.

A linguagem não tem:

Ponteiros do sistema operacional;

Defines;

Sobrecarga de operadores;

Herança múltipla de classes e

Função e/ou procedure.

Principias características:

Cargabe Collection (gerenciamento dinâmico da memória);

Java Virtual Machine (JVM);

Código seguro.

O que é o Java?

Java é:

Uma linguagem de programação;

Um ambiente de desenvolvimento;

Um ambiente de aplicação;

Java é o resultado de uma busca por uma plataforma de

programação que pudesse fornecer segurança, portabilidade

(independência de sistema operacional) e escalabilidade.

Os primeiros objetivos alcançados com o desenvolvimento desta

nova linguagem foram:





Versão: 3.0


8

Diferenças entre o Java e o C++

Java é sintática e morfologicamente muito parecido com a linguagem C++,

entretanto, existem diferenças:

Inexistência de aritméticas de ponteiros (ponteiros são apenas referências);

Arrays são objetos;

Strings são objetos;

Gerenciamento automático de alocação e deslocação de memória (Garbage

Collection);

Não há sobrecarga de operadores;

Não há métodos com lista de argumentos de tamanho variável;

Não existem diretivas de pré-compilação (#define, #ifde);

Não existem Templates;

Não existe Herança Múltiplas com classes, apenas com interfaces;

Não existem funções, mas apenas métodos de classes;

Necessita de ambiente de execução (runtime), ou seja, a JVM (Java Virtual

Machine).


public class Hello

{

public static void main (String arg [])

{

System.out.println("Hello” + “\n”);

}

}

#include <iostream.h>

int main ()

{

cout << “Hello \n" ;

return 0;

}

Java

C++

Veja abaixo um exemplo de um simples programa escrito em Java e em C++.




Versão: 3.0


9

Portabilidade: “A independência de plataforma”

O Java é independente de plataforma. Isto significa que o desenvolvedor não terá que

se preocupar com particularidades do sistema operacional ou do hardware, focando o

seu esforço no código em si. Mas o que isto realmente significa?

Na maioria das linguagens é preciso gerar uma versão para cada plataforma que se

deseja utilizar, exigindo em muitos casos, alterações também no código fonte. Em Java

o mesmo programa pode ser executado em diferentes plataformas. Veja o exemplo

abaixo:

?

O mesmo código fonte


public class HelloWorldApp{public static void main (String arg []){

System.out.println("Hello World!");}

}

Compilação:

> javac Hello.java

Execução:

> java Hello

Sistema Operacional e

Processadores diferentes

Hello

World

Hello

WorldHello

World

"write once, run anywhere."




Versão: 3.0


10

Gerando Aplicações

Para criarmos aplicações ou programas na linguagem Java temos que executar os

alguns passos: Edição, Compilação e Interpretação.

A Edição é a criação do programa, que também é chamado de código fonte.

Com a compilação é gerado um código intermediário chamado Bytecode, que é um

código independente de plataforma.

Na Interpretação, a máquina virtual Java ou JVM, analisa e executa cada instrução do

código Bytecode.

Na linguagem Java a compilação ocorre apenas uma vez e a interpretação ocorre a cada

vez que o programa é executado.

Javac myProgram.java

Java myProgram

1

2

3





Versão: 3.0


11

Instalação do ambiente de desenvolvimento (JDK)

O Java Development Kid (JDK) é conjunto de ferramentas para compilar, depurar,

executar e documentar um programa escrito em java.

As versões para Solaris, Linux e Windows podem ser obtidas no endereço:

www.java.sun.com (Página oficial da linguagem).

Procedimentos de Instalação:

Para instalar o JDK, basta executar o programa de instalação e seguir as instruções.

Caso o JDK esteja compactado será necessário descompactá-lo primeiro, os formatos

mais populares de arquivos compactados são zip (para Windows) e tar (para Unix).

Após a instalação é necessário configurar o ambiente:

No windows: Acrescentar no Autoexec.bat:

SET JAVA_HOME=C:\JDK1.3

PATH=%JAVA_HOME%\bin

A variável JAVA_HOME deve ter o mesmo nome do diretório onde foi instalado o JDK.

O próximo passo é instalar a documentação, ela geralmente está em arquivo

compactado, ao descompacta-la selecionar a unidade de disco, por exemplo: “C:\”,

pois, o diretório padrão da documentação (docs) já está definido no arquivo

compactado. Caso você tenha instalado o JDK em outro diretório que não seja o

padrão, você deverá especificar no momento da instalação. A documentação está

no formato HTML, o arquivo principal o index.html.


Classpath

O Java defini uma variável de ambiente chamada ClassPath. O Java procura pelas

classes e pacotes através desta variável. Ela deve estar no Autoxecec.

Veja um exemplo: Set classpath=,;c:\JDK1.3;c:\MeusPacotes




Versão: 3.0


12


documentação

bin:

Onde estão todos os arquivos necessários para compilar (javac), depurar (jdb) e

executar (java).

demo:

Onde estão os arquivos de demonstração e exemplos da linguagem Java.

docs:

Onde está a documentação do ambiente da Linguagem Java no formato HTML

include:

Onde estão os arquivos escritos em linguagem C, os “header”, que são usados na

integração de Java e a Linguagem C.

Include-old:

Onde estão os arquivos escrito em linguagem C, os “header”, entretanto, os arquivos

são de versão mais antiga.

jre:

Ambiente de execução do Java necessário para distribuir a aplicação aos clientes.

lib:

Onde estão as bibliotecas Java, também chamadas de APIs. A extensão dos arquivos

é .jar.

Resumo:

Após a instalação, você deverá ter uma estrutura de diretórios como aparece na

figura:





Versão: 3.0


13


A figura demonstra uma visão do pacote de desenvolvimento JDK e também do

ambiente de execução (JRE). Ambos são necessários para desenvolver uma aplicação.

Para os clientes, os usuários finais, precisam apenas do ambiente de execução JRE.

Aplicativos como os Applets executam através do Browser (Internet Explorer ou

Netscape) geralmente a VM que está embutida nestes navegadores.

Ambiente para os desenvolvedores

Ambiente necessário nos

Clientes (usuários finais)

Sistema Operacional





Versão: 3.0


14

O Compilador javac

Argumento Descrição

-classpath path Localização das classes. Sobrepõe a variável de ambiente

Classpath.

-d dir Determina o caminho onde as classes compiladas sãoarmazenadas

-deprecation Faz a compilação de código em desuso, geralmente de versõesanteriores e faz aviso de advertência

-g Gera tabelas de "debugging" que serão usadas pelo pelo

deupador JDB.

-nowarm Desabilita as mensagens de advertência

-verbose Exibe informações adicionais sobre a compilação

-O Faz otimização do código

-depend Faz a compilação de todos os arquivos que dependem do arquivoque está sendo compilado. Normalmente somente é compilado o

arquivo fonte mais as classes que este invoca.

Sintaxe: javac [opções] NomedoArquivo.java

Veja abaixo a lista dos principais argumentos:

Exemplos:

> javac Hello.java

> javac -d . Hello.java

> javac -deprecation Hello.java

> javac -O -deprecation -verbose Hello.java

> javac -O Hello.java





Versão: 3.0


15

O Interpretador java


-classpath path Localização das classes. Sobrepõe a variável de ambiente Classpath.

-help Exibe a lista de opções disponíveis

-version Exibe a versão do interpretador

-debug Inicia o interpretador no modo de "debug", geralmente em conjunto

com JDB.

-D propriedade= valor

Possibilita redefinição de valores de propriedades. Pode ser usado

várias vezes.

-jar Indica o nome do arquivo (com extensão .jar) que contém a classe a ser

executada.

-X Exibe a lista de opções não padronizadas do interpretador

-v ou -verbose Exibe informações extras sobre a execução, tais como, mensagens

indicando que uma classe está sendo carregada e etc

Lista de

Argumentos

Define a lista de argumentos que será enviada a aplicação

Sintaxe: java [opções] NomedoArquivo [lista de Argumentos]

Veja abaixo a lista das principais opções:

Alguns Exemplos:

> java Hello

> javac -version

> java -D nome=“Meu Nome” Hello

> java -verbose Hello

> javac Hello MeuNome





Versão: 3.0


16

Java Virtual Machine

A JVM é parte do ambiente de "runtime" Java e é a responsável pela

interpretação dos bytecodes (programa compilado em java), ou seja, a execução

do código.

A JVM consiste em conjunto de instruções, conjunto de registradores, a pilha

(stack) , garbage-collected heap e a área de memória (armazenamento de

métodos).

Funcões da JVM:

Carregar de forma segura todas as classes do programa (protegendo contra

ataques premeditados, por exemplo, Cavalos de Tróia)

Verificar se os bytecodes aderem às especificações da JVM e se não violam a

integridade e segurança da plataforma.

Interpretar o código.

Em tempo de execução estes bytecodes são carregados, são verificados através

do Bytecode Verifier (uma espécie de vigilante) e somente depois de verificados

serão executados.

J

V

M

Programa

Compilado

Programa

Fonte

Javac <programafonte.java>

Class Loader

Byte Code Verifier

Runtime

Java <programafonte>





Versão: 3.0


17

Coletor de Lixo:

A linguagem Java tem alocação dinâmica de memória em tempo de execução.

No C e C++ (e em outras linguagens) o programa desenvolvido é responsável pela

alocação e deslocamento da memória. Isto geralmente provoca alguns problemas.

Durante o ciclo de execução do programa, o Java verifica se as variáveis de

memória estão sendo utilizadas, caso não estejam o Java libera automaticamente

esta área para o uso.

Garbage Collection





Versão: 3.0


18

Escrevendo um pequeno programa

1 - Abra o editor de programas e crie o seguinte programa.

public class Hello

{


{ String s = "world";

System.out.println("Hello " + s);

}

}

2 - Salvar como: Hello.java

Após terminar:

3 - Compile o programa com o seguinte comando:

javac Hello.java

4 - Para executar digite o comando:

java Hello

Está pronto o primeiro programa em Java. Fácil!





Versão: 3.0


19


public class Hello

{




}

}

modificador

Nome da classe

Método

principal

Classe

(corresponde

ao arquivo

que será gravado

do disco)

Classe java

método

Lista de argumentos

(o tipo em questão é String)

Tipo de dado

Variável

Roteiro para criar um programa em Java:

1 - Fazer a assinatura da classe, isto equivale a declaração:

public class NomedaClasse {

2 - Declarar as variáveis, também chamadas de fields:

int i =0 ;

Neste caso não temos nenhum variável de classe ou field

3 - Fazer a assinatura dos métodos:

public static void main (String args[]){

4 - Escrever o corpo do método:

String s= “world”;

System.out.println(“Hello” + s);

5 - Para encerrar o método, note que o corpo do método está entre chaves “{...}“.

}

6 - Para encerrar a classe, segue o mesmo princípio do método. Use chaves “}“.

7 - Salve o arquivo. Observe que o nome do arquivo deve ser o mesmo nome da

classe.

Hello.java

8 - Compilar o programa. Sintaxe: javac <NomedaClasse.java>.

Javac Hello.java

9 - Agora execute o arquivo. Sintaxe: java <NomedaClasse>

Java Hello


Atributo da

Classe System

Dissecando o código




Versão: 3.0


20



Não deu certo ???

Veja se este pequeno “Checklist” pode ajudar:

1 - Problemas com compilação: Veja o Classpath;

2 - Se o compilador não consegue encontrar o arquivo:

Verifique se o nome da classe e o nome do arquivo gravado em

disco são correspondentes, lembre-se que o java faz distinção

entre maiúscula e minúscula;

3 - Erros de sintaxes:

Verifique se os pares chaves estão corretos, ou seja, deve ter

um par para classe,

outro para cada método e para cada bloco de declarações.

Verifique se não há instruções erradas, como string quando o

correto é String (é uma classe), system ao invés de System

Verifique se há ponto e virgula “;” no final de cada instrução.




Versão: 3.0


21




Versão: 3.0


22

Fundamentos da Linguagem Java

Estrutura da Linguagem

Comentários:

Temos três tipos permitidos de comentários nos programas feitos em Java:

• // comentário de uma única linha

• /* comentário de uma ou mais linhas */

• /** comentário de documentação */ (este tipo de comentário é usado pelo utilitário

Javadoc, que é responsável por gerar documentação do código Java)

Exemplo Descrição

int x=10; // valor de x Comentário de linha

/*

A variável x é integer

*/int x;

Exemplo onde o comentário usa mais que uma linha.

Todo o texto entre "/*" e "*/", inclusive, são ignorados pelo

compilador

/**

x -- um valor inteiro representa

a coordenada x*/

int x;

Todo o texto entre o "/**" e "*/", inclusive, são ignorados

pelo compilador mas serão usados pelo utilitário javadoc.

Ponto e vírgula, Blocos e o espaço em branco:

• No Java, os comandos são terminados com o sinal de ponto e vírgula (;)

• Um bloco tem início e fim representados pelo uso das chaves { };

• O uso do espaço em branco permite uma melhor visualização dos comandos e em

conseqüência facilita a sua manutenção.

Exemplo:

Bloco da Classe

public class TestEstrutura

{

public void sayHello(String hello)

{

System.out.println("Hello ");

}

}

Bloco do MétodoPonto e virgula




Versão: 3.0


23


Estrutura da Linguagem

Identificadores:

Que são identificadores ?

Identificadores são nomes que damos as classes, aos métodos e as variáveis.

Regra: Um identificador deverá ser inicializado com uma letra, sublinhado ( _ ), ou

sinal de cifrão ($). Em Java existe uma diferença entre letras maiúsculas e

minúsculas. Veja alguns exemplos:

Classe é diferente de CLASSE

classe é diferente de Classe

Exemplos de identificadores::

Alguns identificadores válidos:

- identifier - userName - User_name - _sys_var1 - - $change

Exemplo: public class PessoaFisica

Veja alguns inválidos:

- 1nome - \TestClass - /metodoValidar

public class Hello

{




}

}

Identificador

(nome da classe)

Método

principalClasse

Identificador

(nome do método)

Veja que primeiro

foi definido

o tipo de dado,

String, e depois o

nome do Identificador

(nome do variável)

--------------------------- Compiler Output ---------------------------

TestIdentificador.java:3: illegal start of type

private 1nome;

Veja o código abaixo onde são apontados os identificadores




Versão: 3.0


24

Palavras Reservadas abstract do implements private throw boolean double import protected throws break else instanceof public transient byte extends int return true case false interface short try catch final long static void char finally native super volatile class float new switch while continue for null synchronized default if package this

Palavras Reservadas


As Palavras Reservadas, quer dizer que nenhuma das palavras da lista acima podem ser

usadas como identificadores, pois, todas elas foram reservadas para a Linguagem Java.

Veja o exemplo abaixo:

public class TestPalavraReservada

{

private int return =1;

public void default(String hello)

{

System.out.println("Hello ");

}

}

Este programa provocará erros ao ser compilado:

--------------------------- Compiler Output ---------------------------

TestEstrutura.java:3: <identifier> expected

private int return =1;

^

TestEstrutura.java:6: <identifier> expected

public void default(String hello)

Palavra reservada

Palavra reservada




Versão: 3.0


25

Tipos de Dados

Existem tipos básicos ou primitivos e os tipo de referência.

Sintaxe padrão:

<Tipo de dado> <nome da variável>; ou

<Tipo de dado> <nome da variável> = valor da variável;

<Tipo de dado> <nome da variável> = valor da variável, <nome da variável> =

valor da variável... ;

Tipo Lógico - boolean: true e false

Exemplo boolean fim = true;

Tipo Textual - char e String (String é uma classe)

Um caracter simples usa a representação do tipo char. Java usa o sistema de

codificação Unicode (Veja Apêndice B). Neste sistema o tipo char representa um

caracter de 16-bit.

O literal do tipo char pode ser representado com o uso do („ „). Exemplos:

a = „b‟;

„\n‟ – nova linha

„\r‟ – enter

„\u????‟ – especifica um caracter Unicode o qual é representado na

forma Hexadecimal.

„\t‟ – tabulação

„\\‟ - \

„\” ”‟ - “”

String (String é uma classe)

O tipo String é um tipo referência que é usado para representar uma seqüência de

caracteres.

Exemplo:

String s = “Isto é uma string”, s1;

Inteiros – byte, short, int e long

Possuem somente a parte inteira, ou seja, não suportam casas decimais.

Exemplos:

int i1 = 10, int i2 = 11;

byte b = 1;

Código de escape





Versão: 3.0


26

Ponto Flutuante

São os tipos que têm suporte às casas decimais e maior precisão numérica.

Existem dois tipos em Java: o float e o double.

Veja alguns exemplos:

3.14 Um ponto flutuante simples;

6.02E23 Um valor de ponto flutuante largo;

2.718F Um valor de ponto flutuante simples;

123.4E+306D Um valor de ponto flutuante usando o tipo double.

Exemplos de declarações:

float f = 3.1;1

float div = 2.95F;

double d1 = 6.35, d2 = 6.36, d3 = 6.37;

double pi = 3.14D

Regra:

Os tipos float e double quando aparecem no mesmo programa é necessário

identificá-los, para que não comprometa a precisão numérica:

float f = 3.1F;

double d = 6.35;

Uma vez não identificado, ao tentar compilar o programa, será emitida uma

mensagem de erro.

Tamanho Tipo Faixa

8 bits byte -128 a 128

16 bits short -32.768 a 32.767

32 bits int -2.147.483.648 a 2.147.483.647

64 bits long 9.223.372.036.854.775.808 a

9.223.372.036.854.775.807

Tamanho Tipo Faixa

32 bits IEEE 754-1985 Float 1,4E-45 a 3,4E+38

64 bits IEEE 754-1985 Double 4,9E-324 a 1,7E+308


Tipos de Dados

Precisão

7 dígitos

15 dígitos

Nota (1) Toda vez que uma variável tipo float não tem a literal F, esta variável internamente é tratada como se fosse um inteiro




Versão: 3.0


27

Inicialização de variáveis


Não é permitido o uso de variáveis indefinidas ou não inicializadas.

Exemplo:

int i;

int a = 2;

int c = i + a;

Neste caso ocorre erro, pois, o valor de i está indefinido.

As variáveis definidas dentro do método são chamadas de variáveis automáticas,

locais ou temporárias e devem ser inicializadas antes do uso.




Versão: 3.0


28

Operadores

Os operadores na linguagem Java, são muito similares ao estilo e funcionalidade

de outras linguagens, como por exemplo o C e o C++.

Exemplos:

int a = 1;

int b = a + 1;

int c = b - 1;

int d = a * b;

short s1 = -1;

short s2 = 10;

short s1++;

int c = 4 % 3;

Operadores Lógicos:

> Maior que

< Menor que

<= Menor que ou igual

>= Maior que ou igual

== Igual

!= Diferente

Exemplos:

i > 10;

x == y;

“Test” != “teste”

!y

x || y

Operadores Matemáticos:

+ Adição

- Subtração

* Multiplicação

/ Divisão

++ Incremento

-- Decremento

% Módulo- Negativo (unário)

+ Positivo (unário)

! Not (negação) && And || OR





Versão: 3.0


29

Outros Operadores:

instanceof Faz a comparação do objeto que está “instanciado” no objeto

Exemplos:

instanceof:

Objeto obj = new String(“Teste”);

if (obj instanceof String) System.out.println(“verdadeiro”)

new:

Hello hello = new Hello();

Precedências de Operadores:

. [ ] ( )

++ - ! ~ instanceof

new (type) expressão - O type é coerção de tipo

* / %

+ -

<< >> >>>

Exemplo:

Com a precedência definida pelo Java

int c = 4 / 2 + 4;

Neste caso, primeiro ocorrerá a divisão e após a soma.

Com a precedência definida pelo desenvolvedor

int a = 4 / (2 + 4);

Já neste caso, primeiro ocorrerá a soma e depois a divisão.

new Este operador é usado para criar novas “instance” de classes


Operadores




Versão: 3.0


30

Operador Nome Descrição

& AND sobre bits Os bits no resultado são configurados como 1 se os bits

correspondentes nos dois operandos forem ambos 1

| OR inclusive sobre

bits

Os bits no resultado são configurados como 1 se pelo menos um

dos bits correspondentes nos dois operandos for 1

^ OR exclusivo sobre

bits

Os bits no resultado são configurados como 1 se somente um dos

bits correspondentes nos dois operandos for 1

<< Deslocamento para

esquerda

Desloca os bits do primeiro operando para a esquerda pelo número

de bits especificado pelo segundo operando; preenche a partir da

direita com bits 0.

>> Deslocamento para

direita com extensãode sinal

Desloca os bits do primeiro operando para a direita pelo número

de bits especificado pelo segundo operando. Se o primeirooperando for negativo, preenche com 1s a partir da esquerda; caso

contrário, preenche com 0s a partir da esquerda.

>>> Deslocamento para

direita com extensão

de zero

Desloca os bits do primeiro operando para a direita pelo número

de bits especificado pelo segundo operando; 0s são inseridos a

partir da esquerda

~ Complemento de um Todos os bits são configurados como 1 e todo os bits são

configurados como 0.

Java fornece extensa capacidade de manipulação de bits. Todos os dados são

representados internamente como uma seqüência de bits. Cada bit pode assumir o

valor de 0 ou 1. No geral uma seqüência de bits formam um byte, que é a unidade de

armazenamento padrão, para uma variável tipo byte. Os tipos de dados são

armazenados em quantidade maiores que byte. Os operadores sobre os bits são

utilizados para manipular os bits de operandos integrais (isto é aqueles do tipo byte,

char, short, int e long).

Manipulação de bits e os operadores sobre bits

Exemplos de manipulação do bits:

Right Shift (>>)

128 >> 1 <=> 128/21 = 64

256 >> 4 <=> 256/24 = 16

-256 >> 1 <=> -256/24= -16

Left Shift (<<)

128 << 1 <=> 128 * 21 = 256

16 << 2 <=> 16 * 22 = 64


Operadores

Operadores Binários:




Versão: 3.0


31

Podemos realizar operações de Pré e Pós incremento e de Pré e Pós decremento.

Veja os exemplos:

Pré-incremento:

Pré-incremento = ++a; Exemplo: a = 10, b = 11, c = a + ++b => c = 22

Pós-incremento = a++; Exemplo: a = 10, b = 11, c = a + b++ => c = 21

Pós-decremento:

Pré-decremento = --x; Exemplo: x = 1, y = 1, z = x + --b => z = 1

Pós-decremento = x--; Exemplo: x = 1, y = 1, z = x - b-- => z = 0

Observe que isto ocorre devido a precedência de operadores. Primeiro é feito a

atribuição e depois o incremento.

Operador Exemplo Equivalência

++ x++, ++x x = x + 1

-- x--, --x x = x - 1

+= x += y x = x + y

-= x -= y x = x - y

*= x *= y x = x * y

/= x /= y x = x / y

&= x &= y x = x & y

|= x |= y x = x | y

^= x ^= y x = x ^ y

%= x %= y x = x % y

Lista de

Exemplos


Operadores

Exemplo:

public class TesteOperador {

public static void main(String args[]) {

int x = 1;

int y = 1;

int z = x - y--;

System.out.println("o valor z: " + z);

}

}




Versão: 3.0


32

public class TestString

{ public static void main(String arg[])

{

String s1 = "Hello";

String s2 = new String("hello");

//equals

if (s1.equals(s2))

{ System.out.println("São iguais"); }

else

{ System.out.println("São Diferentes"); }

//equalsIgnoreCase

System.out.println("equalsIgnoreCase");

if (s1.equalsIgnoreCase(s2))

{ System.out.println("São iguais"); }

else

{ System.out.println("São Diferentes"); }

//Alguns métodos

//indexOf, charAt, substring

String frase = "Vovo viu a uva";

System.out.println("Posição: " + frase.indexOf('a'));

System.out.println("Nova frase: " + frase.substring(0,4));

System.out.println("A letra é: " + frase.charAt(5));

//concat

String nome = "James ”; String sobrenome = "Gosling ";

String nomeCompleto = nome.concat(sobrenome);

System.out.println("O nome é: " + nomeCompleto);

}

}

Exemplo:

String

A classe String

Objetos String são sequências de caracteres Unicode

Exemplo: String nome = “Meu nome”

Principais métodos:

Substituição: replace,

Busca: endWiths, startsWith, indexOf e lastIndexOf

Comparações: equals, equalsIgnoreCase e compareTo

Outras: substring, toLowerCase, toUpperCase, trim, charAt e length

Concatenação: concat e operador +

Exemplo: O operador + é utilizado para concatenar objetos do tipo String,

produzindo uma nova String:

String PrimeiroNome = “Antonio”;

String SegundoNome = “Carlos”;

String Nome = PrimeiroNome + SegundoNome





Versão: 3.0


33

public class TestStringBuffer

{

public static void main(String arg[])

{

//new instance

StringBuffer b1 = new StringBuffer();

StringBuffer b2, b3;

b2 = new StringBuffer(25);

b3 = new StringBuffer("Teste, ");

/*para exibir o conteúdo é necessário

usar o método toString */

System.out.println("b1:" + b1.toString() );



b3.append("vamos testar novamente");


b3.insert(0, "A x B ");


b3.delete(0,4);


b2.append("Teste b2");

System.out.println("b2 Capacidade: " + b2.capacity());

System.out.println("b2 Tamanho: " + b2.length());

b2.append(b3);

System.out.println("b2: " + b2.toString() );

System.out.println("b2 tamanho: " + b2.length() );

System.out.println("b2 invertida: " + b2.reverse() );

}

}

Exemplo:

Objetos StringBuffer são uma seqüência mutável de caracteres Unicode

Construtores:

StringBuffer – Cria um buffer vazio

StringBuffer(int capacidade) – Cria um buffer com a capacidade especificada

StringBuffer(String initialstring) – Cria um buffer contendo uma string informada.

Principais métodos: append, insert, delete, ...


StringBuffer

Várias formas

de declaração

Usando os métodos

para manipular

o objeto StringBuffer




Versão: 3.0


34

Casting (coerção de tipos)

byte

int

charshort

long

float

double

Conversão

Explícita

Conversão

Implícita

Java faz a promoção de tipos para garantir que os valores sejam suportados pelas

faixas, contudo, a linguagem Java não suporta conversões arbitrárias de tipos de

variáveis.

Devemos explicitar a conversão entre tipos de variáveis. Veja o exemplo abaixo:

public class TestCasting

{

public static void main(String args[])

{

byte a = 1;

byte b = 3;

byte c = a + b;

/* Linha errad, pois a operação adição

sofre casting implicita */

//Correção o casting explicito

byte c = (byte) (a + b);

System.out.println(c);

}

}

Casting implícito

Por força do operador

matemático o Java promoveu a

valor resultante de a + b para

um valor inteiro, o que provoca

estouro da faixa de byte, e por

sua vez provoca um erro

Casting explícito

após a soma de a + b, o valor

da soma é convertido para byte

Hierarquia de conversão:





Versão: 3.0


35

Objetos

Os objetos não são convertidos, mas sim suas referências. Uma referência de uma

classe qualquer pode ser sempre usada para fazer referência a um objeto de uma de

suas subclasses. Quando isso acontece, a referência somente poderá ser utilizada

para acesso aos membros da classe, ficando os membros da subclasse

“inacessíveis”, embora com seus valores mantidos. A conversão desse tipo (de

subclasse para classe) é chamada de implícita.

Veja os exemplos abaixo:

import java.awt.*;

public class CastObjeto

{

public CastObjeto()

{

Window janela = new Frame();

janela.pack();

janela.setTitle("Titulo da Janela");

...

}

}

Conversão ilegal, pois, o

objeto janela não “enxerga”

os métodos de Frame,

embora o método exista,

pois o objeto

é do tipo Frame

Window

Frame

SuperClasse

SubClasse

Hierarquia de classes:






Versão: 3.0


36

Casting ( Conversão de tipos ) Objetos

import java.awt.*;

public class CastObjeto

{

public CastObjeto()

{

Window janela =new Frame();

Frame janela1 = (Frame) janela;

janela1.setTitle("Titulo da Janela");

}

}

Conversão legal, pois, a

janela é um objeto do

tipo Frame e está sendo

atribuído a uma referência

do mesmo tipo

A conversão contrária, ou seja, de referência a classe para referência a subclasse, é

possível. Entretanto, essa conversão somente será válida se a referência à subclasse

passar a apontar para um objeto compatível com ela.

SuperClasse

SubClasseConversão

implícita

Conversão

explícita

As Interfaces seguem a mesma regra das classes.






Versão: 3.0


37

Casting Exemplo:

public class TestCasting

{


{

//Exemplo 1

byte a = 1;

byte b = 3;

/*Linha errada, pois a operação adição

sofre casting implicita */

//byte c = i + i;


byte c = (byte) (a + b);

System.out.println(c);

//Exemplo 2

int ia = 1;

long lb = 3;

/*

Perda de Precisão - causa erro

*/

//int ic = ia + lb; //linha errada -> Casting


int ic = ia + (int) lb;

System.out.println(ic);

}

}

O resultante da soma foi promovido

para tipo int, quando atribuímos a

variável , que é do tipo byte, a

operação provoca erro, pois, a faixa

de byte é menor que a faixa de int.

Uma vez aplicado o casting a

operação de soma é realizado e

depois é convertida para o type byte.

Casting explícito:

(byte) (a + b)

Casting implícito: (a + b)






Versão: 3.0


38

Fluxo de Controle

Java como qualquer outra linguagem de programação, suporta instruções e laços

para definir o fluxo de controle. Primeiro vamos discutir as instruções condicionais

e depois as instruções de laço.

Antes, porém, vamos entender a necessidade dos blocos. Um bloco é o conjunto

de instruções delimitadas por chaves “{... }”. Exemplo:

{

int i = 10;

System.out.println(“Hello”);

i++

}

bloco

Os blocos povoam métodos, instruções condicionais, laços e etc, ou seja,

podemos encontrá-los sempre dentro de um programa Java.

Construções condicionais:

if (<expressão boolean>)

<declarações>...

else

<declarações>...

switch (<expressão>) {

case <expressao char-int>:

<declarações>...

break;

case <expressao char-int>:

<declarações>...

default:

<declarações>...

}

(<expressão boolean>) ? <expressão if-true>

: <expressão if-false>





Versão: 3.0


39

A instrução if

Sintaxes: if (expressão boolean) instrução

Exemplo: if (x>y) System.out.println(x);

if (expressão boolean) { //Bloco de instruções }

Exemplo: if (x>y) {

System.out.println(x);

y++;

}

if (expressão boolean)

{ //Bloco de instruções }

else


Exemplo: if (x>y) {


y++;

}

else {

System.out.println(y);

x++;

}

if (expressão boolean)


else if (expressão boolean)






else


Mais de uma instrução

é usado a estrutura de

bloco


Fluxo de Controle




Versão: 3.0


40

A instrução if

Sintaxes: (continuação)

Exemplo: if (x>y) {


y++;

}

else if (x<y) {


x++;

}

else {



}

Notamos que a instrução if pode ser utilizada de várias formas, ela pode ser

aplicada de acordo com o contexto.

O exemplo abaixo demonstra a estrutura mais popular da instrução if, ou seja, if

(expressão lógica) then {...} else {... }. Veja a lógica e também a implementação

do código:

saldo > 0

status = Negativo

status = Positivosim

não

Lógica

if (saldo > 0)

{

status = “Positivo”;

}

else

{

status = “Negativo”;

}

Código


Fluxo de Controle

if (saldo > 0)

status = “Positivo”;

else

status = “Negativo”;

OU




Versão: 3.0


41

A instrução if

Neste exemplo apresentaremos a instrução if com múltiplas opções. Veja a

lógica e também a implementação da do código:

saldo médio

> 5000

sim

não

Lógica

public class ifCompostoExemplo

{


{

int limitecheque;

int saldomedio = 15000;

if (saldomedio > 5000)

{

limitecheque = 1000;

}

else if (saldomedio > 3000 &&

saldomedio <= 5000)

{

limitecheque = 800;

}


saldomedio <= 3000)

{

limitecheque = 600;

}


saldomedio <= 2000)

{

limitecheque = 400;

}

else

{

limitecheque = 0;

}

System.out.println("Limite cheque

especial..." + limitecheque);

}

}

Código

saldo médio >

3000 and <=5000

saldo médio >

2000 and <= 3000

Limite cheque

=1000

Limite cheque

=800

Limite cheque

=600

sim

sim

não

Limite cheque

=0

não

saldo médio >

1000 and <= 2000

simLimite cheque

=400

não


Fluxo de Controle




Versão: 3.0


42

A instrução switch

Switch é uma alternativa para seleção múltipla de escolha, entretanto, ela tem

algumas diferenças da estrutura if - if else. Como, por exemplo, o tipo de dado

válido na expressão é somente do tipo char e os tipos inteiros (int, byte, short,

long).

Sintaxes:

switch (expressao char-integer)

{

case expressao1:

// instruções

case expressao2:

// instruções

case expressao3:

// instruções

default:

// instruções

}

Exemplo:

public class switchSimplesExemplo

{


{

char opcao = 'a';

String selecao = "";

switch (opcao)

{

case 'a':

selecao += „a‟;

case 'b':

selecao += 'b';

case 'c':

selecao += 'c';

default:

selecao += "d";

}

System.out.println(selecao);

}

}

Será impresso “abcd”

Após a impressão do valor, achamos mais uma diferença em relação ao if - if

else, a instrução Switch executa todas as opções após uma opção válida. Por

exemplo, se valor inicial da variável opção for igual „c‟, teremos o seguinte

resultado para a variável selecao = „cd‟.

A instrução switch


Fluxo de Controle




Versão: 3.0


43

Fundamentos da Linguagm Java

A instrução switch.

Para que a instrução switch execute apenas uma opção, desprezando as demais é

necessário incluirmos a instrução break. Bem como o próprio nome da instrução

sugere este sai da instrução switch.

Sintaxes:

switch (expressao char-integer)

{

case expressao1:

// instruções

break;

case expressao2:

// instruções

break

case expressao3:

// instruções

break

default:

// instruções

}

public class switchBreakExemplo

{


{

char opcao = 'b';


switch (opcao)

{

case 'a':

selecao += 'a';

break;

case 'b':

selecao += 'b';

break;

case 'c':

selecao += 'c';

break;

default:

selecao += "d";

}


}

}

Será impresso “b”

A instrução switch com

a instrução break

Note que tanto a instrução default quanto a break são opcionais, depende da

lógica a utilizada.


Fluxo de Controle




Versão: 3.0


44


Neste exemplo apresentaremos a instrução switch e a instrução break com

múltiplas opções. Veja a lógica e também a implementação do código:

case 10sim

não

Lógica

public class switchCompostoExemplo

{


{

String avaliacao ="";

int nota = 8;

switch (nota)

{

case 10:

avaliacao = "Excelente";

break;

case 9:

avaliacao = "Ótimo";

break;

case 8:

avaliacao = "Bom";

break;

case 7:

avaliacao = "Satisfatório";

break;

default:

avaliacao = "Regular";

}

System.out.println("Avaliação: "

+ avaliacao);

}

}

Código

case 9

case 8

avaliacao =

“Excelente”

avaliacao =

“Ótimo”

avaliacao =

“Ótimo”

sim

sim

não

avaliacao =

“Regular”

não

case 7sim

avaliacao =

“Ótimo”

não


Fluxo de Controle




Versão: 3.0


45


Neste exemplo apresentaremos a instrução switch sem o break com múltiplas

opções. Veja a diferença:

case S

sim

não

Lógica

public class switchSemBreakExemplo

{


{

char opcao = 'B';


switch (opcao)

{

case 'S': //Super luxo

selecao += " Ar condicionado +";

case 'L': //Luxo

selecao += " Direção hidráulica +";

case 'B': //Básico

selecao += " Trio Elétrico +";

default:

selecao += " Alarme";

}


}

}

Código

Ar condicionado

sim

sim

não

Alarme

não

case L Direção hidráulica

case S Trio Elétrico


Fluxo de Controle




Versão: 3.0


46

Operador Ternário

E por fim o operador ternário, Java, oferece uma maneira simples de avaliar uma

expressão lógica e executar uma das duas expressões baseadas no resultado.

O operador condicional ternário (?:). É muito parecido com a instrução iif()

presente em algumas linguagens, Visual Basic, por exemplo.

Sintaxe:

(<expressão boolean>) ? <expressão true> : <expressão false>

ou

variável = (<expressão boolean>) ? <expressão true> : <expressão false>

saldo > 0

status = Negativo

status = Positivosim

não

Lógica

{

...

Status = (saldo > 0)?

”Positivo”:“Negativo”;

...

}

Código

Neste exemplo apresentaremos uma expressão condicional simples. Veja a

lógica e implementação do código. Faça uma comparação com a instrução if-else.

Lembre-se que podemos aninhar operadores e condições, pois, todos suportam

a recursividade.


Fluxo de Controle




Versão: 3.0


47

Laços

O que são laços?

Laços são repetições de uma ou mais instruções até que uma condição seja

satisfeita. A linguagem Java tem dois tipos de laços: os finitos e os infinitos.

Para os laços finitos a execução está atrelada a satisfação de uma condição, por

exemplo:

Laços:

while (<boolean-expression>)

<statements>...

do

<statements>...

while (<boolean-expression>);

for (<init-stmts>...; <boolean-expression>; <exprs>...)

<statements>...


Fluxo de Controle

Já os infinitos estes executarão sempre, independente de condição.

Se o valor da variável a não for igual

10.

então

incrementar um na variável

senão

imprimir a variável valor

Isto quer dizer que a instrução de

incremento vai repetir dez vezes.

true a++

Em Java, temos três instruções que suportam laços ou “loops”. São elas:

while, do-while e for.

a = 10 a++

sim

não

Imprimir a




Versão: 3.0


48

A instrução while.

Ela executa uma instrução ou bloco de instruções, enquanto uma determinada

condição não for satisfeita. Ela faz a validação antes de executar as instruções.

Sintaxe:

while (expressao boolean)

instrução java

Exemplo:

public class whileExemplo2

{


{

int d = 10;

while (d >= 0)

System.out.println("Contagem Regressiva " + d--);

}

}

Este código será executado 10

vezes, ou seja até a condição

ser satisfeita

Sintaxe:

while (expressao boolean)

{

//Bloco

}

Exemplo:

public class whileExemplo

{


{

int d = 1;

while (d<= 10)

{

System.out.println("7 x " + d + " = " + 7*d);

d++;

}

}

}

Este código produzirá a Tabuada do 7

Neste exemplo o laço é finito, ou seja, irá

executar até a condição estar satisfeita

A instrução while


Fluxo de Controle




Versão: 3.0


49


Os exemplos abaixo demonstram como tornar um laço infinito usando a instrução

while, provavelmente isto não deverá acontecer, todavia, pode ser um pequeno erro

de lógica, inversão de valores ou uma condição que nunca será satisfeita.

Exemplo 1:

...

int d = 1;

while (d > 0)

{

System.out.println("7 x " + d + " = " + 7*d);

d++;

}

...

Exemplo 2:

...

while (true)

{

System.out.println(d++);

}

....


Fluxo de Controle




Versão: 3.0


50


O exemplo abaixo exibe a lógica e a implementação do código de um laço finito

usando a instrução while.


Fluxo de Controle

valor < 20 Valor++

sim

não

Lógica

{

...

while(valor <20) valor++

System.out.println(valor);

...

}

Código

Imprime valor

Sai do Laço




Versão: 3.0


51

A instrução do-while.

Ela tem uma pequena diferença da instrução while, enquanto a instrução while

verifica a expressão boolean (lógica) antes e somente depois executa a instrução

ou o bloco de instruções, a instrução do-while executa primeiro e depois verifica a

condição.

Sintaxe:

do

instrução java

while(expressão boolean)

Exemplo:

public class dowhileExemplo

{


{

long d=10;

do

System.out.println(d++);

while (d <=20);

}

}

Este código será executado 10

vezes, ou seja até que a

condição seja satisfeita

Sintaxe:

do {

//Bloco

}

while(expressão boolean)

Exemplo:

public class dowhileExemplo2

{


{

int d = 100;

do

{

System.out.println("Faixa " + Math.random()*d);

d++;

}

while (d <=110);

}

}

A instrução do-while

primeiro executa

as instruções que

estão dentro de bloco

e depois verifica a

expressão boolean


Fluxo de Controle




Versão: 3.0


52

A instrução do-while.

O exemplo abaixo exibe a lógica e implementação do código de laço finito usando a

declaração do-while.

Valor < 20

Valor++

sim

não

Lógica

...

do

{

valor++;


}

while(valor <20)

...

Código

Imprime valor

Agora faça uma comparação entre a instrução while e do-while:


Fluxo de Controle

valor < 20 Valor++

sim

não

Lógica

{

...

while(valor <20)

valor++;


...

}

Código

Imprime valor

Sai do Laço




Versão: 3.0


53

A instrução for

A instrução for é a mais popular entre as instruções de laço. A instrução for como as

demais instruções de laços repetem uma instrução ou bloco de instruções até que

determinada condição seja satisfeita.

Sintaxes:

for(valor-inicial1, valor-inicial2 ; condição; valor de incremento/decremento)

instrução java;

for(valor-inicial; condição; valor de incremento/decremento)

{

//Bloco de instruções

}

for(;condição; valor de incremento);

for(l;; valor de incremento);

for();

onde:

valor-inicial - valor de inicio (esta variável que pode ser definida dentro do for ou

fora).

Exemplo:

int x;

for(x=1;x<10;x++) instrução Java

ou

For(int x=1;x<10;x++) instrução Java

condição: é expressão lógica, Exemplo:

For(x=1;x<10;x++) instrução Java

valor de incremento: valor que incrementaremos ou decrementaremos

For(x=1;x<10;x--) instrução Java


Fluxo de Controle




Versão: 3.0


54

A instrução for

Veja abaixo alguns exemplos da implementação da instrução for:

public class forExemplo

{


{

int d;

for(d=180; d <=190; d++) System.out.println("Faixa 180-190 : " + Math.random()*d);

for(d=200; d <=210; d++)

{

System.out.println("Faixa 200-210: " + Math.random()*d);

}

int i;

for(d=220,i=10; d <=230; d++, i++)

{

System.out.println("Faixa 220-230 " + Math.random()*d);

System.out.println("Valor de i " + i);

}

for(d=230,i=20; d <=240 && i < 35; d++, i++)

{



}

for(i=40; i >= 30; i--)

{

System.out.println("Valor de i 40-30 " + i);

}

}

}

Sem bloco

Com bloco

Trabalhando

com valores

Trabalhando

com valores

e condição

composta

Trabalhando

com ordem

decresente


Fluxo de Controle




Versão: 3.0


55

public class forExemplo1

{


{

int d=170;

for(;d <=190; d++) System.out.println("Faixa 180-190 : " + Math.random()*d);

for(d=200; ;d++)

{


if (d>210) break;

}

for(d=210; d < 220;)

{


d++;

}

int i=10;

for(d=220; d <=230; d++)

{


for(; i <=20; i++)


}

for(i=40; i >= 30; i-=2)

{

System.out.println("Valor de i 40-30 " + i);

}

}

}

A instrução for

Veja abaixo mais exemplos, desta vez, com algumas variações possíveis da

instrução for:

Sem declarar

valor-inicial

Sem condição.

A condição está

associado a

instrução if

Sem valor de

incremento ou

decremento.

For aninhados

Decrementado

de dois em dois

Note que a instrução break pode ser usada para sair de instrução de laço (while,

do-while e for).


Fluxo de Controle




Versão: 3.0


56

Lógica

..

for(i=10; i >= 0; i-=2)

{

System.out.println("Valor

de i 10-0 " + i);

}

...

Código

Agora faça uma comparação entre a instrução do while, do-while e for. Quem

será mais rápido ?

A instrução for

O exemplo abaixo demonstra a lógica e implementação do código para a instrução

for:

i >=0

i=i-2

sim

não

Imprime i

i=10


Fluxo de Controle

..

for(i=10; i >= 0; i-=2)

System.out.println("Valor

de i 10-0 " + i);

...

OU




Versão: 3.0


57

Label (rótulo)

Em Java temos uma estrutura de bloco chamada Label. Esta defini um bloco de

instruções que podem ser executadas, devido sua lógica, que é similar ao comando

goto da Linguagem Basic. Esta estrutura não é muito usual.

Sintaxe:

<nome-da-label>:

instrução java

ou

<nome-da-label>:

{

//Bloco de instruçõe

}

Exemplo:

public class labelExemplo

{


{

int d=1;

label_one:

for(d=1; d <=10; d++)

System.out.println("Faixa de 0..10: " +d);

label_two:

{

for(; d <=20; d++)

System.out.println("Faixa de 10..20: " +d);

}

}

}

Veja a label e a instrução

for que parte da label_one


Fluxo de Controle




Versão: 3.0


58

public class labelExemplo1

{


{

label_a:

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

{

System.out.println("Faixa A de 0..10: " +d);

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

{

System.out.println("Resto: " + d%i);

if ( (d%i)>0) continue label_a;

}

}

}

}

Label (rótulo)

Outro exemplo de Label, desta vez usando a instrução continue

A instrução continue

Às vezes precisamos pular para aquela ou esta parte do programa sem passar pelo

resto das instruções.


Fluxo de Controle




Versão: 3.0


59

Exemplo 1 Exemplo 2

String nomes[ ];

nomes = new String[3]

names[0] = "Duke";

names[1] = "Jane";

names[2] = "Tarzan";

String nomes[ ] = {"Duke", "Jane","Tarzan"};

Exemplo 3 Exemplo 4

MinhasDatas dates[ ];

dates = new MinhasDatas[2];

dates[0] = new MinhasDatas(22, 7, 2000);

dates[1] = new MinhasDatas(01, 4, 1999);

MinhasDatas dates[ ] = { new MinhasDatas[2], new

MinhasDatas(22, 7, 2000) , new MinhasDatas(01, 4,

1999); }

Arrays

Os arrays são objetos. Devem possuir um tamanho definido no momento de sua

instanciação, por exemplo:

int[ ] arrayInt = new int[5], ou

int[ ] arrayInt

arrayInt = new int[5]

Os elementos de array são acessados pelo índice, que sempre deverá começar em

0. Não são permitidos índices inválidos, que resultam em exceção.

ArrayOutOfBoundsException.

Os arrays podem receber variáveis do tipo primitivo (int, double, char, boolean,

short e etc) ou do tipo referência, objetos, (String, Double, Integer e etc).

Quando um Arrays é redimensionado todos os elementos são perdidos.

Exemplo:

float ArrayReDim[ ] = new float[5];

ArrayReDim[ ] = new float[15];

Exemplo: Inicialização de Arrays

Arrays Multi-Dimensionais:

Declaração correta:

double duplaDim [ ] [ ] = new double [4] [ ];

duplaDim [0] = new double [1];



Declaração Incorreta:

double duplaDim [ ] [ ] = new double [ ] [4 ];





Versão: 3.0


60

Propriedades:

Length = retorna a quantidade de elementos de um Array

Exemplo:

int listaNum = new int[20]

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

{ System.out.println(listaNum[i]); }

Principais Métodos:

arraycopy = faz cópia de array A para o B.

Exemplos:

public class TestArray1 {

public static void main (String args [ ])

{

int[] thisArray = {1,2,3,4,5,6,7,8,9,10};

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

{

System.out.println("Conteúdo" + thisArray[i]);

}

}

}

Declara e atribui os

valores para array

Imprime no

console os itens

do thisArray

public class TestArray2 {


{

String[] estadosul = new String[3];

estadosul[0]="RS";

estadosul[1]="SC";

estadosul[2]="PR";

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

{

System.out.println("Conteúdo " + estadosul[i]);

}

}

}

Declara e atribui os

valores para thisArray

Imprime no console os

itens do array


Arrays




Versão: 3.0


61


A passagem de parâmetros em Java é somente por valor.

Passando por Valor

A passagem de argumentos na linguagem Java é somente por valor isto é, o

argumento não podem ser mudados pelo método chamado. Quando uma “instance” do

objeto é passado como um argumento a um método, o valor do argumento é referência

ao objeto. O conteúdo do objeto pode ser alterado no método chamado, mas a

referência do objeto jamais é mudada.





Versão: 3.0


62

Parâmetros de inicialização:

Podemos passar parâmetro de inicialização para o método principal. Veja o fragmento

de código:

...


System.out.println(args[0]);

}

...

Exemplo de Passagem de valores:

java NomedaClass Lista de Valores

java TestParam 01 02 03

Note que espaço em branco é a separação entre os itens, no exemplo, acima temos três

itens passados. Vale lembrar que o tipo destes parâmetros é do tipo String, por definição

da linguagem.

Para passar valores que tem nome composto acrescente aspas.

java TestParam “Jose Maria” Maria Joao






Versão: 3.0


63

A classe Math

A Math contém um grupo de funções matemáticas e estatísticas.


Truncar: ceil, floor e round

Variação: max, min, e abs()

Trigonométricas: sin, cos, tan, asin, acos, atan. toDegrees e toRadians

Logaritmo: log e exp

Outras: sqrt, pow e random

Exemplos:

double d = 2;

System.out.println(Math.sqrt(d));

public class TestSqrt

{

public static void main(String arg[])

{

double d = 2D;

System.out.println("A raiz quadrada de "+ d + " " +

Math.sqrt(d));

System.out.println("O valor arrendondado "+ d + " " +

Math.round(Math.sqrt(d)));

}

}


Exemplo:




Versão: 3.0


64

Empacotamento de Classes

É possível trabalhar com vários tipos de dados, desde números binários, hexadecimal,

boolean, string, etc. Em muitos casos há a necessidade de fazer conversão de um

tipo de dado para outro. Bem, começaremos com a conversão de tipos primitivos para

tipo referência (objetos), esta operação também é chamada de Wrapper Class.

Veja abaixo a tabela que associa os tipos.

Exemplos:

public class TestWrapperClass {


{

int pInteger = 500; // Tipo primitivo

Integer wInteger = new Integer(pInteger); // Wrapper Class

int p1 = wInteger.intValue();

//Conversão de valores:

String valueStr = "10";

double d1 = Double.valueOf(valueStr).intValue();

//ou

double d2 = Double.parseDouble(valueStr);

}

}


boolean

Boolean

byte

Byte

Char

Character

short

Short

int

Integer

long

Long

float

Float

double

Double

Tipo primitivo

Tipo referência




Versão: 3.0


65

Uma lista de exemplos de conversão de um tipo para outro tipo e por aí vai...

Convertendo dados em Java de um tipo para outro.

> Convertendo String em integer:

int variavel = 42;

String str = Integer.toString(variavel);

ou

int variavel = 42;

String str = "" + variavel;

ou

int variavel = 42;

String str = String.valueOf(variavel);

> Convertendo String em Long:

long variavel = Long.parseLong(str);

ou

long variavel = Long.valueOf(str).longValue();

> Convertendo String em Double:

double variavel = Double.valueOf(str).doubleValue();

> Convertendo String em Float:

float variavel = Float.valueOf(str).floatValue();

> Convertendo Integer em String:

int variavel = 14;

String str = Integer.toString(variavel);

ou

int variavel = 14;

String str = "" + variavel


Conversão de Tipos




Versão: 3.0


66

Mais exemplos:

> Convertendo Integer em código ASCII:

char c = 'C';

int i = (int) c;

> Convertendo Double em String:

String str = Double.toString(i);

> Convertendo Long em String:

String str = Long.toString(l);

> Convertendo Float em String:

String str = Float.toString(f);

> Convertendo Decimal em Hexadecimal:

int i = 12;

String hexstr = Integer.toString(i, 16);

ou

String hexstr = Integer.toHexString(i);

> Convertendo Decimal em Binário:

int i = 12;

String binstr = Integer.toBinaryString(i);

> Convertendo Hexadecimal em Integer:

int i = Integer.valueOf("B8DA3", 16).intValue();

ou

int i = Integer.parseInt("B8DA3", 16);

> Convertendo Boolean em Integer:

i = (b)?1:0;


Conversão de Tipos




Versão: 3.0


67

public class PessoaJuridica extends Pessoa {

public PessoaJuridica()

{

super("ACME");

}


{

PessoaJuridica pf = new PessoaJuridica();

pf.setIdade(10);

System.out.println("idade: " + pf.getIdade());

}

public String getNome()

{

return "";

};

public int getIdade()

{ return idade; }

public void setIdade(int idade)

{ this.idade = idade; }

}


A referência this

Na classe PessoaJuridica, o uso da palavra this é para

evitar ambigüidade. Note que no método setIdade, o

parâmetro chama-se idade e o atributo também tem o

mesmo nome, ou seja, o mesmo identificador, neste

caso o this separa o atributo do parâmetro.

O Java associa automaticamente a todas as variáveis e métodos referenciados com a

palavra reservada this. Por isso, na maioria dos casos torna-se redundante o uso em

todas as variáveis da palavra this.

Aplicação: Impedir ambigüidade de nome de variáveis.

Restrição: Não pode ser aplicada a métodos estáticos, por exemplo, o método main.

Exemplo:

Existem casos em se faz necessário o uso da palavra this. Por exemplo, podemos

necessitar chamar apenas uma parte do método passando uma instância do argumento

do objeto. (Chamar um classe de forma localizada);

Birthday bDay = new Birthday(this);




Versão: 3.0


68

Coleções

import java.util.*;

public class TestHashTable

{

public static void main(String Arg[])

{

Hashtable table = new Hashtable();

table.put("1", "Joao");

table.put("2", "Jose");

table.put("3", "Maria");

table.put("4", "Marta");

table.put("5", "Pedro");

table.put("6", "Mateus");

String find = (String) table.get("4");

System.out.println(find);

}

}

Hashtable (API: Java.util)

A tabela de hash é uma estrutura de dados que permite procurar os itens armazenados

em tabela utilizando uma chave associada. O formato padrão de entrada de dados na

tabela é chave e valor.

Para construir uma tabela de hash em Java, devemos criar um objeto Hashtable,

utilizando o construtor Hastable.

Para adicionar elementos na tabela usaremos o método put, put(object key, Object

value). Este método é da classe Hashtable. Para recuperar o elemento usado como

chave, devemos usar o método get, get(object key). Para remover um elemento

usamos o método remove.

Exemplo:

Implementação

de tabela Hash

e uso dos métodos

put e get

API


O que são coleções?

Coleções (também conhecidas como container) é um simples objeto que pode agrupar

múltiplos elementos. Coleções são utilizadas para armazenar, recuperar e manipular

dados. Os métodos são responsáveis por realizar as operações. A estrutura

das coleções inclui uma variedade de recursos que simplificam o desenvolvimento. Essa

é uma implementação da noção de reúso de código. Um exemplo de coleção poderia ser

uma lista de nomes e telefones.




Versão: 3.0


69

Enumeration (API: Java.util.Enumeration)

Retorna uma enumeração de uma coleção (Tabela Hash, por exemplo) especificada.

Principais métodos: hasMoreElements e nextElements.

import java.util.Enumeration.*;

import java.util.*;

public class EnumerationExemplo

{


{

Hashtable table = new Hashtable();

table.put("1", "Joao");

table.put("2", "Jose");

table.put("3", "Maria");

table.put("4", "Marta");

table.put("5", "Pedro");

table.put("6", "Mateus");

Enumeration e = table.elements();

while(e.hasMoreElements()){

String valor = (String) e.nextElement();


}

}

}

Usando a Interface

Enumeration, podemos

imprimir todos os

valores contidos

na tabela Hash

Tabela Hash

e métodos

API

Exemplo:


Coleções

import java.util.Iterator.*;

...

Iterator i = table.values().iterator();

while(i.hasNext()){

String valor = (String)i.next();


}

Opcionalmente podemos usar

Iterator que tem a funcionalidade

parecida com Enumeration




Versão: 3.0


70

Vector (API: Java.util)

A classe Vector possibilita a criação de vetor dinâmico para armazenamento de

referências de objetos, que pode ser indexado por número inteiro. Métodos principais:

addElement(), remove(), size(), element() entre outros

import java.util.*;

public class TestVector

{


{

Vector v = new Vector();

Integer y;

for(int x=0;x<5;x++)

{

y = new Integer(x);

v.addElement(y);

}

Object[] objArray = v.toArray();


{

System.out.println(objArray[x]);

}

}

}

Exercício: Use Enumeration para listar todos os elementos de Vector.

Exemplo:

Declaração do Vector

Adiciona valores ao

Vector. Note que estes

valores são do tipo referência,

ou seja, objetos

Converte um Vector

para um array .

API


Coleções




Versão: 3.0


71

ArrayList ( API: Java.util).

ArrayList é array dimensionável da Interface List parecido com Vector. No exemplo

abaixo é permitido que os valores sejam duplicados, porém, desordenados. Principais

métodos: add, remove, clear, size, isEmpty, get, set, iterator.

import java.util.*;

public class ListExemplo {

public static void main(String[] args) {

List list = new ArrayList();

list.add("um");

list.add(new Integer(4));

list.add("terceiro");

list.add(new Integer(4));

System.out.println(list);


Integer y;


{

y = new Integer(x);

v.addElement(y);

}

List listVector = new ArrayList( v );

System.out.println(listVector);

}

}

Declaração do ArrayList

Inserção de valores na lista.

Veja que estes valores são objetos

Imprime os valores da lista

API

Uma nova coleção

Uma outra construção para a

lista, neste caso ela recebe

uma coleção como argumento

Imprime todos os

valores da lista

Exemplo:


Coleções




Versão: 3.0


72

HashSet (API: Java.util)

A classe HashSet Implementa a interface Set, ela também tem suporte da

HashTable. Ela é uma coleção que não pode conter elementos duplicados.

Principais métodos: add, clear, remove, size, iterator e isEmpty.

import java.util.*;

//Com ordem e sem repetição

public class SetExample {

public static void main(String[] args) {

Set set = new HashSet();

set.add(”dois");

set.add("3rd");

set.add(new Float(11.1F));

set.add(”quarto");

set.add(new Float(11.1F));

System.out.println(set);

}

}

API

Declaração do HashSet

Inserção de valores na lista.

Veja que estes valores são objetos

Imprime os valores da lista

Exemplo:


Coleções




Versão: 3.0


73


Coleções




Versão: 3.0


74

Pacotes

A linguagem Java é estruturada em pacotes, estes pacotes contém classes que por sua vez

contém atributos e métodos. Pacote é forma de organização da linguagem Java,

prevenindo de problemas como a repetição de identificadores (nomes) de classes e etc.

Podemos usar a estrutura de pacotes para associar classes com semântica semelhante, ou

seja, classes que tem objetivo comum. Por exemplo, colocaremos em único pacote todas

as classes que se referem a regras de negócios.

Exemplo:

Aplicação

Interface de Usuário

ControleRegras de Negócios

Fisicamente os pacotes tem a estrutura de diretório e subdiretório, isto quer dizer

que a Aplicação terá a seguinte formato:

Aplicação

Regras de Negócios

Interface de Usuário

Controle

Pacotes




Versão: 3.0


75

Pacotes

Package

Esta instrução deve ser declarado na primeira linha do programa fonte, este instrução serve

para indicar que as classes compiladas faz parte do conjunto de classes (package), ou

sejam uma pacote, indicado pela notação path.name (caminho e nome do pacote).

Sintaxe: package <path.name>;

package MyPck;

public class ClassPkg

{

public ClassPkg()

{

System.out.println("Teste de package...");

}

}

Gerar pacotes: javac -d . *.java

import MyPck.ClassPkg;

public class TestPkg

{


{

ClassPkg p = new ClassPkg();

}

}

Diretório

Corrente

MyPck

ClassPck.class---

---

---

--- TestPck.class

Pacotes

Import

A instrução import faz importação para o arquivo fonte (.java) das classes indicadas, cujo o

diretório base deve estar configurado na variável de ambiente: CLASSPATH.

Sintaxe: import <classes>;

Exemplos:

import java.awt.Button; import java/awt/Button;

Substituindo os pontos por barras teríamos o caminho

Aqui estaríamos importando somente o objeto Buttonimport java.awt.*;

Neste caso estaríamos importando todos objetos contidos na classe




Versão: 3.0


76




Versão: 3.0


77


As classes é parte mais importante de um sistema orientada a objetos.

Usamos as classes para capturar o vocabulário do sistema que está em

desenvolvimento. Essas classes podem incluir abstrações que são parte do domínio do

problema, assim como as classes que fazem implementação de operações. Podemos

usar ainda as classes para representar itens de software, de hardware e até itens que

sejam somente conceituais.

Exemplo:

A classe Pessoa deverá ter atributos e métodos comuns

Pessoa

nome

idade

getNome()

getIdade()

Nome da Classe

Atributos

Métodos

O nome da classe deve ser identificador único em conjunto de classes, este nome deve

ser substantivo no singular. Exemplo: Produto, Cliente e etc

Tipos de Classes:

• Classe Concreta

• Classe Abstrata

O que é uma Classes?

“Uma classe descreve um conjunto de objetos com propriedades e comportamentos

semelhantes e com relacionamentos comuns com outros objetos”

Classe




Versão: 3.0


78

Exemplo:

A classe Pessoa. Classe concreta.

public class Pessoa {

//Atributos

private String nome;

private int idade;

//métodos

public String getNome(){

return nome; }

public void setNome(String

nome){

this.nome = nome; }

public int getIdade(){

return idade; }

public void setIdade(int

idade){

this.idade = idade; }

}

Classe Concreta:

É uma classe que tem assinatura e a implementação de métodos.


Exemplo de diagrama de classe

usando Rational Rose (notação Unified)

Classe




Versão: 3.0


79

Exemplo:

A classe Pessoa. Classe Abstrata

Classe Abstrata:

É uma classe que tem apenas assinatura de métodos sem implementação.


Classe

public abstract class Pessoa

{

protected String nome;

public abstract String getnome();

public abstract void setnome(String nome);

}

Se uma classe é abstrata se métodos

também são

Observe que os métodos não implementados. Simplesmente assinados.

Diferenças ente Classe Abstrata e Concreta:

Classe Abstrata Classe Concreta

Os métodos devem ser somente assinadosOs métodos podem ser assinados e

implementados

Não pode sofrer “instance” Poder sofrer “instance”

Relacionamento somente através de herança Todos os tipos de relacionamentos

Classe Abstrata:

Em um relacionamento onde a classe Pai é abstrata e a filha é uma classe

concreta esta deve implementar os métodos assinados na classe Pai.




Versão: 3.0


80

Exemplos de Objetos:

O que são Objetos ?

São qualquer coisa na natureza que possua propriedades (características) e

comportamentos (operações).

Exemplo: uma pessoa, uma cão e etc

Orientação a Objetos:

O termo orientação a objetos significa organizar o mundo real como uma coleção de

objetos que incorporam estrutura de dados e um conjunto de operações que

manipulam estes dados.

Estrutura de um objeto

Objetos combinam propriedades (atributos) e comportamentos (operações).

Podemos dizer que objeto é espécie da classe, ou seja, uma “instance” da classe

Propriedades Comportamentos

Bonita

Jovem

Inteligente

Andar

Correr

Falar

Chorar

Dançar

Objeto: Pessoa


Objetos




Versão: 3.0


81

Exemplos de Objetos:

O que são Objetos ?

São qualquer coisa na natureza que possua propriedades (características) e

comportamentos (operações).

Exemplo: uma pessoa, uma cão e etc

Orientação a Objetos:

O termo orientação a objetos significa organizar o mundo real como uma coleção de

objetos que incorporam estrutura de dados e um conjunto de operações que

manipulam estes dados.

Estrutura de um objeto

Objetos combinam propriedades (atributos) e comportamentos (operações).

Podemos dizer que objeto é espécie da classe, ou seja, uma “instance” da classe


Objetos

Cliente: clientehomem

nome = Felipe

cpf = 039.217.908-22

idade = 22

Classe: Cliente e objetos

nome

cpf

idade

Cliente

Cliente: clientemulher

nome = Marina

cpf = 022.200.708-12

idade = 16




Versão: 3.0


82

public class CalculaData {

private int day, month, year;

public float calcDays(int age )

{

return 365.25F * age;

}

}

Métodos


método

Métodos são os comportamentos de um objeto. A declaração é feita da seguinte

forma:

< modificador > < tipo de retorno > < nome > ( < lista de argumentos > )

< bloco >

< modificador > -> segmento que possui os diferentes tipos de modificações

incluíndo public, protected, private e default (neste caso não precisamos declarar o

modificador).

< tipo de retorno > -> indica o tipo de retorno do método.

< nome > -> nome que identifica o método.

< lista de argumentos > -> todos os valores que serão passados como

argumentos.

Exemplos: public void somaDias (int dias) { }

private int somaMes(int mês) { }

protected String getNome() { }

int getAge(double id) { }




Versão: 3.0


83

Métodos


Método é a implementação de uma operação. As mensagens identificam os métodos

a serem executados no objeto receptor.

Para chamar um método de um objeto é necessário enviar uma mensagem para ele.

Por definição todas as mensagens tem um tipo de retorno, por este motivo em Java,

mesmo que método não retorne nenhum valor será necessário usar o tipo de retorno

chamado “void” (retorno vazio).

ContaCorrente

conta

saldo

setDeposito

getSaldo

setSaque

public class ContaCorrente {

private int conta=0;

private double saldo=0;

public double getSaldo(){

return saldo;

}

public void setDeposito(int valordeposito)

{

return saldo +=valordeposito;

}

public void setSaque(double valorsaque)

{

return saldo -=valorsaque;

}

}




Versão: 3.0


84

Orientação a ObjetosProgramação Orientada a Objetos

public class Mamifero {

private int qdepernas;

private int idade;

public Mamifero(int idade)

{

this.idade = idade;

}

public Mamifero(int idade, int

pernas)

{

this.idade = idade;

this.qdepernas = pernas;

}

//Métodos

}

Construtores -

Podemos ter mais de um

construtor na mesma

classe.

Construtores

O que são construtores?

Construtores são um tipo especial de método usado para inicializar uma “instance”

da classe.

Toda a classe Java deve ter um Construtor. Quando não declaramos o

“Construtor default”, é inicializado automaticamente pelo Java. Mas existem

casos que se faz necessário a declaração explícita dos construtores.

O Construtor não pode ser herdado. Para chamá-lo a partir de uma subclasse

usamos a referência super.

Para escrever um construtor, devemos seguir algumas regras:

1ª O nome do construtor precisa ser igual ao nome da classe;

2ª Não deve ter tipo de retorno;

3ª Podemos escrever vários construtores para mesma classe.

Veja abaixo o exemplo:




Versão: 3.0


85

public class Disciplina {

private int cargaHoraria;

private String nome;

public Disciplina(String nome, int

cargaHoraria){

this.nome = nome;

this.cargaHoraria =

calcCargaHoraria(cargaHoraria);

}


return nome;

}

public int getCargaHoraria(){

return cargaHoraria;

}

public int calcCargaHoraria(int

qdeHoras) {

int horasPlanejamento = (int)

( qdeHoras * 0.1);

return cargaHoraria =

horasPlanejamento + qdeHoras;

}

}

Atributos

Variáveis

temporárias

Atributos e variáveis


Os atributos são pertencentes a classe, eles podem ser do tipo primitivo ou

referência (objetos), os seus modificadores podem ser: public, private, protected ou

default.

O ciclo de vida destes atributos estão vinculados ao ciclo de vida da classe.

Variáveis Locais:

São definidas dentro dos métodos. Elas têm o ciclo de vida vinculado ao ciclo do

método, também são chamadas de variáveis temporárias

Modificador




Versão: 3.0


86

Exemplo de Classe


Livro1

Legenda:

1 – Objeto no mundo real

2 – Modelo de implementação da classe Livro

3 – Codificação da classe Livro

public class Livro extends Object {

public Livro() {

}

private int isbn;

private String titulo;

private String autor;

public int getISBN(){

return isbn;

}

public void setISBN(int isbn){

this.isbn=isbn;

}

public String getTitulo(){

return titulo;

}

public void setTitulo(String titulo){

this.titulo=titulo;

}

public String getAutor(){

return autor;

}

public void setAutor(String autor){

this.autor=autor;

}

}

}

2

3

Criar o objeto Livro




Versão: 3.0


87

Exercício sobre modelo de Classe


1 (Identifique o objeto no mundo real)

2 Descreva o conceito:

Nome da Classe

Atributos 1

Atributos 2

Atributos 3

Métodos 1

Métodos 2

Métodos 3

3 Faça o desenho da classe:

public class <nome da classe> {

public <nome da classe> () {

}

private <tipo> atributo;



public <tipo> <nome método(lista de param...){

return <tipo de retorno>;

}

public <tipo> <nome método(lista de param...) {

this.atributo=valor param;

}

public <tipo> <nome método(lista de param...){

return <tipo de retorno>;

}

public <tipo> <nome método(lista de param...) {

this.atributo=valor param;

}

}

4 Faça a codificação do modelo de classe:




Versão: 3.0


88

O que é abstração?

Podemos dizer abstração é generalização.

Qual é a função da abstração ?

A função da abstração é capturar as propriedades e os comportamentos essenciais,

como se fosse uma fatoração, desta forma determina-se o que é importante e o que

não é.

Aeronave

Caça Helicóptero Passageiros

Mamífero

Vaca Urso Cavalo

Para discutirmos sobre classes abstratas é necessário falarmos sobre a abstração de

dados.

As classes Aeronave e Mamífero neste caso são abstratas e ambas representam um

domínio.






Versão: 3.0


89

Uma operação abstrata só determina a existência de um comportamento não definindo

uma implementação. Classes Abstratas - Exemplo:

Classes Abstratas

Uma classe abstrata é uma classe que:

• Provê organização

• Não possui “instances”

• Possui uma ou mais operações (métodos) abstratas

Pessoa

Pessoa

Física

Pessoa

Jurídica

getNome()

getNome() getNome()

Classe Abstrata

Funcionário

Analista Programador

Classe concreta

Classe concreta

Classe Abstrata






Versão: 3.0


90

Classes Abstratas

Pessoa

Pessoa

Física

Pessoa

Jurídica

getNome()

getNome() getNome()

Classe Abstrata

Classe concreta

public abstract class Pessoa {

protected String idPessoa;

protected int idade;


public Pessoa(String nome)

{

this.nome = nome;

}

public abstract String getNome();

public void setidPessoa()

{ }

public abstract int getIdade();


{ }

}






Versão: 3.0


91

Classes Abstratas

Pessoa

Pessoa

Física

Pessoa

Jurídica

getNome()

getNome() getNome()

Classe Abstrata

Classe concreta

public class PessoaFisica extends Pessoa {

public PessoaFisica(String nome)

{

super(nome);

}


{

PessoaFisica pf = new PessoaFisica("Duke");

pf.setIdade(10);

System.out.println("idade: " + pf.getIdade());

System.out.println("nome: " + pf.getNome());

}


{ return nome; }


{ return idade; }


{ this.idade = idade; }

}






Versão: 3.0


92

Um relacionamento é a conexão entre itens. É representado graficamente como um

caminho, que tem tipos diferentes de linhas para distinguir os tipos de

relacionamentos.

Ao construir as abstrações, descobrimos que são poucas as classes que trabalham

sozinhas. Em vez disso, a maioria das classes colaboram com outras classes de várias

maneiras.

Portanto, quando estamos modelando, devemos identificar as classes, atributos, métodos e

relacionamentos.

Existem alguns tipos principais de relacionamentos entre classes e objetos:

• Herança

• Associação

• Agregação

• Composição

Veja a definição de relacionamento:

Exemplo: Hierarquia de Classes

Pessoa

Aluno Funcionário

ProfessorPessoal

Administrativo

Terceiro

Professor

Autônomo

Pessoal

Operacional

SubClasses

SuperClasse

Relacionamento:

1 - Pessoa é a SuperClasse de Terceiro, Aluno e de Funcionário,

estas são subclasse de Pessoa.

2 - Terceiro e Funcionário são SuperClasse de Professor e Pessoal Administrativo e de

Professor Autônomo e Pessoal Operacional respectivamente.

E estas são subclasse de Terceiro e Funcionário.


Relacionamento




Versão: 3.0


93

Herança é o mecanismo pelo qual elementos mais específicos incorporam a estrutura e

comportamento de elementos mais gerais,

Uma classe derivada herda a estrutura de dados e métodos de sua

classe “base”, mas pode seletivamente:

• adicionar novos métodos

• estender a estrutura de dados

• redefinir a implementação de métodos já existentes

Uma classe “pai” proporciona a funcionalidade que é comum a todas as suas classes

derivadas, filhas, enquanto que uma classe derivada proporciona a funcionalidade

adicional que especializa seu comportamento.

Exemplo:

Graduação Pós-Graduação

Curso

Universitário

Especialização Extensão

Hierarquia de Classes

Podemos dizer que Graduação é tipo de Curso Universitário, assim como Curso de

Especialização ou de Extensão.

extends

extends


Herança




Versão: 3.0


94

Exemplo: Implementação- Pessoa, Aluno, Terceiro, Funcionário






{

this.nome = nome;

}


public void setidPessoa()

{ }



{ }

}

public class Terceiro extends Pessoa{

private int codigoTerceiro;

public Terceiro(String nome)

{

super(nome);

}


{

return 0;

}


{

return "";

};

}

public class Funcionario extends Pessoa{

private int codigofuncionario;

public Funcionario(String nome)

{

super(nome);

}


{

return 0;

}


{

return "";

};

}

Professor

Autônomo

Pessoal

Operacional

ProfessorPessoal

Administrativo


Herança

public class Aluno extends Pessoa{

public Aluno(String nome)

{

super(nome);

}


{

return 0;

}


{

return "";

};

}




Versão: 3.0


95

Pessoa

AlunoTerceiro

public class ProfessorAutonomo

extends Terceiro{

public ProfessorAutonomo(

String nome)

{

super(nome);

}

}

public class PessoalOperacional

extends Terceiro{

public PessoalOperacional(

String nome)

{

super(nome);

}

}

public class Professor

extends Funcionario{

public Professor(

String nome)

{

super(nome);

}

}

public class PessoalAdministrativo

extends Funcionario{

public PessoalAdministrativo(

String nome)

{

super(nome);

}

}

Funcionário


Exemplo de Herança: Implementação: ProfessorAutonomo, PessoalOperacional,

Professor e Pessoal Administrativo

Herança




Versão: 3.0


96

A herança múltipla é quando uma classe tem mais que uma Superclasse associada e

que herde as características de todas elas. Veja a figura abaixo:

Pessoa

Pessoa JurídicaPessoa Física

<<interface>>

Mamífero

Relacionamento:

Pessoa Física é tipo de pessoa, mas também é mamífero.

Na linguagem Java:

A Herança múltipla é somente permitida por contrato, neste caso a Mamífero é uma

Interface, podemos dizer que é tipo especial de classe, que não pode

ter métodos implementados, apenas as assinaturas.


Herança Múltipla

<<interface>>

Mamífero

Interface:

O que é interface ?

Interface é um contrato entre o cliente, que pode ser classe concreta ou abstrata, e a

interface. Este contrato é garantia que o métodos assinados na interface serão

implementados na classe cliente.

Nota: Na interface também podemos declarar constantes (public static final).

interface Product

{

String getName ();

double getCost ();

}

SuperclasseSuperclasse

Exemplo de Interface




Versão: 3.0


97

Exemplo: Implementação da classe Pessoa, PessoaFisica e PessoaJuridica e a

interface Mamifero






{

this.nome = nome;

}



public void setIdade(int idade){ }

}

public class PessoaJuridica1 extends Pessoa

{

public PessoaJuridica1(String nome)

{

super(nome);

}


{

return 0;

}


{

return "";

};

}

public interface Mamifero {

final int qdeOlhos=2;

public int getQdePernas();

}

public class PessoaFisica1 extends Pessoa

implements Mamifero {

public PessoaFisica (String nome)

{

super(nome);

}

public int getQdePernas(){

return 2; }


return “”; }

public int getIdade(){

return 0; }

}

Exercício:

1 - Podemos implementar a herança múltipla na Classe Pessoa? Por que ?

2 - Por que somos obrigado a assinar ou implementar os métodos da Interface Mamifero

na classe PessoaFisica


Herança Múltipla

implements

extends

extends




Versão: 3.0


98

Comparação: classes e interfaces

Tipo Classe Concreta Classe Abstrata Interface

Herança extends(simples)

extends(simples)

implements(múltipla)

Permite a

implementação

de Métodos

sim não não

Permite a

declaração de

Dados

sim sim sim(somente final)





Versão: 3.0


99

Superclasse

Subclasse

public class Empregado {

private double salario;

public Empregado(){

salario=0.00;

}

public double getSalario(){

return this.salario;

}

}

public class Gerente extends Empregado {

private double bonus = .15;

public Gerente(){

//referência ao Construtor

super();

}


//referência ao método getSalario

return super.getSalario() +

(super.getSalario()*this.bonus);

}

}


A referência super

A palavra super é usada para referenciar a superclasse ou classe pai, na verdade o

construtor da classe hierarquicamente superior, podemos usa-lo também para fazer

referência aos membros (atributos e métodos), da superclasse.

Desta forma temos uma extensão do comportamento.

Exemplo:




Versão: 3.0


100


Associação

Definição de Associação:

Um relacionamento estrutural que descreve um conjunto de vínculos, em que o vínculo é

uma conexão entre objetos; o relacionamento semântica entre dois ou mais classificadores

que envolve as conexões entre seus objetos

public class Usuario {

public Senha m_Senha;

Usuario() {

}

}

public class Senha {

public Usuario m_Usuario;

Senha() {

}

}

Usuario Senha

Associação

classe classe




Versão: 3.0


101


Navegação

Navegação

Navegação é uma associação unidirecional

public class Pedido

{

public ItemPedido item[];

public Pedido()

{

}

}

public ItemPedido

{

public ItemPedido()

{

}

}

Pedido tem a responsabilidade de identificar

quais são seus itens. Já os itens não tem a

responsabilidade de saber a qual pedido que

eles pertencem.

O Código Java:

Pedido

ItemPedido




Versão: 3.0


102


public class Pessoa {

public Empresa Empregador[];

Pessoa() {

}

}

Rolename

Definição de RoleName:

É um identificador (nome) do papel da associação, podendo cada ponta ter um nome

especifico.

public class Empresa {

public Pessoa Empregado;

Empresa() {

}

}

As rolename neste caso são usadas identificadores dos atributos (das classes).




Versão: 3.0


103


Agregação

public class Roda {

public Pneu pneu;

Roda() {

}

Roda(int aro, String modelo) {

pneu = new Pneu(aro,modelo)

}

Definição de Agregação:

Um forma especial de associação, que especifica o relacionamento parte-todo entre o

agregado (o todo) e o componente (a parte).

Veja o exemplo abaixo:

public class Pneu {

public Roda roda;

Pneu() {

}

}

Pneu

Roda

roda

pneu

Todo

Parte de




Versão: 3.0


104


Composição

Cliente Pedido

ItemPedido

Produto

Definição de Composição:

Uma forma de agregação com propriedade bem-definida e tempo de via coincidente das

partes pelo todo; as partes com multiplicidade não fixada poderão ser criada após a própria

composição, mas, uma vez criadas, vivem e morrem com elas; essas partes também

podem ser removidas explicitamente antes da morte do elemento composto.

Todo

Parte de

um todo

Dados do Pedido

N• 19069

Cliente 1 – Cliente A

Data: 01/01/2002

It Descrição Qt Preço

--------------------------------

01 Produto A 10 12,40

02 Produto B 01 2,40

03 Produto C 11 5,60

04 Produto D 09 2,23




Versão: 3.0


105


Multiplicidade

Cliente Pedido

0..*1 0..*1

ItemPedido

1

1..*

Produto

1

*

1

1..*

*

1

Definição de Multiplicidade:

A especificação de uma faixa de números cardinais, que um conjunto pode assumir.

Todo

Parte de

um todo

Dados do Pedido

N• 19069

Cliente 1 – Cliente A

Data: 01/01/2002

It Descrição Qt Preço

--------------------------------

01 Produto A 10 12,40

02 Produto B 01 2,40

03 Produto C 11 5,60

04 Produto D 09 2,23




Versão: 3.0


106


Exemplo de implementação de Composição e multiplicidade

Cliente Pedido

0..*1 0..*1

ItemPedido

1

1..*

Produto

1

*

1

1..*

*

1

public class ItemPedido {

public Pedido m_Pedido;

public Produto

m_Produto;

ItemPedido() {

}

}public class Produto {

public ItemPedido m_ItemPedido[];

Produto() {

}

}

public class Pedido {

public ItemPedido m_ItemPedido[];

Pedido() {

}

}

public class Cliente {

public Pedido m_Pedido[];

Cliente() {

}

}




Versão: 3.0


107


Constraint

As constraint (restrições) ampliam o vocabulário dos elementos na UML, permitindo alterar

ou incluir novas regras aos elementos do modelo.

Pedido Cliente

Pedido

Produto

AnaliseCredito

{se Pedido.Cliente.AnaliseCredito é ruim,

então pedido.ePrePago deve ser verdadeiro}

1

*

*

1

* 1faz

Constraint




Versão: 3.0


108

<<negócio>>Vendedor

PercentualDeComissao

<<negócio>>Prestacao

DataDeVencimentoValorDaPrestacao

<<negócio>>Cliente

SituacaoFinanceira

<<negócio>>Produto

QtdeEmEstoque

<<negócio>>Venda

DataDaVenda

<<negócio>>ItemDeVenda

QtdeVendida

<<negócio>>VendaAPrazo

1 1..*

é composta de

*

1

corresponde

*

1

é realizada por

1..*

1

é realizada para

1 1..*

compreende


Exemplo de modelo de classes




Versão: 3.0


109


Exercício

public class NotaFiscal

{

public NotaFiscalLinha nflinha[] = new NotaFiscalLinha[3];


{

NotaFiscal nf = new NotaFiscal();

nf.nflinha[0] = new NotaFiscalLinha("1010","Teste item 0", 5, 200.53);



double valortotal=0;

double quantidadetotal =0;

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

{

System.out.print(nf.nflinha[i].item + " ");

System.out.print(nf.nflinha[i].descricao + " ");

System.out.print(nf.nflinha[i].quantidade + " ");

System.out.print(nf.nflinha[i].valor + "\n");

quantidadetotal =+ nf.nflinha[i].quantidade;

valortotal =+ nf.nflinha[i].valor * quantidadetotal;

}

System.out.println("Quantidade total..." + quantidadetotal);

System.out.println("Valor total........" + valortotal);

}

}

Complete a classe que falta e faça o diagrama de classe correspondente com seus

respectivos relacionamentos.




Versão: 3.0


110


É uma proteção adicional dos dados do objeto de possíveis modificações impróprias,

forçando o acesso a um nível mais baixo para tratamento do dados.

Operações/métodos/interface

pública

Dados/Atributos/propriedades

privada

Encapsulamento (“data hiding”)Encapsulamento é definido como uma técnica para minimizar dependências entre

“módulos” através da definição de interfaces externas. Também conhecido como:

O fenômeno da “caixa preta”

Encapsulamento



public Empregado(){

salario=0.00;

}



}

}

O atributo salario somente poderá ter

um valor atribuído ou alterado,

através de método público.

Através do método getSalario, que

tem modificador public, podemos

manipular ou recuperar o valor do

atributo salario.

Classe Empregado e método

getSalario

O atributo salario





Versão: 3.0


111


A interface (pública) de um objeto declara todas as operações permitidas (métodos)

Todo o acesso aos dados do objeto é feito através da chamada a uma operação (método)

da sua interface.

Encapsulamento - Benefícios

- Segurança:

Protege os atributos dos objetos de terem seus valores corrompidos por outros

objetos.

- Independência:

“Escondendo” seus atributos, um objeto protege outros objetos de complicações de

dependência de sua estrutura interna

Encapsulamento

public class Gerente1 extends Empregado {



//referência ao método getSalario

return super.getSalario() +

(super.getSalario()*this.bonus);

}

}


public Empregado(){

salario=0.00;

}



}

}





Versão: 3.0


112

Definição:

“Polimorfismo” é uma operação que pode assumir múltiplas formas, a propriedade

segundo o qual uma operação pode comportar-se diferentemente em classes diferentes”

(Rumbaugh)

O polimorfismo é o responsável pela extensibilidade em programação orientada a objetos.

Polimorfismo

overloading

overriding

Overloading:

Possibilidade de reúso do nome do método para diferentes implementações, em tempo de

execução, a aplicação, escolherá o método adequado para cada chamada, veja o

exemplo.

TesteSoma Soma

somar(int a, int b)

somar(float a, float b)

somar(char a, char b)

somar(long a, long b))

Para cada tipo de dados existe um método, o reúso do nome do método é permitido,

entretanto a lista de argumentos deve ser diferente, veja o exemplo acima: o método

somar é definido várias vezes, entretanto com a lista de argumentos diferente, desta

forma evitaremos problemas como ambigüidade.


Polimorfismo




Versão: 3.0


113

public class EmpregadoExemplo {


public void setSalario(int diastrabalhados,

double valorhora ){

this.salario = diastrabalhados *

valorhora * 8;

}



}

}

public class Engenheiro extends

EmpregadoExemplo {


{

Engenheiro eng = new Engenheiro();

eng.setSalario(22, 35.00);

System.out.println(eng.getSalario());

}

}

O método setSalario é herdado da Superclasse (Empregado), entretanto para cada cargo

(tipo de empregado) ele tem uma implementação diferente. Por exemplo:

- Para Engenheiro e Secretária salário = (Dias Trabalhados x Valor hora)

- Para Gerente salário = (Dias Trabalhados x Valor hora) + Bônus

- Para Diretor salário = (Dias Trabalhados x Valor hora) + Bônus + Participação nos

lucros.

Overrinding - Exemplo:

Empregado

setSalario()

getSalario()

Engenheiro

getSalario()

Gerente

getSalario()

Diretor

getSalario()

Secretária

getSalario()


Polimorfismo




Versão: 3.0


114

O método setSalario (continuação)

public class Diretor extends GerenteExemplo {

private double lucros = 1000.00;


{

Diretor d = new Diretor();

d.setSalario(22, 35.00);

System.out.println(d.getSalario());

}


return super.getSalario() + this.lucros;

}

}

public class GerenteExemplo extends EmpregadoExemplo {



{

GerenteExemplo g = new GerenteExemplo();

g.setSalario(22, 35.00);

System.out.println(g.getSalario());

}


return super.getSalario() + (super.getSalario()*this.bonus);

}

}


Polimorfismo

public class Secretaria extends EmpregadoExemplo {


{

Secretaria sec = new Secretaria();

sec.setSalario(22, 35.00);

System.out.println(sec.getSalario());

}

}




Versão: 3.0


115


Overrinding

Uma subclasse pode mudar o comportamento herdado da Superclasse, ou seja, um método

herdado poderá ser alterado. Veja o exemplo abaixo:

O método getSaldo é herdado da Superclasse (Conta Bancária), entretanto para cada

tipo de Conta ele tem uma implementação diferente. Por exemplo:

- Para apurar o saldo da Conta Corrente saldo atual = (soma dos depósitos + saldo

anterior) - saques

Para a conta poupança seria saldo atual = (soma dos depósitos + saldo anterior + juros)

- saques

Para a conta de investimentos seria saldo atual = (soma dos aplicações + saldo anterior

+ juros) - resgates - ir

Conta Bancária

getSaldo()

Conta Corrente

getSaldo()

Conta Poupança

getSaldo()

Investimentos

getSaldo()

Exercício:

Faça a implementação das classes acima.

Polimorfismo

As subclasse podem modificar o comporamento de método herdado da super classe,

entretanto temos que seguir algumas regras:

- Manter o mesmo nome do método

- Manter o mesmo tipo de retorno

- Manter a lista de argumentos.




Versão: 3.0


116

Acessibilidade

Acessibilidade ou Visibilidade

Os níveis de controle tem o seguinte papel de tornar um atributo, um método ou classe

visível ou não.

Exemplo:

Se um atributo foi declarado dentro de uma classe chamada TestA e este atributo tem o

nível de controle private. Somente esta classe poderá fazer acesso a este atributo, ou seja,

somente classe TestA o enxergará, todas as demais, não poderão fazer acesso direto a

este atributo.

public class TestA {

private int a=1;

}

Para contornar a situação poderíamos fazer duas coisas, a primeira: alterar o nível de

controle do atributo a, na classe TestA, para public, desta forma a classe TestB o

enxergaria. Todavia, as boas práticas de programação não recomendam fazer isto.

A segunda: é uma maneira mais elegante de resolvemos o problema, podemos criar

métodos públicos na classe TestA, por exemplo, getA e setA, aí sim, através destes

métodos seria possível manipular o atributo da classe TestA.

public class TestB extends

TestA{

private int b=a;

}

TestB.java:3: a has private access in TestA

private int b=a; ^

A linguagem Java tem para os atributos e métodos quatro níveis de controles: public,

protected, default e private.

Para classes tem dois níveis: public e default (também chamado de pacote ou de friendly).

Este níveis de controle são os responsáveis pela acessibilidade ou visibilidade de atributos,

e métodos.




Versão: 3.0


117

Acessibilidade

Acessibilidade ou Visibilidade

public class

public sublass

Exemplos:

class

public sublass

protected class

public sublass

public default protected

A tabela abaixo demonstra a acessibilidade para cada nível de controle

Modificador Mesma

Classe

Mesmo

Package

SubClasse Universo

Public sim sim sim sim

Protected sim sim sim não

Private sim não não não

Default sim sim não não




Versão: 3.0


118




Versão: 3.0


119


public class TestInstanceof

{


{

Object[] obarray = new Object[4];

obarray[0] = new Integer(3);

obarray[1] = new Float(3);

obarray[2] = new String("Teste");

obarray[3] = new Character('a');

if (obarray[3] instanceof Character)

{

System.out.println("Character");

}

}

}

Instanceof

O operador instanceof é usado para identificar qual é o tipo do objeto esta “instanciado”.

Verifica qual é

objeto que está

contido na terceira

posição do obarray




Versão: 3.0


120

Exceções

Exception

O que são exceções ?

Exceções em Java são anomalias que podem acontecer durante a execução de um

programa. Existem diversos tipos de exceções, desde erros de sintaxes até falha de

equipamento, como, erro de leitura e gravação.

Para o tratamento de exceções, usamos as declarações try, catch e finally.

A declaração try indica a parte do código aonde poderá ocorrer uma exception,

Já a declaração catch faz a captura da exceção, caso venha a ocorrer.

A declaração finally, que é opcional, é utilizada para definir novo bloco de instruções

ou finalizar objetos que estão abertos, por exemplo, conexões. A execução desta

declaração é independente, da declaração catch, ou seja, mesmo que não aconteça

nenhuma exceção os comandos e/ou instruções dentro da declaração finally serão

executados.

Exemplo:

try {

// código que pode ocasionar uma exception

}

catch(Classe Exceção objeto exceção)

{

// tratamento do erro

}

finally {

// código

}

ou

try {

// código que pode ocasionar uma exception

}

catch(Classe Exceção objeto exceção)

{

// tratamento do erro

}




Versão: 3.0


121

Exceções

Estruturas básica das classes de exceção:

Exception

Throwable

Exception Error

IOException RuntimeException

EOFException FileNotFoun

ExceptionArithmeticException

NullPointerException

IndexOfBoundException

AWTError JVMError

Exceptions mais comuns:

ArithmeticException - int i = 12 / 0

NullPointerException - ocorre quando um objeto não foi instanciado.

NegativeArraySizeException - ocorre quando é atribuído um valor nulo para um array.

ArrayIndexOutOfBoundsException - ocorre quando foi violado o índice do array, ou

seja, elemento não existe.

Categorias de Exceptions:

Existem três grandes categorias de exceções em Java. De fato, a classe

Java.lang.Throwable age como uma classe pai , para que todos os objetos disparados

possam ser capturados pela declaração catch.

Podemos usar a classe Throwable, para tratar as exceções, entretanto, existe uma

subclasse que tratam erros específicos, por exemplo:

- Exception, IOEception, SQLExceptoion, RuntimeException assim por diante

Para maiores detalhes devemos consultar a documentação.




Versão: 3.0


122

Exceções

Exception

Declare ou Manipule as Exception:

Na construção de um código, o desenvolvedor deve prever maneira para tratar possíveis

erros. Existem duas formas de fazer isto. A primeira é com o uso da declaração try e

catch, como foi visto anteriormente, e a segunda maneira é indicando que a exceção

não é dirigida para este método, neste caso usamos a palavra reservada throws para

que jogará a exceção para o método chamador.

Sintaxe:

throws <classe de exceção>

Exemplo:

public void troublesome( ) throws IOException

public class TestThrows

{


{

try

{

new TestThrows().divisao(10,0);

}

e.printStackTrace();

{

System.out.println("Deu erro " + e);

}

}

public void divisao(int d1, int d2) throws ArithmeticException

{

System.out.println("Divisao: " + d1/d2);

}

}

Criando uma Exception

É permitido que o desenvolvedor crie suas próprias classes de exceção.

Cria uma trilha da

ocorrência da exceção

Lança a exceção

para o método main




Versão: 3.0


123

Exceções

Exception

Exemplo:

public class ExceptionExemplo

{

public static void main (String args[ ])

{

int status = 0;

String greetings [ ] = { "Hello word" ,

"No, I mean it!", "HELLO WORLD!"};

try {

for(int i=0; greetings.length > i;i++)

System.out.println(greetings[i]);

}

catch(ArrayIndexOutOfBoundsException e)

{

System.out.println("Exceção: " + e);

status = 1;

}

finally

{

System.exit(status);

}

}

}

Implementação

do tratamento

de exceção

Neste exemplo o código funciona perfeitamente, entretanto a implementação do

controle de exceção, cumpre seu papel, de prevenção a falhas.




Versão: 3.0


124

Exceções

Exception

Exemplo:

public class ExceptionBadExemplo

{

public static void main (String args[ ])

{

int status = 0;

String greetings [ ] = { "Hello word" ,

"No, I mean it!", "HELLO WORLD!"};

try {

for(int i=0; 4 > i;i++)

System.out.println(greetings[i]);

}

catch(ArrayIndexOutOfBoundsException e)

{

System.out.println("Exceção: " + e);

status = 1;

}

finally

{

System.exit(status);

}

}

}

Implementação

do tratamento

de exceção

Hello word

No, I mean it!

HELLO WORLD!

Exceção: java.lang.ArrayIndexOutOfBoundsException

Neste segundo exemplo forjamos um erro na instrução for ( o valor colocando na

condição é maior que o índice do array), isto resulta em uma exceção, que foi

devidamente capturada, pela instrução catch, e tratada veja abaixo:




Versão: 3.0


125


Para formatar ou criar uma máscara para apresentação de valores numéricos, usamos a

classe java.text.DecimalFormat, esta possui métodos para formatação de valores

monetários, científico e percentuais entre outros.

A formatação é feita por strings com caracteres especiais.Veja o exemplo:

import java.text.DecimalFormat;

import java.text.NumberFormat;

public class DecimalFormat1 {


//Cientifico

DecimalFormat df = new DecimalFormat("0.000E0000");

System.out.println( df.format(1234.56));

//Percentual

NumberFormat nf = NumberFormat.getPercentInstance();

System.out.println(nf.format(0.67));

}

}

67%

Os valore

serão

exibidos no

seguinte

formato:

1,235E000

3

Mascara

Instancia

Observe que o ponto indica a separação decimal e virgula a separação de milhar

Principais símbolos:

Símbolo Significado

0 Representação o valor 0

# Representação qualquer valor

, (virgula) Separação de milhar

. (ponto)_ Separação de decimal

- Representação valores negativos

; Separador de mascara, por exemplo: quando

uma mesma mascara de duas formatações:

###.##;(00.##)

$ Representação de valores monetários





Versão: 3.0


126


Formatação de Números:

Este exemplo demonstra formatação para valores monetário entre outros:

import java.text.DecimalFormat;

import java.text.NumberFormat;

public class DecimalFormatMask {


double valor = 1045.561;

DecimalFormat df = null;

df = new DecimalFormat("###,###.###");

System.out.println(df.format(valor));

df = new DecimalFormat("###,###.00");


df.applyPattern("#,###.00");


df.applyPattern("$#,###.00");


df.applyPattern("###.##;(###.##)");

System.out.println(df.format(valor - 1500.54D));

}

}


APIs

O valor sem formatação

Criando máscaras e a

impressão do valor




Versão: 3.0


127


Formatação de Datas:

A classe java.util.Date representa a data, num formato em milissegundos. Para

representar em outro formato, como em dia, por exemplo, podemos optar por usar a

classe GregorianCalendar.

Construtores:

new Date() - Cria uma data que representa o instante de criação.

new Date(long tempo) - Cria uma data com tempo em milissegundos após 1 de

janeiro de 1970.


after(Date d) - Retorna true se data for posterior a d

before(Date d) - Retorna true se data for anterior a d

getTime() - Retorna os milissegundos da data (com relação a 1 de janeiro de 1970)

setTime(long tempo) - Especifica a data em milissegundos (após 1 de janeiro de

1970)

Podemos usar outros métodos para comparar datas como:

compareTo() e equals()

SimpleDateFormat

A classe java.text.SimpleDateFormat possui métodos para formatação de datas. A

formatação é baseado em modelo ou mascaras, ou seja, para exibirmos a data como

formato de 11/09/2001 é necessário usar a seguinte mascara: “dd/MM/yyyy”.


format(Date data) - Formata a data conforme a mascara de formatação definida no

construtor.

Date parse(String texto, ParsePosition posicao) - Interpreta o texto como uma data,

retornando o um objeto Date, este método também usa mascara definida no

construtor. O parâmetro posicao geralmente tem o valor new ParsePosition(0)





Versão: 3.0


128


Formatação de Datas:

Exemplo:

import java.text.SimpleDateFormat;

import java.util.GregorianCalendar;

public class DateFormatMask {


GregorianCalendar c = new GregorianCalendar(2001,9,27);

SimpleDateFormat df;

df = new SimpleDateFormat("yyyy/MM/d");

System.out.println(df.format(c.getTime()));

//Mês

df = new SimpleDateFormat("yyyy/MMM/d");


df = new SimpleDateFormat("yyyy/MMMM/d");


//Dia da semana

df = new SimpleDateFormat("E d/MMMM/yyyy");


df = new SimpleDateFormat("EEEE d/MMMM/yyyy");


//Semana

df = new SimpleDateFormat("E d/MMMM/yyyy 'semana' w ");


df = new SimpleDateFormat("E d/MMMM/yyyy 'semana' W ");


//Hora

df = new SimpleDateFormat("E d/MMMM/yyyy 'hora ' H':'m':'s");


//Data completa

df = new SimpleDateFormat("'Sao Paulo,' EEEE d ' de ' MMMM ' de ' yyyy");


}

}





Versão: 3.0


129

Constantes


Para declarar uma variável, um método, um bloco ou até mesmo uma classe como

constante usamos o modificador final.

Entretanto, o uso deste modificador deve obedecer a certas restrições como:

• Uma classe constante não pode ter subclasses;

• Um método constante não pode ser sobrescrito;

• O valor para variável constante deve ser definido no momento da declaração ou através

de um construtor, para variáveis membro, uma vez atribuído o valor, este não mudará

mais.

public final class TestFinalPai

{

private final int VALOR;

public TestFinalPai(int V)

{

VALOR = V;

}

}

public class TestFinalFilho extends TestFinalPai

{

public TestFinalFilho() {

super(10);

}


{

}

}

TestFinalFilho.java:1: cannot inherit from final TestFinalPai

public class TestFinalFilho extends TestFinalPai

Veja o exemplo:

Quando compilamos

a classe um erro é gerado




Versão: 3.0


130

Constantes


public class TestFinal1

{

private final int VALOR;

public TestFinal1()

{

VALOR = 0;

}


{

TestFinal1 tf= new TestFinal1();

System.out.println(tf.VALOR);

}

}

public class TestFinal2

{


{

final int VAL;

VAL =0;

System.out.println(VAL);

}

}

Convenção, para variáveis constantes (final), o nome da variável deve ser escrito

em maiúsculo.

Veja o exemplo:

• TestFinal1: O valor é atribuído através de um construtor, note que a variável é membro

da classe.

• TestFinal2: O valor é atribuído no método, pois, neste caso a variável é um local




Versão: 3.0


131

Threads

t1

Execução

t3 t5 t2

fila

T1.start()


O que são Linhas?

São linha de execução em paralelo.

Java permite que seus programas executem ao mesmo tempo várias Threads, o

processo de utilizar duas ou mais Threads de execução no mesmo programa é

chamado de Multithreads.

Três Partes de uma Linha :

Uma linha inclui três partes principais. Primeiro, CPU virtual. Segundo, código que esta

CPU está executando. Terceiro, os dados no que o código trabalha. Podemos

compartilhar código e dados.

-----------------------------------------------------------------------------------------------------------------

Observações:

-Quanto um computador tem somente um processador, as Threads são executadas em

concorrência. Entretanto quanto o computador tem mais de processado as Threads podem ser

executadas em paralelo.

-Um programa é considerado MultiThreads quanto a mesma Thread tem vários “instances”.

-----------------------------------------------------------------------------------------------------------------

Execução da Threads:

O método thread.start() não significa que Thread será executado imediatamente, o

start apenas o habilita para a fila de execução e que de acordo com sua prioridade e

outros Threads existentes pode ser o próximo a ser executada ou não.




Versão: 3.0


132

Threads


Método Descrição

void start() Habilita uma Thread para execução

void interrupt() Interrompe a execução

static void sleep(long

ms)

Suspende a execução de uma Thread pelo tempo

especificado, o tempo é um valor em milisegundo.

Principal vantagem: Economiza processamento de CPU.

Aplicação: Controle Diversos, processo de sincronização

etc

static void yield() Suspende a execução da Thread corrente e dá a

oportunidade de execução para a próxima Thread da fila

de execução de mesma prioridade.

boolean isAlive() Verifica se a Thread está ativo (se foi iniciada e ainda

seu processamento não terminou). Não importa se a

Thread está em execução ou não.

Prioridades:

Método Descrição

setPriority() Ajusta o valor da prioridade da Thread

getPriority() Pega o valor prioridade da Thread

Obs: Podemos usar os valores constantes:

Thread.MIN_PRIORITY, Thread.NORM_PRIORITY, Thread.MAX_PRIORITY,

Exemplo:

...

public int total(int valor) {

synchronized (this) {

valorTotal += valor;

}}


Sincronismo:

Todos os objetos em Java possuem um Monitor, que pode ser utilizado pelas

Threads para evitar acessos simultâneos ao mesmo trecho de código, que causaria

inconsistência de dados. Uma Thread toma para si um monitor quando este está

disponível, ou seja, retém os dados, e após a execução os liberam. Para executar

este processo é preciso usar a palavra synchronized.




Versão: 3.0


133

Threads


Método Descrição

wait() Indica que a Thread ativa deve esperar (parar a

execução) até que seja noficado (notify, por exemplo)

notify() Informa a Thread que está esperando (que foi parado

pelo método wait()) e o habilita a execução

notifyAll() Informa todos as Thread que estão esperando (que foram

parados pelo método wait()) e os habilita a execução

Principal vantagens das Threads:

- Incentiva o REÚSO de código

Cuidados: Evitar situação de Deadlock (travamento)


Estado de espera (Putting Threads on Hold)

Vários mecanismos existem que podem parar a execução de uma linha

temporariamente. Seguindo este tipo de suspensão, execução pode ser retomada

como se nada tivesse interrompido sua execução, a linha aparece ter executado uma

instrução muito lentamente simplesmente.

O método sleep foi introduzido na primeira seção e foi usado para deter uma linha

para um período de tempo.

Às vezes é apropriado suspender execução de uma linha indefinidamente em qual

caso alguma outra linha será responsável para retomar a execução. Um par de

métodos de Linha está disponível para isto. Eles são chamados suspend () e resume

().

O método join ( ) causa a linha atual para esperar até a linha em qual o método

join é chamado termina.




Versão: 3.0


134

Threads


public class TestThread {


Xyz r = new Xyz();

Thread t = new Thread(r);

t.start();

}

}

class Xyz implements Runnable {

int i;

public void run() {

i = 0;

while (true) {

System.out.println("Hello " + i++);

if ( i == 50 ) break;

}

}

}

Este exemplo demonstra a implementação de uma Thread simples

“instance” da

Thread

O método start()

solicita a execução

da Thread

A interface Runnable é responsável pelos

métodos run()

No método run() é

implementado o

corpo do método

Corpo do

método run()




Versão: 3.0


135

Threads


public class TestThread1 {


Xyz r = new Xyz();

Thread t1 = new Thread(r);

Thread t2 = new Thread(r);

t1.start();

t2.start();

}

}

class Xyz implements Runnable {

int i;

public void run() {

i = 0;

for(;;) {

System.out.println(Thread.currentThread());

System.out.println(i++);

if (i == 50) break;

}

}

}

Este exemplo é parecido com anterior, entretanto, agora é demonstrado a execução de

duas Threads.

“instances” da Thread

O método start()

solicita a execução

das Threads

A interface Runnable é responsável pelos

métodos run()

No método run() é

implementado o

corpo do método

Corpo do

método run()

é a parte do

código que será

repetido

Retorna a referência

da Thread corrente




Versão: 3.0


136

Threads


Este exemplo demonstra como configurar a prioridade de execução de uma Thread.

public class TestThreadPrior {


Thread t0 = new Thread(new TestPrior());

Thread t1 = new Thread(new TestPrior());

t0.setPriority(Thread.MAX_PRIORITY);

t0.start();

System.out.println("Prioridade t1 " + t0.getPriority());

System.out.println("----------------------------------");

t1.setPriority(Thread.MIN_PRIORITY);

t1.start();


System.out.println("----------------------------------");

}

}

class TestPrior implements Runnable {

int i;

public void run() {

i = 0;

try {

for(;;) {

Thread.sleep(5);



if ( i == 50 ) break;

}

}catch(Exception e) {

}

}

}

Prioridades: Usamos

o método setPriority para

definir e getPriority para

saber qual é a prioridade

da Thread

Para usar:

O método sleep(),

somos forçados

usar o controle

de exceção: try-catch




Versão: 3.0


137

Threads


public class TestThreadYield {


ThreadYield t = new ThreadYield();

Thread t0 = new Thread(t);





t0.start();

t1.setPriority(Thread.NORM_PRIORITY);


t1.start();



t2.start();

}

}

class ThreadYield implements Runnable {

int i;

public void run() {

i = 0;

try {

for(;;) {

Thread.yield();



if ( i == 50 ) break;

}

}catch(Exception e) {}

}

}

Este exemplo mostra a funcionalidade do método yield().

Suspende a execução da Thread

corrente e dá a oportunidade de

execução a próxima Thread da fila

de execução de mesma prioridade.




Versão: 3.0


138

Threads


public class ThreadContaCorrente implements Runnable

{

int saldo = 100;

public void run()

{

System.out.println(Thread.currentThread().getName());

for(int x=0; x < 10; x++)

{ try

{ Thread.sleep( (int) (Math.random() * 500));

catch(Exception err)

{ System.err.println("Erro: " + err); }

if (Thread.currentThread().getName().equals("deb"))

{

saldo -= 1;

}

else

{

saldo += 1;

}

System.out.println(Thread.currentThread().getName() + " Saldo: " + saldo);

}

}}

public class TestSynchronized

{


{ ThreadContaCorrente cc = new ThreadContaCorrente();

Thread debito = new Thread(cc);

Thread credito = new Thread(cc);

debito.setName("deb");

debito.start();

credito.setName("cre");

credito.start();

}}

Este exemplo é divido em duas partes. A primeira parte não implementa o recurso de

sincronismo.




Versão: 3.0


139

Threads


Esta a segunda parte. Neste caso implementamos o recurso de sincronismo.

public class TestSynchronizedON

{


{

ThreadContaCorrenteON cc = new ThreadContaCorrenteON();

Thread debito = new Thread(cc);

Thread credito = new Thread(cc);

debito.setName("deb");

debito.start();

credito.setName("cre");

credito.start();

}

}

public class ThreadContaCorrenteON implements Runnable

{

int saldo = 100;

public synchronized void run()

{

System.out.println(Thread.currentThread().getName());

for(int x=0; x < 10; x++)

{ try

{ Thread.sleep(5); }

catch(Exception err)

{ System.err.println("Erro: " + err); }

if (Thread.currentThread().getName().equals("deb"))

{

saldo -= 1;

}

else

{

saldo += 1;

}

System.out.println(Thread.currentThread().getName() + " Saldo: " + saldo);

}

}}

Implementação

do sincronismo




Versão: 3.0


140

Serialization


Serialization é implementação de persistência em Java. O que é persistência ?

É a possibilidade de gravar métodos virtuais em um meio físico, por exemplo Hard Disk.

Entretanto alguns recursos não suportam a persistência são eles: THREADS, IMAGENS

E CONEXÕES.

A persistência deve ser implementada com cuidado, pois, uma vez implementada,

poderemos ter problemas com segurança., pois os métodos podem representar as

regras de negócios e estas podem acabar sendo violadas.

Para especificar os recursos e/ou atributos que não devem ser persistindo, devemos

usar a palavra reservada chamada “transient”.

Exemplos:

Implementação do modificador transient

import java.io.*;

public class MyClass implements Serializable {

public transient Thread MyThread;

private String codeID;

}

import java.io.*;

public class MyClass implements Serializable {

public transient int code;

private String codeID;

}




Versão: 3.0


141

Serialization


import java.io.*;

import java.util.*;

public class TestSerializeVector {

TestSerializeVector()

{



v.addElement(new Integer(x));

try {

FileOutputStream f = new FileOutputStream ("vector.ser");

ObjectOutputStream s = new ObjectOutputStream (f);

s.writeObject (v);

s.close ();

} catch (IOException e) {

e.printStackTrace ();

}

}

public static void main (String args[]) {

new TestSerializeVector();

}

}

Este exemplo é divido em duas partes. A primeira exibe como gravar um objeto em

arquivo. Gravar objeto vetor no arquivo Vector.ser

Os dados do

objeto

Gravação




Versão: 3.0


142

Serialization


import java.io.*;

import java.util.*;

public class TestUnSerializeVector {

TestUnSerializeVector () {

Vector v = null;

Object obj = null;

try {

FileInputStream f = new FileInputStream ("vector.ser");

ObjectInputStream s = new ObjectInputStream (f);

System.out.println(s);

v = (Vector) s.readObject ();

s.close ();

} catch (Exception e) {


}

System.out.println(

"Unserialized Vector object from vector.ser");

Object[] objArray = v.toArray();


{

System.out.println(objArray[x]);

}

}

public static void main (String args[]) {

new TestUnSerializeVector();

}

}

A segunda parte demonstra como recuperar o objeto e os dados gravados em um

arquivo. Nome do arquivo Vector.ser (objeto vector)

Recuperação

Note que é

necessário fazer

a coerção de tipo

(Vector)




Versão: 3.0


143

Serialization


import java.io.*;

import java.util.Date;

import java.util.*;

public class TestSerialize {

public void doSerialize()

{

try

{ FileOutputStream ostream = new FileOutputStream("dados.ser");

ObjectOutputStream p = new ObjectOutputStream(ostream);

p.writeInt(12345);

p.writeObject("Today");

p.writeObject(new Date());

p.flush();

ostream.close();



}finally

{ System.out.println("Process ok"); }

}

public void unDoSerialize() {

try

{ FileInputStream istream = new FileInputStream("dados.ser");

ObjectInputStream p = new ObjectInputStream(istream);

int i = p.readInt();

String today = (String)p.readObject();

Date date = (Date)p.readObject();

System.out.println(p);

istream.close();

System.out.println("String: " + today);

System.out.println("Date: " + date);

System.out.println("int: " + i);



}

}

TestSerialize()

{ doSerialize();

unDoSerialize();

}


{

new TestSerialize();

}

}

Gravação

Recuperação

Para cada tipo

de dados foi

usado o método

apropriado.

Objeto = readObject

Int = readIn

Este exemplo mostra como

criar um método para fazer

a gravação e outro para

fazer a recuperação.




Versão: 3.0


144

TCP/IP


Servidor

ServerSocket(port #)

ServerSocket.accept()

Sockect()

(Fluxo de Mensagens)

InputStream

OutputStream

Socket.close()

Cliente

ServerSocket(host,

port #)

(tentativa de

conexão)

(Fluxo de Mensagens)

InputStream

OutputStream

Socket.close()

TCP/IP Socket Connections

API java.net possiblita a implementação de Datagram Sockets e Stream Sockets. Com

Soquetes de Fluxo, podemos estabelecer conexão entre um cliente e servidor, enquanto

perdurar a conexão podemos trocar mensagens, este fluxo de mensagem é controlado,

casa haja algum problema entre as mensagens enviadas e recebidas, elas podem ser

corrigidas. Este serviço é chamado orientado a conexão, o protocolo utilizado é TCP.

Já os Soquetes Datagramas, as mensagens são transmitidas em pacotes, entretanto, o

fluxo de troca de mensagens não são controlados, isto quer dizer, que eles podem ser

perdidos (nunca chegar ao seu destino, por exemplo) entre outras coisas. Este serviço é

chamado serviço sem conexão, o protocolo utilizado é UDP.

Abaixo um esquema válido para Serviço orientada a conexão (TCP)




Versão: 3.0


145

TCP/IP


Métodos Descrição

ServerSocket(port #,

number clientes)

Estabelece a porta em que um servidor espera a

conexão. O segundo parâmetro para o construtor

é quantidade de clientes que podem esperar uma

conexão e ser processada pelo servidor, se as

filas estiverem repletas, as conexão são

recusadas automaticamente.

accept Espera o estabelecimento de uma conexão,

retorna o objeto socket (quando estabelecido uma

conexão)

sockets responsável pelo gerenciamento dos serviços

baseados em conexão.

close Fecha a conexão

setSoTimeout(int timeout) Estabele um timeout em milesegundos

public int getSoTimeout() Retorna o tempo estabelecido para timeout

Classe de Exceptions:SocketException





Versão: 3.0


146

TCP/IP


import java.net.*;

import java.io.*;

public class TestServer {


ServerSocket s= null;

try {

s = new ServerSocket(5432);



}

for (;;) {

try {

Socket s1 = s.accept();

OutputStream s1out = s1.getOutputStream();

DataOutputStream dos = new DataOutputStream(s1out);

// Envia a mensagem

dos.writeUTF("Hello Net World!");

dos.close();

s1.close();



}

}

}

}

Exemplos:

Este exemplo é divido em duas partes. A primeira exibe como criar um Servidor.

API

Objecto

ServerSocket Número da Porta

Fluxo de Dados

Encerra a o fluxo

de dados e a

conexão

Espera o

estabelecimento

de conexão




Versão: 3.0


147

TCP/IP


import java.net.*;

import java.io.*;

public class TestClient {


try {

// Endereço IP é Localhost

Socket s1 = new Socket("127.0.0.1", 5432);

InputStream is = s1.getInputStream();

DataInputStream dis = new DataInputStream(is);

System.out.println(dis.readUTF());

dis.close();

s1.close();

} catch (ConnectException connExc) {

System.err.println("Could not connect to the server.");



}

}

}

Exemplos:

Este é segunda parte. A criação de um cliente.

Objeto Socket, veja

os parâmtros no Construtor

“”Endereço IP”

e “Número da Porta” do

Servidor

Fluxo de Dados

Leitura do Fluxo

API




Versão: 3.0


148

TCP/IP


Cenário da Conexão Servidor e Cliente

TestServer TestClient

TCP/IP

129.1.13.1

IP

Porta

5432 Hello...

Mensagem

Fluxo de Dados




Versão: 3.0


149




Versão: 3.0


150

Introdução a UML

O Quê é a UML?

A UML (Linguagem de Modelagem Unificada) é uma linguagem-padrão para elaboração

da estrutura de projetos de software. A UML poderá ser usada para:

• Visualização

• Especificação

• Construção de modelos e diagramas

• Documentação.

A UML é adequada para a modelagem de sistemas, cuja a abrangência poderá incluir

sistemas de informação corporativos a serem distribuídos a aplicação baseadas em Web

e até sistemas complexos embutidos de tempo real.

A UML é apenas uma linguagem e, portanto, é somente uma parte de um método para

desenvolvimento de software. Ela é independente do processo, apesar de ser

perfeitamente utilizada em processo orientado a casos de usos, centrado na arquitetura,

iterativo e incremental.

• Diagrama de Caso de Uso

• Diagrama de Seqüência

• Diagrama de Colaboração

• Diagrama de Estados

• Diagrama de Classes

• Diagrama de objetos

• Diagrama de Atividades

• Diagrama de Componentes

• Diagrama de Distribuição

• Diagrama de Pacotes

Principais

Diagramas:




Versão: 3.0


151

Casos de Uso

O que são Caso de Uso?

São diagramas de que permitem visualizar, especificar e documentar o comportamento

de um elemento. Esses diagramas fazem com que sistema, subsistemas e classes

fiquem acessíveis e compreensíveis, por apresentarem uma visão externa sobre como

esses elementos podem ser utilizados no contexto.

Definição:

Caso de Uso é uma descrição de um conjunto de seqüências de ações, inclusive

variantes, que um sistema pode produzir um resultado de valor observável por um ator.

A representação gráfica é uma elipse.

Elementos:

Ator:

Um ator representa um conjunto coerente de papéis que os usuários de casos de uso

desempenham quanto interagem com esses casos de uso. Geralmente um ator

representa um papel, que pode ser de pessoa, de um sistema ou de um dispositivo.

Cenários:

Podemos definir os cenários como uma “descrição” de um Caso de uso. O caso de uso

deve ser descrito através de cenários. Devem ser construídos tantos cenários quantos

forem necessários para se entender completamente todo o sistema. Podem ser

considerados como teste informais para validação dos requisitos do sistema.

Introdução a UML




Versão: 3.0


152

Diagramas de Caso de Uso e Extensões

Professor

Selecionar curso

para ensinar

Pedir lista dos

matriculados

Gerenciar

Manter informação de

aluno

Manter informação de

professor

Gerar catalogo

Manter informações dos

cursos

Sistema de

cobrançaMatrícula nos

Cursos

Aluno

Casos de Uso

Generalização:

Entre casos de uso é parecida à generalização existente entre as classes.

No caso de uso a generalização significa que o caso de uso filho herda o

comportamento e o significado do caso de uso pai; o filho poderá acrescentar ou

sobrescrever o comportamento de seu pai; poderá ser substituído em qualquer

local qual o pai apareça.

Include:

Quando você estiver se repetindo em dois ou mais caso de uso separados,

devemos evitar a repetição

Extends:

Quando estivermos descrevendo uma variação em comportamento normal,

entretanto, querendo fazer uma descrição mais controlada, explicando os pontos

de extensão no caso de uso.

Realizes:

Especifica a colaboração entre os casos de uso

Use (obsoleto): Especifica que a semântica do elemento de origem depende da

semântica da parte pública do destino

Introdução a UML




Versão: 3.0


153

Diagrama de Seqüência

O que é Diagramas de Seqüência?

É um diagrama que exibe a colaboração dinâmica entre os vários objetos de um sistema.

O principal aspecto deste diagrama é que a partir dele percebe-se a seqüência de

mensagens enviadas entre os objetos. Ele mostra a interação entre os objetos, alguma

evento que acontecerá em um ponto específico da execução do sistema.

formulários

de registro

formulário

de matrícula

cursos

disponíveis

Ator (José) entrar com chave de

acessovalidar acesso

entrar com o

semestre

criar nova matrículaapresentar em tela

obter cursos


Introdução a UML




Versão: 3.0


154

Diagrama de Colaboração

O que é Diagramas de Colaboração?

É um diagramas que mostra a colaboração dinâmica entre os objetos, semelhante ao

diagrama de seqüência. No diagrama de colaboração, além de mostrar a troca de

mensagens entre os objetos, percebe-se também os objetos com os seus

relacionamentos. A interação de mensagens é mostrada em ambos os diagramas. Se a

ênfase do diagrama for o decorrer do tempo, é melhor escolher o diagrama de seqüência,

mas se a ênfase for o contexto do sistema, é melhor dar prioridade ao diagrama de

colaboração. Podemos também escolher ambos.

O diagrama de colaboração é desenhado como um diagrama de objeto, onde os diversos

objetos são mostrados juntamente com seus relacionamentos. As setas de mensagens

são desenhadas entre os objetos para mostrar o fluxo de mensagens entre eles. As

mensagens são nomeadas, que entre outras coisas mostram a ordem em que as

mensagens são enviadas. Também podem mostrar condições, interações, valores de

resposta e etc. O diagrama de colaboração também pode conter objetos ativos, que

executam paralelamente com outros.

6:obter cursos

Ator (José)

formulários de registro

2: validar acesso

1:entrar com chave

de acesso3:entrar com o

semestre

4:criar nova matrícula

formulário de matrículacursos disponíveis

5:apresentar

em tela

Diagrama de Colaboração

Introdução a UML




Versão: 3.0


155

Diagrama de Estado

O que é Diagrama de Estado?

É um diagrama que tipicamente complementa a descrição das classes. Pois este

diagrama exibe todos os estados possíveis que objetos de uma certa classe podem se

encontrar. E mostra também quais são os eventos do sistemas que provocam tais

mudanças.

Não necessário escrever o diagrama de estado para todas as classes de um sistema,

mas apenas para aquelas que possuem um número definido de estados conhecidos e

onde o comportamento das classes é afetado e modificado pelos diferentes estados.

Diagramas de estado capturam o ciclo de vida dos objetos, subsistemas e sistemas.

Eles mostram os estados que um objeto pode possuir e como os eventos (mensagens

recebidas, tempo, erros, e condições sendo satisfeitas) afetam estes estados ao passar

do tempo.

Registro fechado

[númeroDeAlunos<3]

cancelarCurso�

cancelarCursocancelarCurso

Registro fechado

[númeroDeAlunos>=3

]

Registro fechado [número

de alunos =10]^Curso

.Criar relatório

Matrícula aberta/inicialize

númeroDeAlunos = 0

Curso Completado

faça: Gerar lista de

alunos

Criação

faça: Crie o

objeto curso

Atribuição Cursofaça: Atribuir um

professor ao curso

Curso Aberto

Entrada: Registre

um aluno

Adicionar Aluno

Curso Encerrado

faça: relate cursoesta cheio

Curso Cancelado

faça: envie notificação

de cancelamento

cancelarCurso�

Introdução a UML




Versão: 3.0


156

Diagrama de Atividade

O que é Diagrama de Atividade?

É um diagramas que exibe o fluxo seqüencial das atividades, é geralmente utilizado para

demonstrar as atividades executadas por uma operação específica do sistema, como por

exemplo seleção de um item do menu principal. Consistem em estados de ação, que

contém a especificação de uma atividade a ser desempenhada por uma operação do

sistema. Decisões e condições, como execução paralela, também podem ser mostrados

na diagrama de atividade. O diagrama também pode conter especificações de

mensagens enviadas e recebidas como partes de ações executadas.

Diagramas de atividade capturam ações e seus resultados. Eles focam o trabalho

executado na implementação de uma operação (método), e suas atividades numa

instância de um objeto. O diagrama de atividade é uma variação do diagrama de estado e

possui um propósito um pouco diferente do diagrama de estado, que é o de capturar

ações (trabalho e atividades que serão executados) e seus resultados em termos das

mudanças de estados dos objetos.

Fazer Pedido

Cliente

Processar Pedido

Separar Produtos

Enviar Pedido

Cobrar Cliente

Fechar Pedido

Receber Pedido

Pagar Fatura

Vendas Estoque

Introdução a UML




Versão: 3.0


157

Diagrama de Pacotes

Como podemos definir o diagrama de pacotes?

A definição de Pacote é uma generalização, ou seja, um agrupamento, com o propósito de

organizar as Classes de Objetos em grupos. Esta abordagem facilita a análise a medida

que o número de Classes de Objetos cresce num do cenário. O tipo de relacionamento é

linha pontilhada com uma seta que indica dependência.

A notação usada pela UML para representar pacotes é:

Nome do Pacote

Exemplo: As classes pertencentes ao Sistema de Matrícula podem ser agrupadas em três

pacotes:

• UI (Interface com usuário)

• Regras de Negócio

• Interfaces de Banco de Dados

Interfaces de

Banco de Dados

{abstrata}

Interfaces com

UsuárioRegras de

Negócios

Interface

Oracle

Interface

MySQL

Introdução a UML




Versão: 3.0


158

Diagrama de Classes

O que é um Diagrama de Classes?

É um diagrama que demonstra a estrutura estática das classes de um sistema e seus

relacionamentos. Classes podem se relacionar com outras através de diversas maneiras:

associação (conectadas entre si), dependência (uma classe depende ou usa outra classe),

especialização (uma classe é uma especialização de outra classe), ou em pacotes

(classes agrupadas por características similares). Todos estes relacionamentos são

mostrados no diagrama de classes juntamente com as suas estruturas internas, que são

os atributos e operações. O diagrama de classes é considerado estático já que a estrutura

descrita é sempre válida em qualquer ponto do ciclo de vida do sistema. Um sistema

normalmente possui alguns diagramas de classes, já que não são todas as classes que

estão inseridas em um único diagrama e uma certa classes pode participar de vários

diagramas de classes.

1..*

1

1

tem

Professores

Pessoa

AlunosFuncionários

Administrativo

Curso

Disciplinas

Matricula11

1

Uma classe num diagrama pode ser diretamente implementada utilizando-se uma

linguagem de programação orientada a objetos que tenha suporte direto para

construção de classes. Para criar um diagrama de classes, as classes têm que estar

identificadas, descritas e relacionadas entre si.

Introdução a UML




Versão: 3.0


159

Diagrama de Objetos

O que é um Diagrama de Objetos?

É um diagrama que exibe uma variação do diagrama de classes e utiliza quase a mesma

notação. A diferença é que o diagrama de objetos mostra os objetos que foram

“instanciados” das classes. O diagrama de objetos é como se fosse o perfil do sistema em

um determinado momento de sua execução. A mesma notação do diagrama de classes é

utilizada, entretanto há duas diferenças: os objetos são escritos com seus nomes

sublinhados e todas as instâncias num relacionamento são mostradas. Os diagramas de

objetos não tem a mesma importância do diagramas de classes, mas eles são muito úteis

para exemplificar diagramas complexos de classes ajudando muito em sua compreensão.

Diagramas de objetos também são usados como parte dos diagramas de colaboração,

onde a colaboração dinâmica entre os objetos do sistema são mostrados.

Nome: “Fulano de Tal”

Data: 23-02-2001

:Aluno

Matricula: 201-23-02-01

Curso: Adm Empresas

201-23-02-01:Matricula

Introdução a UML




Versão: 3.0


160

Diagrama de Componente

O que é um Diagrama de Componente?

É um diagrama que exibe o sistema por um lado funcional, expondo as relações entre

seus componentes e a organização de seus módulos durante sua execução.

O diagrama de componente descreve os componentes de software e suas dependências

entre si, representando a estrutura do código gerado. Os componentes são a

implementação na arquitetura física dos conceitos e da funcionalidade definidos na

arquitetura lógica (classes, objetos e seus relacionamentos). Eles são tipicamente os

arquivos implementados no ambiente de desenvolvimento.

Curso.jar Pessoa.jar

Aluno.class Professores.classDisciplina.classr

Introdução a UML




Versão: 3.0


161

Diagrama de Distribuição

O que é Diagrama de Distribuição?

É um diagrama que exibe a arquitetura física do hardware e do software no sistema.

Pode apresentar os atuais computadores e periféricos, juntamente com as conexões que

eles estabelecem entre si e pode mostrar também os tipos de conexões entre esses

computadores.

Especifica-se também os componentes executáveis e objetos que são alocados para

mostrar quais unidades de software são executados e em quais computadores são

executados.

O diagrama de distribuição demonstra a arquitetura “runtime” de processadores,

dispositivos físicos e de software que executam no ambiente onde o sistema

desenvolvido será utilizado. É o último diagrama da topologia do sistema, descrevendo

a estrutura de hardware e software que executam em cada unidade.

O diagrama de distribuição é composto por componentes, que possuem a mesma

simbologia dos componentes do diagrama de componentes, nodes, que significam

objetos físicos que fazem parte do sistema, podendo ser uma computador cliente em

uma Rede, um computador Servidor, uma impressora, um roteador, etc., e conexões

entre estes nodes e componentes que juntos compõem toda a arquitetura física do

sistema.

Cliente AServidor

de Aplicação

Servidor

de Banco de

Dados

<<TCP/IP>><<TCP/IP>>

0..* 1 1 1

Introdução a UML




Versão: 3.0


162

Transformando modelos UML

em código Java




Versão: 3.0


163

Implementação Java

Transformando diagramas UML em código Java

import java.awt.Graphics;

public class Hello extends java.applet.Applet

{

public void paint(Graphics g)

{

g.drawString("Hello", 15,15);

}

}

Nossa proposta é apresentar o mais simples exemplo de aplicação UML e Java, por

isso, não temos intenção de esgotar o tema UML.

Nosso exemplo é um velho conhecido, o programa Hello. Bem vamos começar pela

implementação do código e depois faremos uma engenharia reversa para obtermos os

diagramas e demais itens UML. Veja os passos abaixo:

public class

Tapplet

extends

Applet {

}

Código fonte

(java)Bytcode

(java)

Compilação

<HTML>

<body>

..

</body>

</HTML>

Arquivo

HTML

12

3

4

O programa Java

1

Primeiro Passo:

Criação do programa Java,

um Applet.

Segundo Passo:

Compilar o programa




Versão: 3.0


164

Implementação Java

<HTML>

<CAPTION>Hello</CAPTION>

<TR><TD>

<APPLET CODE="Hello.class" WIDTH=100 HEIGHT=100>

</APPLET>

</TD></TR>

</HTML>

A página HTML, Hello.html

3

4

A execução

Terceiro Passo:

Criação a página HTML,

o nome será Hello.html.

Para encerrar Quarto Passo:

Execução do programa, podemos

usar o Browser, mas neste caso usamos o

AppletViewer, que é utilitário Java, que

que exibe Applet, a partir de páginas HTML

Bem agora vamos para segunda parte, que é a modelagem dessa aplicação usando

UML.





Versão: 3.0


165

Modelagem UML

A Modelagem UML. Do programa Hello:

Hello

paint()g.drawString

(“Hello”, 15, 15)

O programa Hello pode ser representado graficamente pela figura acima, é claro que foi

omitido os detalhes e a implementação do método paint é feito através de nota

Hello

paint() Graphics

Applet

Agora temos um modelo de fato, veja os relacionamentos (herança e navegação) entre

as classes e a definição do método paint. O exemplo abaixo faz um mapeamento entre

o código Java e modelo UML.

Hello

paint() Graphics

Applet




{


}





Versão: 3.0


166

Modelagem UML - Pacotes


java org sunjavax

Bem como já dissemos, (Veja Miscelania - Pacotes) a linguagem Java é estruturada em

pacotes, estes pacotes contém classes que por sua vez contém atributos e métodos.

Podemos usar a estrutura de pacotes para associar classes com semânticas semelhante,

ou seja, classes que tem objetivo comum. Veja a estrutura abaixo:

applet awt

net

rmiiobeans

lang

math security

utiltextsql

As classes Applet

(pacote applet) e

Graphics (pacote) awt

que colaboram com

a classe Hello

Principais

pacotes

da Linguagem

Java

Principais

subpacotes

do pacote

Java




Versão: 3.0


167

Modelagem UML


java

awt

applet

lang

Hello


A figura acima demonstra o Diagrama de Pacotes da classe Hello, o pacote raiz (maior)

é o Java e outros outros pacotes (menores), que estão aninhados entro do pacote Java,

são os subpacotes, o relacionamento entre eles se dá através de dependência (seta

pontilhada). Por exemplo:

A classe Hello depende do pacote java.applet. E o java.applet depende do pacote java.awt.

Veja o código e os respectivos pacotes:



{


{


}

}

appletawt

lang




Versão: 3.0


168


java

awt

applet

lang

Hello

AppletConte

xt

Applet

AppletStub

Panel(from awt)

Container(from awt)

Component(from awt)

AudioClip

Object(from lang)

Graphics....

abstract void drawString(AttributedCharacterIterator iterator, int x, int y)

abstract void drawString(String str, int x, int y)

....

Esta figura demonstra uma visão mais detalhada dos pacotes e as respectivas classes e

atributos.


Interface




Versão: 3.0


169


Podemos fazer a modelagem da ordenação de eventos usando uma Diagrama de

Sequência, Veja o diagrama logo abaixo. A sequência se inicia com a execução do

objeto Thread que, por sua vez,

1 - invoca o método run() de Toolkit.

2 - O objeto Toolkit então chama uma de seus próprios métodos, callbackloop() que,

a seguir, chama ...

3 - handleExpose de ComponentPeer.

4 - O objeto ComponentPeer então chama o método paint() de seu alvo. O objeto

ComponentPeer assume que seu atributo é um Component, (Hello) e assim o método

paint() é executado de forma polimorfica.

Modelagem UML - Diagrama de Seqüência

:Thread :Toolkit :ComponenPeer :target Hello

run

run callbackLoop

handleExposepaint





Versão: 3.0


170


Modelagem UML e Codificação em Java

Herança Múltipla Vejamos a codificação Java:

public class ClientePessoaFisica extends Cliente implements Pessoa

{

public ClientePessoaFisica()

{

setNome("Duke");

System.out.println("Nome: " + getNome());

System.out.println("Tem dependente: " + getDependente(0));

}

public boolean getDependente(int dependente)

{

return (dependente>0)?true:false;

}

}

public interface Pessoa

{

public boolean getDependente(int dependente);

}

public class Cliente

{

String nome;


{

return this.nome;

}

public void setNome(String nome)

{

this.nome = nome;

}

}

public class ClientePessoaJuridica extends Cliente

{

public ClientePessoaJuridica()

{

System.out.println("Nome: " + getNome());

}

}

Implementação do

método assinado

na Interface Pessoa

Assinatura do método

Atributo

Métodos




Versão: 3.0


171




Versão: 3.0


172

Utilitários

JavaDoc (Documentação)

Opção Valor Descrição

-d path de saída Diretório onde será gerado os arquivos HTML

-sourcepath path Especifica o diretório raiz dos fontes ou dos Package

-public Documenta apenas variáveis e métodos públicos

-private Documenta todas as variáveis e métodos

Sintaxe: Javadoc [Opções] package/arquivo < package/arquivo>

Exemplo: javadoc MinhasClasses.class

Tags para Documentação: Usar: /** e */

Tag Declaração Class e

Interface

Construtor Método Atributo

@see Cria um link com outra

página HTMLX X X X

@deprecated Informa quais métodos

estão ultrapassadosX X X X

@author Nome do Autor X

@param Documenta o parametro X X

@throws

@Exception

Documenta Exceções X X

@return Documenta o returno (valor

e tipo)X

Javadoc

É uma utilitário do JDK que gera a documentação dos programas java, geralmente

em formato HTML.

Localização JDK1.X/BIN/Javadoc.

Sintaxe padrão: javadoc <arquivofonte.java>




Versão: 3.0


173

usage: javadoc [options] [packagenames] [sourcefiles] [classnames]

[@files]

-overview <file> Read overview documentation from HTML file

-public Show only public classes and members

-protected Show protected/public classes and members

(default)

-package Show package/protected/public classes and

members

-private Show all classes and members

-help Display command line options

-doclet <class> Generate output via alternate doclet

-docletpath <path> Specify where to find doclet class files

-1.1 Generate output using JDK 1.1 emulating doclet

-sourcepath <pathlist> Specify where to find source files

-classpath <pathlist> Specify where to find user class files

-bootclasspath <pathlist> Override location of class files loaded

by the bootstrap class loader

-extdirs <dirlist> Override location of installed extensions

-verbose Output messages about what Javadoc is doing

-locale <name> Locale to be used, e.g. en_US or en_US_WIN

-encoding <name> Source file encoding name

-J<flag> Pass <flag> directly to the runtime system

Provided by Standard doclet:

-d <directory> Destination directory for output files

-use Create class and package usage pages

-version Include @version paragraphs

-author Include @author paragraphs

-splitindex Split index into one file per letter

-windowtitle <text> Browser window title for the documenation

-doctitle <html-code> Include title for the package index(first)

page

-header <html-code> Include header text for each page

-footer <html-code> Include footer text for each page

-bottom <html-code> Include bottom text for each page

-link <url> Create links to javadoc output at <url>

-linkoffline <url> <url2> Link to docs at <url> using package list at

<url2>

-group <name> <p1>:<p2>.. Group specified packages together in overview

page

-nodeprecated Do not include @deprecated information

-nosince Do not include @since information

-nodeprecatedlist Do not generate deprecated list

-notree Do not generate class hierarchy

-noindex Do not generate index

-nohelp Do not generate help link

-nonavbar Do not generate navigation bar

-serialwarn Generate warning about @serial tag

-charset <charset> Charset for cross-platform viewing of

generated documentation.

-helpfile <file> Include file that help link links to

-stylesheetfile <path> File to change style of the generated

documentation

-docencoding <name> Output encoding name

Javadoc


Utilitários




Versão: 3.0


174


Utilitários

Este exemplo exibe como implementar as tags de documentação que serão usados

pelo utilitário Javadoc

import java.util.List;

/**

* @author YourName

* @version 2.0

*/

public class DocExemplo {

/** Declaração e atribuição de x. */

private int x;

/**

* This variable a list of stuff.

* @see #getStuff()

*/

private List stuff;

/**

* O construtor inicia a variavel x.

* @param int x

*/

public DocExemplo(int x) {

this.x = x;

}

/**

* Este método retorna algum valor.

* @throws IllegalStateException se nenhum retorno for encontrado

* @return A lista de valores

*/

public List getStuff()

throws IllegalStateException {

if ( stuff == null ) {

throw new java.lang.IllegalStateException("Erro, sem valor");

}

return stuff;

}

}




Versão: 3.0


175


Utilitários

Exemplo:

Para gerar a documentação digite o seguinte comando:

c:\jdk1.3\bin\javadoc.exe -version -author DocExemplo.java...

Depois chame a página principal “index.html” via Browser.

A figura acima é exemplo de documentação gerada pelo Javadoc.




Versão: 3.0


176

Jar (Compactação, Agrupamento e Distribuição)

Sintaxe: jar opções [meta-arq] nome-arquivo-destino [nome-arquivo-entrada]


meta-arquivo Arquivo que contém as informações sobre o arquivo destino gerado.

Este argumento é opcional, entretanto um arquivo meta-arquivo é

gerado, default, META-INF/MANIFEST.INF

arquivo-destino Nome do arquivo jar. A extensão .jar não é automatica, deve ser

especificada

arquivo-entrada Nome dos arquivos a serem agrupados e/ou compactados

Opções Descrição

c Cria um novo arquivo

t Mostra o conteúdo de um arquivo existente

x Extrai todos os arquivos

x <arquivo> Extrai o arquivo especificado

f Indica que a operação (c,t ou x) será executada sobre o arquivo e não

sobre a entrada/saída padrão.

v Mostra o status da operação (verbose)

m Suprime a geração do meta-arquivo

o Faz apenas o agrupamento, sem compactação. Deve ser utilizado

para arquivos jar na variável de ambiente Classpath

Exemplos:

jar cvf Classes.jar ClassA.class ClassB.class ClassC.class

Para ver o conteúdo do arquivo jar, gerado: jar tvf Classes.jar

Para extrair arquivo: Jar xvf Classes.jar

Obs: a opção f é sempre utilizada em operações com arquivos.

Jar

É um utilitário do JDK que faz agrupamento de arquivos em único, um arquivo .jar,

geralmente com compressão. Localização JDK1.X/BIN/Jar. É usado também para

fazer a distribuição de aplicação.

Os arquivos Jar podem conter um aplicação inteira, por isso, ele é usado para fazer

distribuição de aplicações. Também é bastante usado com componente Javabeans e

Applet.

Utilitários




Versão: 3.0


177

Esta classe Java requer um parâmetro

que deve ser passando na chamada

da classe, se o parâmetro não for

informado, isto provocará

uma exceção

JDB (debug)

É um utilitário do JDK, para fazer depuração de código. O primeiro passo é escrever

um programa em Java e depois aplicar o depurador de código. Principais comandos:

run (chama a máquina virtual),

cont (continução) e

quit ou exit (sai do JDB). Veja o exemplo abaixo:

Utilitários

public class Hello

{



System.out.println("Hello " + arg[0]);

}

}

O próximo passa é abrir uma janela “DOS”, chame o depurador jdb

<nomedoprograma> <enter>.

Então ferramenta será inicializada, veja abaixo toda a seqüência de depuração.

Por fim a exceção é localizada, ocorrerá na linha 5.




Versão: 3.0


178

Javap (Desmontagem)

Javap

Faz a desmontagem de código ou descompilação. Sintaxe:

javap <opções> <classes>

Lista das principais opções:

Utilitários

public class Hello

{


{

System.out.println("Hello”);

}

}

Código fonte, veja exemplo abaixo:

Código fonte


-c Desmonta o código

-classpath <pathlist> Especifica onde encontrar as classes

-help Imprime as mensagens de ajuda

-public Exibe somente as classe e membros públicos

-protected Exibe somente as classe e membros protegidos

-package Exibe somente as classe e membros pacotes (default) sem

modificador

-private Exibe somente as classe e membros privates

-s Imprime tipo de assinatura interna

-verbose Imprime a pilha e detalhes, tais como tamanho e etc.

Após compilar o programa fonte. Você poderá fazer a desmontagem do arquivo

Hello.class. Para desmontar digite o comando: javap Hello

Compiled from Hello.java

public class Hello extends java.lang.Object {

public Hello();

public static void main(java.lang.String[]);

}




Versão: 3.0


179




Versão: 3.0


180

A - Convenção de Código no Java

B - Sistema de Codificação Unicode

C - Registrando Fonte de Dados

D - Notação UML

Apêndices




Versão: 3.0


181

Apêndice A

Convenção de Código no Java

Classe - Os nome da classes devem um substantivo e ter a primeira letra

maiúscula o restante em minúsculo. Exemplo: public class Pessoa.

No caso de nome composto o primeiro e segundo nome deve começar com letras

maiúscula. Exemplo: public class PessoaFisica.

Não devemos usar espaço em branco para separa os nomes e nem usar o

sublinhado.

Interfaces - Seguir as mesmas regras para nome de classe

Métodos - Os nomes dos métodos podem ser verbos no infinitivo,

devendo ser escrito em letras minúscula. Exemplo: public int calcular.

Para nome composto usar a seguinte regra a o primeiro nome em minúsculo e a

primeira letra do segundo nome em maiúsculo, veja o exemplo: public int

calcularArea

Constantes - Nomes de constantes devem escritos em letras maiúsculas.

Exemplo: public static final VALOR

Atributos e Variáveis - Os nome dos atributos e/ou variáveis devem ser escritos

em letras minúsculas.

Controles de Estruturas: Através de { } (chaves);

*Espaços - Convencionou-se o uso de quatro espaços para indentações;

Comentários - Vide o capitulo sobre documentação

Para maiores detalhes veja:http://java.sun.com/docs/books/jls/index.html




Versão: 3.0


182

Apêndice B

Sistema de Codificação Unicode

O que é Unicode?

Unicode é sistema de codificação que fornece um número único para cada

caracter, Não importa a plataforma, não importa o programa, não importa a língua.

Fundamentalmente, os computadores lidam com números. Gravam letras e outros caracteres na

memória designando um número para cada um deles. Antes de o Unicode ser inventado, havia

centenas de sistemas diferentes de codificação . Nenhum destes sistemas de codificação, no

entanto, poderia conter caracteres suficientes: por exemplo, a União Européia por si só requer vários

sistemas de codificação diferentes para cobrir todas a línguas. Mesmo para uma única língua como o

inglês não havia sistema de codificação adequado para todas as letras, pontuação e símbolos

técnicos em uso corrente.

Estes sistemas de codificação são também conflitantes entre si. Em outras palavras, dois

codificadores podem usar o mesmo número para dois caracteres diferentes ou usar números

diferentes para o mesmo caracter. Qualquer computador em particular (especialmente os servidores)

precisam suportar muitos codificadores diferentes; ainda assim toda as vezes que se passam dados

entre codificadores ou plataformas diferentes, estes dados sempre correm o risco de serem

corrompidos.

O Unicode está mudando tudo isso!

O Unicode fornece um único número para cada caracter, não importa a plataforma, não importa o

programa, não importa a língua. O Padrão Unicode tem sido adotado por líderes do setor de

informática tais como a Apple, HP, IBM, JustSystem, Microsoft, Oracle, SAP, Sun, Sybase, Unisys e

muitos outros. O Unicode é necessário para padrões modernos tais como o XML, Java, ECMAScript

(JavaScript), LDAP, CORBA 3.0, WML, etc. e é a maneira oficial de implementar o ISO/IEC 10646. É

suportado por muitos sistemas operacionais, todos os browsers modernos e muitos outros produtos.

O surgimento do Padrão Unicode Standard e a disponibilidade de instrumentos para suportá-lo está

entre as tendências recentes mais significativas das tecnológicas mundiais de software.

Incorporar o Unicode aos servidores de clientes, aplicações de faixas múltiplas e websites oferece

uma redução significativa nos custos quando comparado ao uso de conjuntos de caracteres legacy.

O Unicode possibilita que um único software ou website seja alvejado através de plataformas,

línguas e países múltiplos sem a necessidade de reengenharia. Isto permite com que dados sejam

transportados através de muitos sistemas diferentes sem que sejam corrompidos.

Mais informações: www.unicode.org

http://www.unicode.org/unicode/consortium/memblogo.html

..\..\onlinedat/products.html




Versão: 3.0


183

Apêndice C

Registrando Fonte de Dados

Para registrar um fonte de Dados no Windows98, clique iniciar, configurações,

painel de controle e selecione Fonte de Dados ODBC.

Selecione uma fonte de

dados, por exemplo MS

Access 97 Database e

pressione o botão Adicionar.




Versão: 3.0


184

Apêndice C

Informe o nome

da fonte de dados.

Clicar no botão

Selecionar para

informar o

caminho onde ela

se encontra.

Para finalizar

clique em OK

Agora selecione o drive

Registrando Fonte de Dados




Versão: 3.0


185

SÍMBOLO GRÁFICO NOMEDIAGRAMAS EM QUEAPARECE USUALMENTE

MODELO A QUEPERTENCEM

ASSOCIAÇÂO DEAGREGAÇÃO

Diagrama de Classes,Diagrama de Componentes.

Classes de Objetos

Componentes

ASSOCIAÇÂO DECOMPOSIÇÃO

Diagrama de Classes,

Diagrama de Componentes.

Classes de Objetos

Componentes

ASSOCIAÇÂO DEDEPENDÊNCIA

Diagrama de Casos de Uso,Diagrama de Classes,Diagrama de Componentes,Diagrama de Implantação.

Caso de Uso

Classes de Objetos

Componentes

Componentes

ASSOCIAÇÂO DEGENERALIZAÇÃO

Diagrama de Casos de Uso,

Diagrama de Classes.

Caso de Uso

Classes de Objetos

ASSOCIAÇÂOREGULAR

Diagrama de Casos de Uso,Diagrama de Classes,Diagrama de Componentes,Diagrama de Implantação.

Caso de Uso

Classes de Objetos

Componentes

Componentes

ATORDiagrama de Casos de Uso,Diagrama de Seqüência.

Caso de Uso

Caso de Uso

CASO DE USO Diagrama de Casos de Uso. Caso de Uso

CLASSE Diagrama de Classes. Classes de Objetos

COMPONENTE Diagrama de Componentes Componentes

Nome do EstadoESTADO

Diagrama de Estados,

Diagrama de Atividades.

Classes de Objetos

Caso de Uso

ESTADO FINAL


Diagrama de Atividades

Classes de Objetos

Caso de Uso

Nome da Classe

Atributos

Operações

Nome do Componente

Apêndice D

Notação UML




Versão: 3.0


186

ESTADO INICIALDiagrama de Estados,Diagrama de Atividades.

Classes de Objetos

Caso de Uso

Nome da “Interface” ou

“INTERFACE”Diagrama de Componentes Componentes

INTERVALO DEEXECUÇÃO DE

OPERAÇÂODiagrama de Seqüência Caso de Uso

MENSAGEM DERETORNO

Diagrama de Seqüência Caso de Uso

MENSAGEM ECHAMADA DEOPERAÇÂO“Síncrona”


MENSAGEM ECHAMADA DEOPERAÇÃO“Assíncrona”


NÓ Diagrama de Implantação Componentes

texto NOTA Em qualquer diagrama

identificador:Classe ou :Classe

OBJETODiagrama de Seqüência,


Caso de Uso

Caso de Uso

Nome do Pacote PACOTE

Em qualquer diagrama em que énecessário representar umconjunto de coisas que devemestar agrupadas para efeito deuma organização apropriada

TRANSIÇÃO DEESTADO



Classes de Objetos

Caso de Uso

AUTODELEGAÇÃO Diagrama de Seqüência Caso de Uso

<<interface>> Nome da “Interface”

Operação1 ()Operação2 ()

Operação3 ()

Apêndice D

Notação UML




Versão: 3.0

Rildo F Santos ([email protected]) 187

Notas:

Marcas Registradas:

Todos os termos mencionados e reconhecidos como Marca Registrada e/ou

comercial são de responsabilidade de seus proprietários. O autor informa não estar

associada a nenhum produto e/ou fornecedor apresentado neste material. No decorrer

deste, imagens, nomes de produtos e fabricantes podem ter sido utilizados, e desde já

o autor informa que o uso é apenas ilustrativo e/ou educativo, não visando ao lucro,

favorecimento ou desmerecimento do produto/fabricante.

É expressamente proibido o uso deste material para fins comerciais.

Melhoria e Revisão:

Este material esta em processo constante de revisão e melhoria, se você encontrou

algum problema ou erro envie um e-mail nós.

Criticas e Sugestões:

Nós estamos abertos para receber criticas e sugestões que possam melhorar o

material, por favor envie um e-mail para nós.

Rildo F dos Santos ([email protected])

Imagens:

Google, Flickr e Banco de Imagem.




Versão: 3.0

Rildo F Santos ([email protected]) 188

Licença:

Documents

Java Basico