Vous êtes sur la page 1sur 188

Linguagem de Programação JAVA

JB100 Java Básico

Autor: Rildo F Santos (rildosan@uol.com.br)

Revisão 3.0 27/01/09


Rildo F Santos (rildosan@uol.com.br)
© Copyright e-tecnologia.com, 2002 Versão: 3.0
Linguagem de Programação JAVA
JB100 Java Básico
Estrutura do Curso

Introdução Apresenta arquitetura da linguagem Java

Fundamentos Apresenta comandos e funcionalidades


da linguagem básicas

Programação
Principais aspectos da programação
Orientada
orientada a objetos
a Objetos

Características Apresentar características avançada da


Avançadas Linguagem (Threads, networking e etc)

Introdução Apresentar uma visa geral da UML e seus


a UML os principais componentes

Demonstrar os principais utilitários da


Utilitários
linguagem Java (Jar, JadaDoc e etc)

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 2
Linguagem de Programação JAVA
JB100 Java Básico
Conteúdo
Introdução Características Avançadas
breve apresentação Instanceof
gerando aplicações Exception
Instalação do JDK Formatando Números e Datas
O primeiro programa Constantes
Threads
Fundamentos da linguagem Java Serialization
Estrutura da linguagem TCP/IP
Palavras Reservadas
Tipos de Dados Introdução a UML
Inicialização de variáveis Utilitários
Operadores JavaDoc
A classe String Jar
A classe StringBuffer JDB
Casting Javap
Fluxo de Controle
Arrays Apêndice
Passagem de Parâmetros Convenção de Código no Java
A classe Math Unicode
Empacotamento de Classes Notação UML
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

Nota
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)

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 3
Linguagem de Programação JAVA
JB100 Java Básico
Objetivo

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.

Objetivo deste curso:

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.

Expectativas após o 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;

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 4
Linguagem de Programação JAVA
JB100 Java Básico

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 5
Linguagem de Programação JAVA
JB100 Java Básico
Introdução a linguagem 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).

Java

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 6
Linguagem de Programação JAVA
JB100 Java Básico
Introdução a linguagem Java

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:

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

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 7
Linguagem de Programação JAVA
JB100 Java Básico
Introdução a linguagem Java

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

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

Java public class Hello


{
public static void main (String arg [])
{
System.out.println("Hello” + “\n”);
}
}

C++ #include <iostream.h>

int main ()
{
cout << “Hello \n" ;
return 0;
}

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 8
Linguagem de Programação JAVA
JB100 Java Básico
Introdução a linguagem Java
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:

public class HelloWorldApp


{ Compilação:
public static void main (String arg []) > javac Hello.java
{
System.out.println("Hello World!");
}
} Execução:
> java Hello
O mesmo código fonte

Hello
World Hello
World
Hello
World
Sistema Operacional e
Processadores diferentes

"write once, run anywhere."


Rildo F Santos (rildosan@uol.com.br)
© Copyright e-tecnologia.com, 2002 Versão: 3.0 9
Linguagem de Programação JAVA
JB100 Java Básico
Introdução a linguagem Java
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.

3
Java myProgram

2
Javac myProgram.java

Na linguagem Java a compilação ocorre apenas uma vez e a interpretação ocorre a cada
vez que o programa é executado.

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 10
Linguagem de Programação JAVA
JB100 Java Básico
Introdução a linguagem Java

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

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 11
Linguagem de Programação JAVA
JB100 Java Básico
Introdução a linguagem Java

Instalação do ambiente de desenvolvimento (JDK)


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

Resumo:
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: documentação
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.

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 12
Linguagem de Programação JAVA
JB100 Java Básico
Introdução a linguagem Java

Instalação do ambiente de desenvolvimento (JDK)

Sistema Operacional
Ambiente necessário nos
Ambiente para os desenvolvedores Clientes (usuários finais)

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.

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 13
Linguagem de Programação JAVA
JB100 Java Básico
Introdução a linguagem Java

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

Veja abaixo a lista dos principais argumentos:


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ão
armazenadas
-deprecation Faz a compilação de código em desuso, geralmente de versões
anteriores 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 arquivo


que está sendo compilado. Normalmente somente é compilado o
arquivo fonte mais as classes que este invoca.

Exemplos:

> javac Hello.java

> javac -d . Hello.java

> javac -deprecation Hello.java

> javac -O -deprecation -verbose Hello.java

> javac -O Hello.java

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 14
Linguagem de Programação JAVA
JB100 Java Básico
Introdução a linguagem Java

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

Veja abaixo a lista das principais opções:


Argumento Descrição
-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= Possibilita redefinição de valores de propriedades. Pode ser usado
valor 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 Define a lista de argumentos que será enviada a aplicação
Argumentos

Alguns Exemplos:

> java Hello

> javac -version

> java -D nome=“Meu Nome” Hello

> java -verbose Hello

> javac Hello MeuNome

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 15
Linguagem de Programação JAVA
JB100 Java Básico
Introdução a linguagem Java

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.

Programa
Fonte

Javac <programafonte.java>

Programa Class Loader


Compilado

J
Byte Code Verifier
Java <programafonte> V
M
Runtime

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 16
Linguagem de Programação JAVA
JB100 Java Básico
Introdução a linguagem Java

Garbage Collection

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.

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 17
Linguagem de Programação JAVA
JB100 Java Básico
Introdução a linguagem Java

Escrevendo um pequeno programa

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

public class Hello


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

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 18
Linguagem de Programação JAVA
JB100 Java Básico
Introdução a linguagem Java

Escrevendo um pequeno programa


Dissecando o código
modificador

Nome da classe
Lista de argumentos
public class Hello
(o tipo em questão é String)
Classe {
(corresponde public static void main (String arg [])
Método { String s = "world";
ao arquivo principal Variável
que será gravado System.out.println("Hello " + s);
do disco) }
}
método
Atributo da
Classe java Classe System
Tipo de dado

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

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 19
Linguagem de Programação JAVA
JB100 Java Básico
Introdução a linguagem Java

Escrevendo um pequeno programa

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.

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 20
Linguagem de Programação JAVA
JB100 Java Básico

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 21
Linguagem de Programação JAVA
JB100 Java Básico
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
/*
Exemplo onde o comentário usa mais que uma linha.
A variável x é integer
Todo o texto entre "/*" e "*/", inclusive, são ignorados pelo
*/
compilador
int x;
/**
x -- um valor inteiro representa
Todo o texto entre o "/**" e "*/", inclusive, são ignorados
a coordenada x
pelo compilador mas serão usados pelo utilitário javadoc.
*/
int x;

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:

public class TestEstrutura


{
public void sayHello(String hello)
{
Bloco da Classe System.out.println("Hello ");
}
}

Ponto e virgula
Bloco do Método

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 22
Linguagem de Programação JAVA
JB100 Java Básico
Fundamentos da Linguagem Java

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

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


TestIdentificador.java:3: illegal start of type
private 1nome;

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

Identificador
(nome da classe) Identificador
public class Hello
(nome do método)
{
public static void main (String arg [])
Método { String s = "world";
Classe
principal Veja que primeiro
System.out.println("Hello " + s); foi definido
} o tipo de dado,
} String, e depois o
nome do Identificador
(nome do variável)

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 23
Linguagem de Programação JAVA
JB100 Java Básico
Fundamentos da Linguagem Java

Palavras Reservadas

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

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


{ Palavra reservada
private int return =1;
Palavra reservada
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)

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 24
Linguagem de Programação JAVA
JB100 Java Básico
Fundamentos da Linguagem Java

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 Código de escape
„\\‟ - \
„\” ”‟ - “”

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;

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 25
Linguagem de Programação JAVA
JB100 Java Básico
Fundamentos da Linguagem Java

Tipos de Dados

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

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 Precisão


32 bits IEEE 754-1985 Float 1,4E-45 a 3,4E+38 7 dígitos
64 bits IEEE 754-1985 Double 4,9E-324 a 1,7E+308 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

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 26
Linguagem de Programação JAVA
JB100 Java Básico
Fundamentos da Linguagem Java

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.

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 27
Linguagem de Programação JAVA
JB100 Java Básico
Fundamentos da Linguagem Java

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

Operadores Lógicos:

> Maior que <= Menor que ou igual == Igual

< Menor que >= Maior que ou igual != Diferente

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

Exemplos:
i > 10;
x == y;
“Test” != “teste”
!y
x || y

Operadores Matemáticos:

+ Adição * Multiplicação ++ Incremento


- Subtração + Positivo (unário) -- Decremento

/ Divisão - Negativo (unário) % Módulo

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;

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 28
Linguagem de Programação JAVA
JB100 Java Básico
Fundamentos da Linguagem Java

Operadores

Outros Operadores:

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


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

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.

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 29
Linguagem de Programação JAVA
JB100 Java Básico
Fundamentos da Linguagem Java

Operadores

Operadores Binários:

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

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 Os bits no resultado são configurados como 1 se pelo menos um
bits dos bits correspondentes nos dois operandos for 1
^ OR exclusivo sobre Os bits no resultado são configurados como 1 se somente um dos
bits bits correspondentes nos dois operandos for 1
<< Deslocamento para Desloca os bits do primeiro operando para a esquerda pelo número
esquerda de bits especificado pelo segundo operando; preenche a partir da
direita com bits 0.
>> Deslocamento para Desloca os bits do primeiro operando para a direita pelo número
direita com extensão de bits especificado pelo segundo operando. Se o primeiro
de sinal operando for negativo, preenche com 1s a partir da esquerda; caso
contrário, preenche com 0s a partir da esquerda.
>>> Deslocamento para Desloca os bits do primeiro operando para a direita pelo número
direita com extensão de bits especificado pelo segundo operando; 0s são inseridos a
de zero partir da esquerda
~ Complemento de um Todos os bits são configurados como 1 e todo os bits são
configurados como 0.

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
4
-256 >> 1 <=> -256/2 = -16

Left Shift (<<)


128 << 1 <=> 128 * 21 = 256
16 << 2 <=> 16 * 22 = 64

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 30
Linguagem de Programação JAVA
JB100 Java Básico
Fundamentos da Linguagem Java

Operadores

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

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);
}

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
Lista de *= x *= y x = x * y
Exemplos /= 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

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 31
Linguagem de Programação JAVA
JB100 Java Básico
Fundamentos da Linguagem Java
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

Exemplo: 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);
}
}

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 32
Linguagem de Programação JAVA
JB100 Java Básico
Fundamentos da Linguagem Java
StringBuffer

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

Exemplo: public class TestStringBuffer


{
public static void main(String arg[])
{
//new instance
StringBuffer b1 = new StringBuffer();
Várias formas StringBuffer b2, b3;
de declaração 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() );
System.out.println("b2:" + b2.toString() );
System.out.println("b3:" + b3.toString() );
b3.append("vamos testar novamente");
System.out.println("b3:" + b3.toString() );
Usando os métodos b3.insert(0, "A x B ");
para manipular System.out.println("b3:" + b3.toString() );
b3.delete(0,4);
o objeto StringBuffer System.out.println("b3:" + b3.toString() );
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() );
}
}

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 33
Linguagem de Programação JAVA
JB100 Java Básico
Fundamentos da Linguagem Java

Casting (coerção de tipos)

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


Casting implícito
{
Por força do operador
public static void main(String args[])
matemático o Java promoveu a
{
valor resultante de a + b para
byte a = 1;
um valor inteiro, o que provoca
byte b = 3;
estouro da faixa de byte, e por
byte c = a + b;
sua vez provoca um erro
/* Linha errad, pois a operação adição
sofre casting implicita */
//Correção o casting explicito
byte c = (byte) (a + b); Casting explícito
System.out.println(c); após a soma de a + b, o valor
} da soma é convertido para byte
}

Hierarquia de conversão:

byte

short char

int

long

float
Conversão Conversão
Implícita double Explícita

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 34
Linguagem de Programação JAVA
JB100 Java Básico
Fundamentos da Linguagem Java

Casting (coerção de tipos)

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(); Conversão ilegal, pois, o
janela.setTitle("Titulo da Janela"); objeto janela não “enxerga”
... os métodos de Frame,
} embora o método exista,
} pois o objeto
é do tipo Frame

Hierarquia de classes:

SuperClasse Window

SubClasse Frame

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 35
Linguagem de Programação JAVA
JB100 Java Básico
Fundamentos da Linguagem Java

Casting (coerção de tipos)

Casting ( Conversão de tipos ) Objetos

import java.awt.*;
public class CastObjeto
{
public CastObjeto()
{ Conversão legal, pois, a
Window janela =new Frame(); janela é um objeto do
Frame janela1 = (Frame) janela; tipo Frame e está sendo
janela1.setTitle("Titulo da Janela"); 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

Conversão Conversão
SubClasse
implícita explícita

As Interfaces seguem a mesma regra das classes.

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 36
Linguagem de Programação JAVA
JB100 Java Básico
Fundamentos da Linguagem Java

Casting (coerção de tipos)

Casting Exemplo:
public class TestCasting
{
public static void main(String args[])
{

//Exemplo 1
byte a = 1;
byte b = 3;
/*Linha errada, pois a operação adição
O resultante da soma foi promovido sofre casting implicita */
para tipo int, quando atribuímos a //byte c = i + i;
variável , que é do tipo byte, a //Correção o casting explicito
operação provoca erro, pois, a faixa byte c = (byte) (a + b);
de byte é menor que a faixa de int.
Uma vez aplicado o casting a System.out.println(c);
operação de soma é realizado e
depois é convertida para o type byte. //Exemplo 2 Casting implícito: (a + b)
int ia = 1;
long lb = 3;
/*
Perda de Precisão - causa erro
*/
Casting explícito: //int ic = ia + lb; //linha errada -> Casting
(byte) (a + b) //Correção o casting explicito
int ic = ia + (int) lb;
System.out.println(ic);
}
}

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 37
Linguagem de Programação JAVA
JB100 Java Básico
Fundamentos da Linguagem Java

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”); bloco
i++
}

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>

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 38
Linguagem de Programação JAVA
JB100 Java Básico
Fundamentos da Linguagem Java

Fluxo de Controle
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
{ //Bloco de instruções }
Exemplo: if (x>y) {
System.out.println(x);
y++; Mais de uma instrução
} é usado a estrutura de
else { bloco
System.out.println(y);
x++;
}

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

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 39
Linguagem de Programação JAVA
JB100 Java Básico
Fundamentos da Linguagem Java

Fluxo de Controle

A instrução if
Sintaxes: (continuação)
Exemplo: if (x>y) {
System.out.println(x);
y++;
}
else if (x<y) {
System.out.println(y);
x++;
}
else {
System.out.println(y);
System.out.println(x);
}

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:

if (saldo > 0)
{
sim status = “Positivo”;
saldo > 0 status = Positivo }
else
{
não
status = “Negativo”;
}
status = Negativo
OU
if (saldo > 0)
status = “Positivo”;
else
Lógica status = “Negativo”;
Código

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 40
Linguagem de Programação JAVA
JB100 Java Básico
Fundamentos da Linguagem Java

Fluxo de Controle
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:

public class ifCompostoExemplo


{
public static void main(String args[])
saldo médio sim Limite cheque {
> 5000 =1000 int limitecheque;
int saldomedio = 15000;
if (saldomedio > 5000)
não {
limitecheque = 1000;
saldo médio > sim Limite cheque }
3000 and <=5000 else if (saldomedio > 3000 &&
=800 saldomedio <= 5000)
{
não limitecheque = 800;
}
sim else if (saldomedio > 2000 &&
saldo médio > Limite cheque saldomedio <= 3000)
2000 and <= 3000
=600 {
limitecheque = 600;
}
não
else if (saldomedio > 1000 &&
saldomedio <= 2000)
saldo médio > sim Limite cheque {
1000 and <= 2000 limitecheque = 400;
=400 }
else
não {
limitecheque = 0;
}
Limite cheque System.out.println("Limite cheque
=0 especial..." + limitecheque);
}
}

Lógica Código

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 41
Linguagem de Programação JAVA
JB100 Java Básico
Fundamentos da Linguagem Java

Fluxo de Controle
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: Exemplo:
switch (expressao char-integer) public class switchSimplesExemplo
{ {
case expressao1: public static void main(String args[])
// instruções {
case expressao2: char opcao = 'a';
// instruções String selecao = "";
case expressao3: switch (opcao)
// instruções {
default: case 'a':
// instruções selecao += „a‟;
} case 'b':
A instrução switch selecao += 'b';
case 'c':
selecao += 'c';
default:
selecao += "d";
}
Será impresso “abcd” System.out.println(selecao);
}
}

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

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 42
Linguagem de Programação JAVA
JB100 Java Básico
Fundamentos
Fundamentosda
daLinguagm
Linguagem
Java
Java

Fluxo de Controle
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) public class switchBreakExemplo
{ {
case expressao1: public static void main(String args[])
// instruções {
break; char opcao = 'b';
case expressao2: String selecao = "";
// instruções switch (opcao)
break {
case expressao3: case 'a':
// instruções selecao += 'a';
break break;
default: case 'b':
// instruções selecao += 'b';
} break;
case 'c':
A instrução switch com selecao += 'c';
a instrução break break;
default:
selecao += "d";
}
Será impresso “b” System.out.println(selecao);
}
}

Note que tanto a instrução default quanto a break são opcionais, depende da
lógica a utilizada.

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 43
Linguagem de Programação JAVA
JB100 Java Básico
Fundamentos da Linguagem Java

Fluxo de Controle

A instrução switch.

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:

public class switchCompostoExemplo


{
avaliacao = public static void main(String args[])
sim
case 10 “Excelente” {
String avaliacao ="";
int nota = 8;
não switch (nota)
{
sim avaliacao = case 10:
case 9
“Ótimo” avaliacao = "Excelente";
break;
não case 9:
avaliacao = "Ótimo";
sim avaliacao = break;
case 8
“Ótimo” case 8:
avaliacao = "Bom";
break;
não
case 7:
avaliacao = "Satisfatório";
sim avaliacao = break;
case 7
“Ótimo” default:
avaliacao = "Regular";
não }
System.out.println("Avaliação: "
avaliacao = + avaliacao);
“Regular” }
}

Lógica Código

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 44
Linguagem de Programação JAVA
JB100 Java Básico
Fundamentos da Linguagem Java

Fluxo de Controle
A instrução switch.

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


opções. Veja a diferença:

public class switchSemBreakExemplo


sim {
case S Ar condicionado public static void main(String args[])
{
char opcao = 'B';
não
String selecao = "";
sim switch (opcao)
case L Direção hidráulica {
case 'S': //Super luxo
selecao += " Ar condicionado +";
não
case 'L': //Luxo
sim selecao += " Direção hidráulica +";
case S Trio Elétrico case 'B': //Básico
selecao += " Trio Elétrico +";
default:
não selecao += " Alarme";
}
Alarme System.out.println(selecao);
}
}
Lógica Código

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 45
Linguagem de Programação JAVA
JB100 Java Básico
Fundamentos da Linguagem Java

Fluxo de Controle
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>

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.

sim
saldo > 0 status = Positivo {
...
não Status = (saldo > 0)?
”Positivo”:“Negativo”;
...
status = Negativo }

Código
Lógica

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


a recursividade.

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 46
Linguagem de Programação JAVA
JB100 Java Básico
Fundamentos da Linguagem Java

Fluxo de Controle
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:

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


10.
não
então
a = 10 a++ incrementar um na variável
senão
sim
imprimir a variável valor
Imprimir a
Isto quer dizer que a instrução de
incremento vai repetir dez vezes.

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

true a++

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

Laços:

while (<boolean-expression>)
<statements>...

do
<statements>...
while (<boolean-expression>);

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


<statements>...

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 47
Linguagem de Programação JAVA
JB100 Java Básico
Fundamentos da Linguagem Java

Fluxo de Controle
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: Exemplo:
while (expressao boolean) public class whileExemplo2
instrução java {
public static void main(String args[])
{
int d = 10;
Este código será executado 10 while (d >= 0)
vezes, ou seja até a condição System.out.println("Contagem Regressiva " + d--);
ser satisfeita }
}

Sintaxe: Exemplo:
while (expressao boolean) public class whileExemplo
{ {
//Bloco public static void main(String args[])
} {
int d = 1;
while (d<= 10)
{
A instrução while 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

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 48
Linguagem de Programação JAVA
JB100 Java Básico
Fundamentos da Linguagem Java

Fluxo de Controle

A instrução while.

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++);
}
....

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 49
Linguagem de Programação JAVA
JB100 Java Básico
Fundamentos da Linguagem Java

Fluxo de Controle
A instrução while.

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


usando a instrução while.

não
valor < 20 Valor++ {
...
while(valor <20) valor++
sim
System.out.println(valor);
Imprime valor ...
}
Sai do Laço

Lógica Código

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 50
Linguagem de Programação JAVA
JB100 Java Básico
Fundamentos da Linguagem Java

Fluxo de Controle
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: Exemplo:
do public class dowhileExemplo
instrução java {
while(expressão boolean) public static void main(String args[])
{
long d=10;
Este código será executado 10 do
vezes, ou seja até que a System.out.println(d++);
condição seja satisfeita while (d <=20);
}
}

Sintaxe: Exemplo:
do { public class dowhileExemplo2
//Bloco {
} public static void main(String args[])
while(expressão boolean) {
int d = 100;
do
A instrução do-while {
primeiro executa System.out.println("Faixa " + Math.random()*d);
as instruções que d++;
}
estão dentro de bloco
while (d <=110);
e depois verifica a }
expressão boolean }

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 51
Linguagem de Programação JAVA
JB100 Java Básico
Fundamentos da Linguagem Java

Fluxo de Controle
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++ do
não {
valor++;
System.out.println(valor);
Imprime valor }
Valor < 20 while(valor <20)
...
sim

Código
Lógica

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

não {
valor < 20 Valor++
...
while(valor <20)
sim valor++;
System.out.println(valor);
Imprime valor
...
}
Sai do Laço

Lógica Código

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 52
Linguagem de Programação JAVA
JB100 Java Básico
Fundamentos da Linguagem Java

Fluxo de Controle
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

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 53
Linguagem de Programação JAVA
JB100 Java Básico
Fundamentos da Linguagem Java

Fluxo de Controle
A instrução for

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

public class forExemplo


{
public static void main(String args[])
{
int d;
Sem bloco for(d=180; d <=190; d++) System.out.println("Faixa 180-190 : " + Math.random()*d);

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


{
Com bloco System.out.println("Faixa 200-210: " + Math.random()*d);
}
int i;
for(d=220,i=10; d <=230; d++, i++)
{
Trabalhando System.out.println("Faixa 220-230 " + Math.random()*d);
com valores System.out.println("Valor de i " + i);
}

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


com valores {
e condição System.out.println("Faixa 230-240 " + Math.random()*d);
System.out.println("Valor de i " + i);
composta }
for(i=40; i >= 30; i--)
{
Trabalhando System.out.println("Valor de i 40-30 " + i);
com ordem }
decresente }
}

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 54
Linguagem de Programação JAVA
JB100 Java Básico
Fundamentos da Linguagem Java

Fluxo de Controle
A instrução for

Veja abaixo mais exemplos, desta vez, com algumas variações possíveis da
instrução for:

public class forExemplo1


Sem declarar {
valor-inicial public static void main(String args[])
{
int d=170;
for(;d <=190; d++) System.out.println("Faixa 180-190 : " + Math.random()*d);
Sem condição. for(d=200; ;d++)
A condição está {
associado a System.out.println("Faixa 200-210: " + Math.random()*d);
if (d>210) break;
instrução if
}
for(d=210; d < 220;)
Sem valor de {
System.out.println("Faixa 210-220: " + Math.random()*d);
incremento ou d++;
decremento. }
int i=10;
for(d=220; d <=230; d++)
{
For aninhados System.out.println("Faixa 220-230 " + Math.random()*d);
for(; i <=20; i++)
System.out.println("Valor de i " + i);
}
for(i=40; i >= 30; i-=2)
{
Decrementado
System.out.println("Valor de i 40-30 " + i);
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).

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 55
Linguagem de Programação JAVA
JB100 Java Básico
Fundamentos da Linguagem Java

Fluxo de Controle
A instrução for

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


for:

i=10
..
for(i=10; i >= 0; i-=2)
{
sim System.out.println("Valor
i >=0 de i 10-0 " + i);
}
...
não
OU
Imprime i
..
for(i=10; i >= 0; i-=2)
System.out.println("Valor
de i 10-0 " + i);
i=i-2 ...

Lógica Código

Agora faça uma comparação entre a instrução do while, do-while e for. Quem
será mais rápido ?

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 56
Linguagem de Programação JAVA
JB100 Java Básico
Fundamentos da Linguagem Java

Fluxo de Controle
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>: Exemplo:
instrução java public class labelExemplo
ou {
<nome-da-label>: public static void main(String args[])
{ {
//Bloco de instruçõe int d=1;
}
label_one:
Veja a label e a instrução for(d=1; d <=10; d++)
for que parte da label_one System.out.println("Faixa de 0..10: " +d);
label_two:
{
for(; d <=20; d++)
System.out.println("Faixa de 10..20: " +d);
}
}
}

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 57
Linguagem de Programação JAVA
JB100 Java Básico
Fundamentos da Linguagem Java

Fluxo de Controle
Label (rótulo)

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

public class labelExemplo1


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

A instrução continue
Às vezes precisamos pular para aquela ou esta parte do programa sem passar pelo
resto das instruções.

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 58
Linguagem de Programação JAVA
JB100 Java Básico
Fundamentos da Linguagem Java

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

Exemplo 1 Exemplo 2
String nomes[ ]; String nomes[ ] = {"Duke", "Jane","Tarzan"};
nomes = new String[3]
names[0] = "Duke";
names[1] = "Jane";
names[2] = "Tarzan";
Exemplo 3 Exemplo 4
MinhasDatas dates[ ]; MinhasDatas dates[ ] = { new MinhasDatas[2], new
dates = new MinhasDatas[2]; MinhasDatas(22, 7, 2000) , new MinhasDatas(01, 4,
dates[0] = new MinhasDatas(22, 7, 2000); 1999); }
dates[1] = new MinhasDatas(01, 4, 1999);

Arrays Multi-Dimensionais:
Declaração correta:
double duplaDim [ ] [ ] = new double [4] [ ];
duplaDim [0] = new double [1];
duplaDim [1] = new double [2];
duplaDim [3] = new double [3];
Declaração Incorreta:
double duplaDim [ ] [ ] = new double [ ] [4 ];

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 59
Linguagem de Programação JAVA
JB100 Java Básico
Fundamentos da Linguagem Java

Arrays
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 [ ])
{
Declara e atribui os
int[] thisArray = {1,2,3,4,5,6,7,8,9,10};
valores para thisArray
for (int i =0; i < thisArray.length; i++)
{ Imprime no
System.out.println("Conteúdo" + thisArray[i]); console os itens
} do thisArray
}
}

public class TestArray2 {


public static void main (String args [ ])
{
String[] estadosul = new String[3];
Declara e atribui os estadosul[0]="RS";
valores para array estadosul[1]="SC";
estadosul[2]="PR";
for (int i =0; i < estadosul.length; i++)
Imprime no console os {
itens do array System.out.println("Conteúdo " + estadosul[i]);
}
}
}

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 60
Linguagem de Programação JAVA
JB100 Java Básico
Fundamentos da Linguagem Java

Passagem de Parâmetros
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.

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 61
Linguagem de Programação JAVA
JB100 Java Básico
Fundamentos da Linguagem Java

Passagem de Parâmetros
Parâmetros de inicialização:

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


de código:

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

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 62
Linguagem de Programação JAVA
JB100 Java Básico
Fundamentos da Linguagem Java

A classe Math

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

Principais métodos:
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));

Exemplo:

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)));
}
}

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 63
Linguagem de Programação JAVA
JB100 Java Básico
Fundamentos da Linguagem Java

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.

Tipo primitivo
boolean byte Char short int long float double

Boolean Byte Character Short Integer Long Float Double


Tipo referência

Exemplos:

public class TestWrapperClass {


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

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 64
Linguagem de Programação JAVA
JB100 Java Básico
Fundamentos da Linguagem Java

Conversão de Tipos

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

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 65
Linguagem de Programação JAVA
JB100 Java Básico
Fundamentos da Linguagem Java

Conversão de Tipos

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;

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 66
Linguagem de Programação JAVA
JB100 Java Básico
Programação Orientada a Objetos

A referência this
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);

public class PessoaJuridica extends Pessoa {


public PessoaJuridica()
{
super("ACME");
}
public static void main(String args[])
{
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; }
}

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.

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 67
Linguagem de Programação JAVA
JB100 Java Básico
Fundamentos da Linguagem Java

Coleções
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.

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:
API import java.util.*;
public class TestHashTable
{
public static void main(String Arg[])
{
Hashtable table = new Hashtable();
table.put("1", "Joao");
Implementação table.put("2", "Jose");
de tabela Hash table.put("3", "Maria");
e uso dos métodos table.put("4", "Marta");
put e get table.put("5", "Pedro");
table.put("6", "Mateus");
String find = (String) table.get("4");
System.out.println(find);
}
}

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 68
Linguagem de Programação JAVA
JB100 Java Básico
Fundamentos da Linguagem Java

Coleções

Enumeration (API: Java.util.Enumeration)

Retorna uma enumeração de uma coleção (Tabela Hash, por exemplo) especificada.
Principais métodos: hasMoreElements e nextElements.
Exemplo:

import java.util.Enumeration.*;
API
import java.util.*;
public class EnumerationExemplo
{
public static void main(String Arg[])
{
Hashtable table = new Hashtable();
table.put("1", "Joao");
table.put("2", "Jose");
Tabela Hash table.put("3", "Maria");
e métodos table.put("4", "Marta");
table.put("5", "Pedro");
table.put("6", "Mateus");

Usando a Interface Enumeration e = table.elements();


Enumeration, podemos while(e.hasMoreElements()){
imprimir todos os String valor = (String) e.nextElement();
valores contidos System.out.println(valor);
na tabela Hash }
}
}

import java.util.Iterator.*;
...
Opcionalmente podemos usar
Iterator i = table.values().iterator();
Iterator que tem a funcionalidade
while(i.hasNext()){
parecida com Enumeration
String valor = (String)i.next();
System.out.println(valor);

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 69
Linguagem de Programação JAVA
JB100 Java Básico
Fundamentos da Linguagem Java

Coleções

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

Exemplo:

API import java.util.*;

public class TestVector


{
public static void main(String Arg[])
{
Declaração do Vector Vector v = new Vector();
Integer y;
for(int x=0;x<5;x++)
Adiciona valores ao
{
Vector. Note que estes
y = new Integer(x);
valores são do tipo referência,
v.addElement(y);
ou seja, objetos
}
Object[] objArray = v.toArray();
Converte um Vector for(int x=0;x<5;x++)
para um array . {
System.out.println(objArray[x]);
}
}
}

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

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 70
Linguagem de Programação JAVA
JB100 Java Básico
Fundamentos da Linguagem Java

Coleções

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.

Exemplo:

API import java.util.*;


public class ListExemplo {
public static void main(String[] args) {
Declaração do ArrayList List list = new ArrayList();
list.add("um");
Inserção de valores na lista. list.add(new Integer(4));
Veja que estes valores são objetos list.add("terceiro");
list.add(new Integer(4));
System.out.println(list);
Imprime os valores da lista
Vector v = new Vector();
Integer y;
for(int x=0;x<5;x++)
Uma nova coleção {
y = new Integer(x);
v.addElement(y);
}
Uma outra construção para a
lista, neste caso ela recebe List listVector = new ArrayList( v );
uma coleção como argumento System.out.println(listVector);
}
Imprime todos os }
valores da lista

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 71
Linguagem de Programação JAVA
JB100 Java Básico
Fundamentos da Linguagem Java

Coleções

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.

Exemplo:

import java.util.*;
API
//Com ordem e sem repetição
public class SetExample {
public static void main(String[] args) {
Declaração do HashSet Set set = new HashSet();
set.add(”dois");
set.add("3rd");
Inserção de valores na lista. set.add(new Float(11.1F));
Veja que estes valores são objetos set.add(”quarto");
set.add(new Float(11.1F));
System.out.println(set);
Imprime os valores da lista }
}

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 72
Linguagem de Programação JAVA
JB100 Java Básico
Fundamentos da Linguagem Java

Coleções

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 73
Linguagem de Programação JAVA
JB100 Java Básico
Pacotes

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

Regras de Negócios Controle

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

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 74
Linguagem de Programação JAVA
JB100 Java Básico
Pacotes

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:
Substituindo os pontos por barras teríamos o caminho

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

Aqui estaríamos importando somente o objeto Button


import java.awt.*;

Neste caso estaríamos importando todos objetos contidos na classe

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; Gerar pacotes: javac -d . *.java


public class ClassPkg
{
public ClassPkg()
{
System.out.println("Teste de package...");
}

}
Diretório import MyPck.ClassPkg;
Corrente public class TestPkg
{
MyPck public static void main(String args[])
--- {
--- ClassPck.class
ClassPkg p = new ClassPkg();
--- }
--- TestPck.class
}

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 75
Linguagem de Programação JAVA
JB100 Java Básico

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 76
Linguagem de Programação JAVA
JB100 Java Básico
Programação Orientada a Objetos

Classe

O que é uma Classes?


“Uma classe descreve um conjunto de objetos com propriedades e comportamentos
semelhantes e com relacionamentos comuns com outros objetos”

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

Nome da Classe
Pessoa
nome
idade Atributos
getNome()
getIdade() 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

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 77
Linguagem de Programação JAVA
JB100 Java Básico
Programação Orientada a Objetos

Classe
Exemplo:
A classe Pessoa. Classe concreta.

public class Pessoa { Exemplo de diagrama de classe


usando Rational Rose (notação Unified)
//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.

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 78
Linguagem de Programação JAVA
JB100 Java Básico
Programação Orientada a Objetos

Classe
Exemplo:
A classe Pessoa. Classe Abstrata

public abstract class Pessoa


{
protected String nome;
Se uma classe é abstrata se métodos
public abstract String getnome(); também são
public abstract void setnome(String nome);

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

Diferenças ente Classe Abstrata e Concreta:

Classe Abstrata Classe Concreta

Os métodos podem ser assinados e


Os métodos devem ser somente assinados
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.

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

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 79
Linguagem de Programação JAVA
JB100 Java Básico
Programação Orientada a Objetos

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

Exemplos de Objetos:

Objeto: Pessoa Propriedades Comportamentos


Andar
Bonita
Correr
Jovem
Falar
Inteligente
Chorar
Dançar

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 80
Linguagem de Programação JAVA
JB100 Java Básico
Programação Orientada a Objetos

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

Exemplos de Objetos:

Classe: Cliente e objetos

Cliente
nome
cpf
idade

Cliente: clientemulher Cliente: clientehomem


nome = Marina nome = Felipe
cpf = 022.200.708-12 cpf = 039.217.908-22
idade = 16 idade = 22

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 81
Linguagem de Programação JAVA
JB100 Java Básico
Programação Orientada a Objetos

Métodos

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) { }

public class CalculaData {


private int day, month, year;
public float calcDays(int age )
{
método
return 365.25F * age;
}
}

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 82
Linguagem de Programação JAVA
JB100 Java Básico
Programação Orientada a Objetos

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 public class ContaCorrente {


private int conta=0;
conta private double saldo=0;
saldo
setDeposito public double getSaldo(){
getSaldo return saldo;
setSaque }

public void setDeposito(int valordeposito)


{
return saldo +=valordeposito;
}

public void setSaque(double valorsaque)


{
return saldo -=valorsaque;
}
}

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 83
Linguagem de Programação JAVA
JB100 Java Básico
Programação
Orientação a Objetos
Orientada a Objetos

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:

public class Mamifero {


private int qdepernas;
private int idade;

public Mamifero(int idade)


{
this.idade = idade;
}
Construtores -
public Mamifero(int idade, int Podemos ter mais de um
pernas) construtor na mesma
{ classe.
this.idade = idade;
this.qdepernas = pernas;
}

//Métodos
}

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 84
Linguagem de Programação JAVA
JB100 Java Básico
Programação Orientada a Objetos

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

public class Disciplina {


private int cargaHoraria;
Atributos
private String nome;

public Disciplina(String nome, int


Modificador cargaHoraria){
this.nome = nome;
this.cargaHoraria =
calcCargaHoraria(cargaHoraria);
}
public String getNome(){
return nome;
}
public int getCargaHoraria(){
return cargaHoraria;
}
public int calcCargaHoraria(int
qdeHoras) {
int horasPlanejamento = (int) Variáveis
( qdeHoras * 0.1); temporárias
return cargaHoraria =
horasPlanejamento + qdeHoras;
}
}

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 85
Linguagem de Programação JAVA
JB100 Java Básico
Programação Orientada a Objetos

Exemplo de Classe

1 Livro

Legenda:
1 – Objeto no mundo real
2 – Modelo de implementação da classe Livro
3 – Codificação da classe Livro

3
public class Livro extends Object {
public Livro() {
}
2 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;
}
}
}

Criar o objeto Livro

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 86
Linguagem de Programação JAVA
JB100 Java Básico
Programação Orientada a Objetos

Exercício sobre modelo de Classe

1 (Identifique o objeto no mundo real)

2 Descreva o conceito:

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


Nome da Classe
public class <nome da classe> {
Atributos 1 public <nome da classe> () {
Atributos 2 }
Atributos 3 private <tipo> atributo;
private <tipo> atributo;
Métodos 1 private <tipo> atributo;
Métodos 2
Métodos 3 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;
}
}

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 87
Linguagem de Programação JAVA
JB100 Java Básico
Programação Orientada a Objetos

Abstração de Dados

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


dados.

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 Mamífero

Caça Helicóptero Passageiros Vaca Urso Cavalo

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


domínio.

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 88
Linguagem de Programação JAVA
JB100 Java Básico
Programação Orientada a Objetos

Abstração de Dados

Classes Abstratas

Uma classe abstrata é uma classe que:


• Provê organização
• Não possui “instances”
• Possui uma ou mais operações (métodos) abstratas

Classe Abstrata
Pessoa
getNome()

Pessoa Pessoa
Física Jurídica
getNome() getNome()
Classe concreta

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


uma implementação. Classes Abstratas - Exemplo:

Classe Abstrata
Funcionário

Analista Programador

Classe concreta

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 89
Linguagem de Programação JAVA
JB100 Java Básico
Programação Orientada a Objetos

Abstração de Dados

Classes Abstratas

Classe Abstrata
Pessoa
getNome()
Classe concreta

Pessoa Pessoa
Física Jurídica
getNome() getNome()

public abstract class Pessoa {


protected String idPessoa;
protected int idade;
protected String nome;

public Pessoa(String nome)


{
this.nome = nome;
}

public abstract String getNome();

public void setidPessoa()


{ }

public abstract int getIdade();

public void setIdade(int idade)


{}
}

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 90
Linguagem de Programação JAVA
JB100 Java Básico
Programação Orientada a Objetos

Abstração de Dados

Classes Abstratas

Classe Abstrata
Pessoa
getNome()
Classe concreta

Pessoa Pessoa
Física Jurídica
getNome() getNome()

public class PessoaFisica extends Pessoa {


public PessoaFisica(String nome)
{
super(nome);
}
public static void main(String args[])
{
PessoaFisica pf = new PessoaFisica("Duke");
pf.setIdade(10);
System.out.println("idade: " + pf.getIdade());
System.out.println("nome: " + pf.getNome());
}
public String getNome()
{ return nome; }

public int getIdade()


{ return idade; }
public void setIdade(int idade)
{ this.idade = idade; }
}

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 91
Linguagem de Programação JAVA
JB100 Java Básico
Programação Orientada a Objetos
Relacionamento
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:

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


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

Exemplo: Hierarquia de Classes

SuperClasse
Pessoa

SubClasses
Terceiro Aluno Funcionário

Professor Pessoal Pessoal


Professor
Autônomo Operacional Administrativo

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.

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 92
Linguagem de Programação JAVA
JB100 Java Básico
Programação Orientada a Objetos

Herança
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:

Curso
Universitário
extends

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

extends

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.

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 93
Linguagem de Programação JAVA
JB100 Java Básico
Programação Orientada a Objetos

Herança

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

public abstract class Pessoa {


protected String idPessoa;
protected int idade;
protected String nome;
public Pessoa(String nome)
{
this.nome = nome;
}
public abstract String getNome();
public void setidPessoa()
{ }
public abstract int getIdade();
public void setIdade(int idade)
{}
}

public class Terceiro extends Pessoa{ public class Aluno extends Pessoa{ public class Funcionario extends Pessoa{
private int codigoTerceiro; public Aluno(String nome) private int codigofuncionario;
public Terceiro(String nome) { public Funcionario(String nome)
{ super(nome); {
super(nome); } super(nome);
} public int getIdade() }
public int getIdade() { public int getIdade()
{ return 0; {
return 0; } return 0;
} public String getNome() }
public String getNome() { public String getNome()
{ return ""; {
return ""; }; return "";
}; } };
} }

Pessoal
Professor
Administrativo
Professor Pessoal
Autônomo Operacional

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 94
Linguagem de Programação JAVA
JB100 Java Básico
Programação Orientada a Objetos

Herança

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


Professor e Pessoal Administrativo

Pessoa

Terceiro Aluno Funcionário

public class ProfessorAutonomo public class Professor


extends Terceiro{ extends Funcionario{
public ProfessorAutonomo( public Professor(
String nome) String nome)
{ {
super(nome); super(nome);
} }
} }

public class PessoalOperacional


public class PessoalAdministrativo
extends Terceiro{
extends Funcionario{
public PessoalOperacional(
public PessoalAdministrativo(
String nome)
String nome)
{
{
super(nome);
super(nome);
}
}
}
}

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 95
Linguagem de Programação JAVA
JB100 Java Básico
Programação Orientada a Objetos

Herança Múltipla
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:

Superclasse
<<interface>> Superclasse
Mamífero Pessoa

Pessoa Física Pessoa Jurídica

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.

<<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
{
Exemplo de Interface String getName ();
double getCost ();
}

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 96
Linguagem de Programação JAVA
JB100 Java Básico
Programação Orientada a Objetos

Herança Múltipla
Exemplo: Implementação da classe Pessoa, PessoaFisica e PessoaJuridica e a
interface Mamifero

public abstract class Pessoa {


protected String idPessoa;
protected int idade;
protected String nome;

public Pessoa(String nome)


{
this.nome = nome;
}
public abstract String getNome();
public interface Mamifero {
public abstract int getIdade();
final int qdeOlhos=2;
public void setIdade(int idade){ }
}
public int getQdePernas();
}

extends

implements extends public class PessoaJuridica1 extends Pessoa


{
public class PessoaFisica1 extends Pessoa public PessoaJuridica1(String nome)
implements Mamifero { {
public PessoaFisica (String nome) super(nome);
{ }
super(nome); public int getIdade()
} {
public int getQdePernas(){ return 0;
return 2; } }
public String getNome(){ public String getNome()
return “”; } {
public int getIdade(){ return "";
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

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 97
Linguagem de Programação JAVA
JB100 Java Básico
Programação Orientada a Objetos

Comparação: classes e interfaces

Tipo Classe Concreta Classe Abstrata Interface


Herança extends extends implements
(simples) (simples) (múltipla)
Permite a sim não não
implementação
de Métodos
Permite a sim sim sim
declaração de (somente final)
Dados

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 98
Linguagem de Programação JAVA
JB100 Java Básico
Programação Orientada a Objetos

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:

public class Empregado { Superclasse


private double salario;

public Empregado(){
salario=0.00;
}

public double getSalario(){


return this.salario;
}
}

public class Gerente extends Empregado { Subclasse


private double bonus = .15;
public Gerente(){
//referência ao Construtor
super();
}
public double getSalario(){
//referência ao método getSalario
return super.getSalario() +
(super.getSalario()*this.bonus);
}
}

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 99
Linguagem de Programação JAVA
JB100 Java Básico
Programação Orientada a Objetos

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

Associação
classe classe
Usuario Senha

public class Usuario { public class Senha {


public Senha m_Senha; public Usuario m_Usuario;

Usuario() { Senha() {
} }
} }

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 100
Linguagem de Programação JAVA
JB100 Java Básico
Programação Orientada a Objetos

Navegação

Navegação
Navegação é uma associação unidirecional

Pedido

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

O Código Java:

public class Pedido public ItemPedido


{ {
public ItemPedido item[];
public ItemPedido()
public Pedido() {
{ }
} }
}

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 101
Linguagem de Programação JAVA
JB100 Java Básico
Programação Orientada a Objetos

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() {
}
}

public class Pessoa {


public Empresa Empregador[];

Pessoa() {
}
}

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

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 102
Linguagem de Programação JAVA
JB100 Java Básico
Programação Orientada a Objetos

Agregação

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 Roda {


public Pneu pneu;

Roda() {
}

Roda(int aro, String modelo) {


pneu = new Pneu(aro,modelo)

Roda Todo }

roda

pneu

Pneu
Parte de

public class Pneu {


public Roda roda;
Pneu() {
}
}

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 103
Linguagem de Programação JAVA
JB100 Java Básico
Programação Orientada a Objetos

Composição

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.

Cliente Pedido
Todo

Dados do Pedido
N• 19069
ItemPedido Parte de
Cliente 1 – Cliente A
um todo
Data: 01/01/2002

Produto

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

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 104
Linguagem de Programação JAVA
JB100 Java Básico
Programação Orientada a Objetos

Multiplicidade

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

Cliente Pedido
Todo
1 0..*
1

Dados do Pedido 1..*


N• 19069
ItemPedido Parte de
Cliente 1 – Cliente A
um todo
Data: 01/01/2002
*
1
Produto

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

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 105
Linguagem de Programação JAVA
JB100 Java Básico
Programação Orientada a Objetos

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

public class Cliente { public class Pedido {


public Pedido m_Pedido[]; public ItemPedido m_ItemPedido[];
Pedido() {
Cliente() { }
} }
}

Cliente Pedido
public class ItemPedido {
1 0..*
1
public Pedido m_Pedido;
1..*
ItemPedido
public Produto
* m_Produto;
1
Produto

ItemPedido() {
}
}
public class Produto {
public ItemPedido m_ItemPedido[];
Produto() {
}
}

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 106
Linguagem de Programação JAVA
JB100 Java Básico
Programação Orientada a Objetos

Constraint

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


ou incluir novas regras aos elementos do modelo.

* faz 1
Pedido Cliente

1 {se Pedido.Cliente.AnaliseCredito é ruim,


então pedido.ePrePago deve ser verdadeiro}

* Constraint
Pedido AnaliseCredito

1
Produto

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 107
Linguagem de Programação JAVA
JB100 Java Básico
Programação Orientada a Objetos

Exemplo de modelo de classes

<<negócio>>
<<negócio>> Produto
Cliente
<<negócio>>
Vendedor QtdeEmEstoque
SituacaoFinanceira

PercentualDeComissao
1
1

1 é realizada para
corresponde

1..*
*
<<negócio>> <<negócio>>
Venda ItemDeVenda
é realizada por é composta de
DataDaVenda QtdeVendida
* 1 1..*

<<negócio>> <<negócio>>
VendaAPrazo Prestacao
compreende
DataDeVencimento
1 1..* ValorDaPrestacao

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 108
Linguagem de Programação JAVA
JB100 Java Básico
Programação Orientada a Objetos

Exercício

public class NotaFiscal


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

public static void main(String args[])


{

NotaFiscal nf = new NotaFiscal();

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


nf.nflinha[2] = new NotaFiscalLinha("2020","Teste item 1", 15, 50.43);
nf.nflinha[1] = new NotaFiscalLinha("3030","Teste item 3", 25, 30.23);

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.

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 109
Linguagem de Programação JAVA
JB100 Java Básico
Programação Orientada a Objetos

Encapsulamento
É 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 Classe Empregado e método


pública getSalario

Dados/Atributos/propriedades
privada O atributo salario

public class Empregado { O atributo salario somente poderá ter


private
private double
double salario;
salario; um valor atribuído ou alterado,
através de método público.
public Empregado(){
salario=0.00;
}

public double getSalario(){ Através do método getSalario, que


return this.salario; tem modificador public, podemos
} manipular ou recuperar o valor do
} atributo salario.

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”

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 110
Linguagem de Programação JAVA
JB100 Java Básico
Programação Orientada a Objetos
Encapsulamento
A interface (pública) de um objeto declara todas as operações permitidas (métodos)

public class Empregado {


private double salario;

public Empregado(){
salario=0.00;
}

public double getSalario(){


return this.salario;
}
}

public class Gerente1 extends Empregado {


private double bonus = .15;
public double getSalario(){
//referência ao método getSalario
return super.getSalario() +
(super.getSalario()*this.bonus);
}
}

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

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 111
Linguagem de Programação JAVA
JB100 Java Básico
Programação Orientada a Objetos

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

overloading

Polimorfismo

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.

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 112
Linguagem de Programação JAVA
JB100 Java Básico
Programação Orientada a Objetos

Polimorfismo

Overrinding - Exemplo:
Empregado
setSalario()
getSalario()

Engenheiro Gerente Secretária


getSalario() getSalario() getSalario()

Diretor
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.
public class EmpregadoExemplo {
private double salario;

public void setSalario(int diastrabalhados,


double valorhora ){
this.salario = diastrabalhados *
valorhora * 8; public class Engenheiro extends
} EmpregadoExemplo {
public double getSalario(){ public static void main(String args[])
return this.salario; {
} Engenheiro eng = new Engenheiro();
} eng.setSalario(22, 35.00);
System.out.println(eng.getSalario());
}
}

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 113
Linguagem de Programação JAVA
JB100 Java Básico
Programação Orientada a Objetos

Polimorfismo
O método setSalario (continuação)
public class GerenteExemplo extends EmpregadoExemplo {
private double bonus = .15;
public static void main(String args[])
{
GerenteExemplo g = new GerenteExemplo();
g.setSalario(22, 35.00);
System.out.println(g.getSalario());
}
public double getSalario(){
return super.getSalario() + (super.getSalario()*this.bonus);
}
}

public class Secretaria extends EmpregadoExemplo {


public static void main(String args[])
{
Secretaria sec = new Secretaria();
sec.setSalario(22, 35.00);
System.out.println(sec.getSalario());
}
}

public class Diretor extends GerenteExemplo {


private double lucros = 1000.00;

public static void main(String args[])


{
Diretor d = new Diretor();
d.setSalario(22, 35.00);
System.out.println(d.getSalario());
}
public double getSalario(){
return super.getSalario() + this.lucros;
}
}

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 114
Linguagem de Programação JAVA
JB100 Java Básico
Programação Orientada a Objetos

Polimorfismo
Overrinding
Uma subclasse pode mudar o comportamento herdado da Superclasse, ou seja, um método
herdado poderá ser alterado. Veja o exemplo abaixo:

Conta Bancária

getSaldo()

Conta Corrente Conta Poupança Investimentos

getSaldo() getSaldo() getSaldo()

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

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.

Exercício:
Faça a implementação das classes acima.

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 115
Linguagem de Programação JAVA
JB100 Java Básico
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;
}

public class TestB extends


TestA{ TestB.java:3: a has private access in TestA
private int b=a;
private int b=a; ^
}

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.

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.

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 116
Linguagem de Programação JAVA
JB100 Java Básico
Acessibilidade

Acessibilidade ou Visibilidade

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

Modificador Mesma Mesmo SubClasse Universo


Classe Package
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

Exemplos:

public class class protected class

public sublass public sublass public sublass

default protected
public

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 117
Linguagem de Programação JAVA
JB100 Java Básico

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 118
Linguagem de Programação JAVA
JB100 Java Básico
Programação Orientada a Objetos

Instanceof

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

public class TestInstanceof


{
public static void main(String args[])
{
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');
Verifica qual é
objeto que está
if (obarray[3] instanceof Character)
contido na terceira
{
posição do obarray
System.out.println("Character");
}

}
}

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 119
Linguagem de Programação JAVA
JB100 Java Básico
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
}

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 120
Linguagem de Programação JAVA
JB100 Java Básico
Exceções

Exception

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

Throwable

Exception Error

IOException RuntimeException AWTError JVMError

EOFException FileNotFoun ArithmeticException


Exception NullPointerException
IndexOfBoundException

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.

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 121
Linguagem de Programação JAVA
JB100 Java Básico
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


{
public static void main(String args[])
{
try
{
Cria uma trilha da
new TestThrows().divisao(10,0);
ocorrência da exceção
}
e.printStackTrace();
{
System.out.println("Deu erro " + e);
} Lança a exceção
} para o método main
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.

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 122
Linguagem de Programação JAVA
JB100 Java Básico
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)
Implementação {
do tratamento System.out.println("Exceção: " + e);
de exceção status = 1;
}
finally
{
System.exit(status);
}
}
}

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


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

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 123
Linguagem de Programação JAVA
JB100 Java Básico
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)
Implementação {
do tratamento System.out.println("Exceção: " + e);
de exceção status = 1;
}
finally
{
System.exit(status);
}
}
}

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:

Hello word
No, I mean it!
HELLO WORLD!
Exceção: java.lang.ArrayIndexOutOfBoundsException

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 124
Linguagem de Programação JAVA
JB100 Java Básico
Características Avançadas

Formatando Números e Datas


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; Os valore


import java.text.NumberFormat; serão
exibidos no
seguinte
public class DecimalFormat1 { formato:
public static void main(String args[]) {
//Cientifico Mascara
DecimalFormat df = new DecimalFormat("0.000E0000");
System.out.println( df.format(1234.56)); 1,235E000
//Percentual 3
NumberFormat nf = NumberFormat.getPercentInstance(); Instancia
System.out.println(nf.format(0.67));
67%
}
}
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

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 125
Linguagem de Programação JAVA
JB100 Java Básico
Características Avançadas

Formatando Números e Datas


Formatação de Números:

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

import java.text.DecimalFormat;
APIs
import java.text.NumberFormat;

public class DecimalFormatMask {


public static void main(String args[]) {

O valor sem formatação double valor = 1045.561;

DecimalFormat df = null;
df = new DecimalFormat("###,###.###");
System.out.println(df.format(valor));

df = new DecimalFormat("###,###.00");
System.out.println(df.format(valor));
Criando máscaras e a
df.applyPattern("#,###.00");
impressão do valor
System.out.println(df.format(valor));

df.applyPattern("$#,###.00");
System.out.println(df.format(valor));

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

}
}

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 126
Linguagem de Programação JAVA
JB100 Java Básico
Características Avançadas

Formatando Números e Datas


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.

Principais Métodos:
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”.
Principais Métodos:
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)

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 127
Linguagem de Programação JAVA
JB100 Java Básico
Características Avançadas

Formatando Números e Datas

Formatação de Datas:
Exemplo:

import java.text.SimpleDateFormat;
import java.util.GregorianCalendar;

public class DateFormatMask {


public static void main(String args[]) {
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");
System.out.println(df.format(c.getTime()));
df = new SimpleDateFormat("yyyy/MMMM/d");
System.out.println(df.format(c.getTime()));
//Dia da semana
df = new SimpleDateFormat("E d/MMMM/yyyy");
System.out.println(df.format(c.getTime()));
df = new SimpleDateFormat("EEEE d/MMMM/yyyy");
System.out.println(df.format(c.getTime()));
//Semana
df = new SimpleDateFormat("E d/MMMM/yyyy 'semana' w ");
System.out.println(df.format(c.getTime()));
df = new SimpleDateFormat("E d/MMMM/yyyy 'semana' W ");
System.out.println(df.format(c.getTime()));
//Hora
df = new SimpleDateFormat("E d/MMMM/yyyy 'hora ' H':'m':'s");
System.out.println(df.format(c.getTime()));
//Data completa
df = new SimpleDateFormat("'Sao Paulo,' EEEE d ' de ' MMMM ' de ' yyyy");
System.out.println(df.format(c.getTime()));
}
}

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 128
Linguagem de Programação JAVA
JB100 Java Básico
Características Avançadas

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.

Veja o exemplo:

public final class TestFinalPai


{
private final int VALOR;

public TestFinalPai(int V)
{
VALOR = V;
}

public class TestFinalFilho extends TestFinalPai


{
public TestFinalFilho() {
super(10);
Quando compilamos
a classe um erro é gerado }
public static void main(String args[])
{

}
}

TestFinalFilho.java:1: cannot inherit from final TestFinalPai


public class TestFinalFilho extends TestFinalPai

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 129
Linguagem de Programação JAVA
JB100 Java Básico
Características Avançadas

Constantes
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

public class TestFinal1


{
private final int VALOR;

public TestFinal1()
{
VALOR = 0;
}
public static void main(String args[])
{
TestFinal1 tf= new TestFinal1();
System.out.println(tf.VALOR);
}
}

public class TestFinal2


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

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 130
Linguagem de Programação JAVA
JB100 Java Básico
Características Avançadas

Threads

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.

fila
T1.start()
t1 t3 t5 t2
Execução

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 131
Linguagem de Programação JAVA
JB100 Java Básico
Características Avançadas

Threads
Principais Métodos:
Método Descrição
void start() Habilita uma Thread para execução
void interrupt() Interrompe a execução
static void sleep(long Suspende a execução de uma Thread pelo tempo
ms) 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,

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.

Exemplo:
...
public int total(int valor) {
synchronized (this) {
valorTotal += valor;
}
}

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 132
Linguagem de Programação JAVA
JB100 Java Básico
Características Avançadas

Threads

Principais Métodos:
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.

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 133
Linguagem de Programação JAVA
JB100 Java Básico
Características Avançadas

Threads

Este exemplo demonstra a implementação de uma Thread simples

public class TestThread {


public static void main(String args[]) {
“instance” da Xyz r = new Xyz();
Thread Thread t = new Thread(r);
t.start();
}
O método start() }
solicita a execução
da Thread class Xyz implements Runnable {
int i;
No método run() é
implementado o public void run() {
corpo do método i = 0;

while (true) {
System.out.println("Hello " + i++);
if ( i == 50 ) break;
Corpo do }
método run() }
}

A interface Runnable é responsável pelos


métodos run()

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 134
Linguagem de Programação JAVA
JB100 Java Básico
Características Avançadas

Threads
Este exemplo é parecido com anterior, entretanto, agora é demonstrado a execução de
duas Threads.

public class TestThread1 {


public static void main(String args[]) {
Xyz r = new Xyz();
“instances” da Thread Thread t1 = new Thread(r);
Thread t2 = new Thread(r);
t1.start();
t2.start();
O método start()
}
solicita a execução
}
das Threads
class Xyz implements Runnable {
int i;
No método run() é
implementado o public void run() {
corpo do método i = 0;
for(;;) {
Corpo do System.out.println(Thread.currentThread());
método run() System.out.println(i++);
é a parte do if (i == 50) break;
código que será }
repetido }
}

Retorna a referência A interface Runnable é responsável pelos


da Thread corrente métodos run()

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 135
Linguagem de Programação JAVA
JB100 Java Básico
Características Avançadas

Threads

Este exemplo demonstra como configurar a prioridade de execução de uma Thread.

public class TestThreadPrior {


public static void main(String args[]) {
Thread t0 = new Thread(new TestPrior());
Thread t1 = new Thread(new TestPrior());
Prioridades: Usamos t0.setPriority(Thread.MAX_PRIORITY);
o método setPriority para t0.start();
definir e getPriority para System.out.println("Prioridade t1 " + t0.getPriority());
saber qual é a prioridade System.out.println("----------------------------------");
da Thread t1.setPriority(Thread.MIN_PRIORITY);
t1.start();
System.out.println("Prioridade t1 " + t1.getPriority());
System.out.println("----------------------------------");
}
}

class TestPrior implements Runnable {


int i;

public void run() {


i = 0;
Para usar: try {
O método sleep(), for(;;) {
somos forçados Thread.sleep(5);
usar o controle System.out.println(Thread.currentThread());
de exceção: try-catch System.out.println(i++);
if ( i == 50 ) break;
}
}catch(Exception e) {
}
}
}

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 136
Linguagem de Programação JAVA
JB100 Java Básico
Características Avançadas

Threads

Este exemplo mostra a funcionalidade do método yield().

public class TestThreadYield {


public static void main(String args[]) {
ThreadYield t = new ThreadYield();
Thread t0 = new Thread(t);
Thread t1 = new Thread(t);
Thread t2 = new Thread(t);
t0.setPriority(Thread.MAX_PRIORITY);
System.out.println("Prioridade t0 " + t0.getPriority());
t0.start();
t1.setPriority(Thread.NORM_PRIORITY);
System.out.println("Prioridade t1 " + t1.getPriority());
t1.start();
t2.setPriority(Thread.MAX_PRIORITY);
System.out.println("Prioridade t2 " + t2.getPriority());
t2.start();
}
}
class ThreadYield implements Runnable {
int i;
public void run() {
i = 0;
Suspende a execução da Thread try {
corrente e dá a oportunidade de for(;;) {
execução a próxima Thread da fila Thread.yield();
de execução de mesma prioridade. System.out.println(Thread.currentThread());
System.out.println(i++);
if ( i == 50 ) break;
}
}catch(Exception e) {}
}
}

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 137
Linguagem de Programação JAVA
JB100 Java Básico
Características Avançadas

Threads
Este exemplo é divido em duas partes. A primeira parte não implementa o recurso de
sincronismo.

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
{
public static void main(String args[])
{ ThreadContaCorrente cc = new ThreadContaCorrente();
Thread debito = new Thread(cc);
Thread credito = new Thread(cc);
debito.setName("deb");
debito.start();
credito.setName("cre");
credito.start();
}}

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 138
Linguagem de Programação JAVA
JB100 Java Básico
Características Avançadas
Threads

Esta a segunda parte. Neste caso implementamos o recurso de sincronismo.

public class TestSynchronizedON


{
public static void main(String args[])
{
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
Implementação
{ Thread.sleep(5); }
do sincronismo 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);


}
}}

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 139
Linguagem de Programação JAVA
JB100 Java Básico
Características Avançadas

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;
}

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 140
Linguagem de Programação JAVA
JB100 Java Básico
Características Avançadas

Serialization

Este exemplo é divido em duas partes. A primeira exibe como gravar um objeto em
arquivo. Gravar objeto vetor no arquivo Vector.ser

import java.io.*;
import java.util.*;
public class TestSerializeVector {
TestSerializeVector()
{
Vector v = new Vector();
for(int x=0;x<5;x++)
Os dados do v.addElement(new Integer(x));
objeto
try {
FileOutputStream f = new FileOutputStream ("vector.ser");
ObjectOutputStream s = new ObjectOutputStream (f);
Gravação s.writeObject (v);
s.close ();
} catch (IOException e) {
e.printStackTrace ();
}
}
public static void main (String args[]) {
new TestSerializeVector();
}
}

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 141
Linguagem de Programação JAVA
JB100 Java Básico
Características Avançadas

Serialization

A segunda parte demonstra como recuperar o objeto e os dados gravados em um


arquivo. Nome do arquivo Vector.ser (objeto vector)

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);
Recuperação System.out.println(s);
Note que é v = (Vector) s.readObject ();
necessário fazer s.close ();
a coerção de tipo } catch (Exception e) {
(Vector) e.printStackTrace ();
}

System.out.println(
"Unserialized Vector object from vector.ser");
Object[] objArray = v.toArray();
for(int x=0;x<5;x++)
{
System.out.println(objArray[x]);
}
}
public static void main (String args[]) {
new TestUnSerializeVector();
}
}

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 142
Linguagem de Programação JAVA
JB100 Java Básico
Características Avançadas

Serialization
Este exemplo mostra como import java.io.*;
criar um método para fazer import java.util.Date;
a gravação e outro para import java.util.*;
fazer a recuperação. public class TestSerialize {
public void doSerialize()
{
try
{ FileOutputStream ostream = new FileOutputStream("dados.ser");
ObjectOutputStream p = new ObjectOutputStream(ostream);
p.writeInt(12345);
p.writeObject("Today");
Gravação p.writeObject(new Date());
p.flush();
ostream.close();
} catch (Exception e) {
e.printStackTrace ();
}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);
Recuperação istream.close();
System.out.println("String: " + today);
System.out.println("Date: " + date);
System.out.println("int: " + i);
} catch (Exception e) {
e.printStackTrace (); Para cada tipo
} de dados foi
} usado o método
TestSerialize() apropriado.
{ doSerialize();
Objeto = readObject
unDoSerialize();
} Int = readIn
public static void main(String args[])
{
new TestSerialize();
}
}

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 143
Linguagem de Programação JAVA
JB100 Java Básico
Características Avançadas

TCP/IP
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)

Servidor Cliente
ServerSocket(port #) ServerSocket(host,
ServerSocket.accept() port #)
(tentativa de
Sockect() conexão)

(Fluxo de Mensagens) (Fluxo de Mensagens)


InputStream InputStream
OutputStream OutputStream

Socket.close() Socket.close()

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 144
Linguagem de Programação JAVA
JB100 Java Básico
Características Avançadas

TCP/IP
Principais métodos:
Métodos Descrição
ServerSocket(port #, Estabelece a porta em que um servidor espera a
number clientes) 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

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 145
Linguagem de Programação JAVA
JB100 Java Básico
Características Avançadas

TCP/IP
Exemplos:
Este exemplo é divido em duas partes. A primeira exibe como criar um Servidor.

API import java.net.*;


import java.io.*;

public class TestServer {


public static void main(String args[]) {
ServerSocket s= null;
Objecto
ServerSocket Número da Porta
try {
s = new ServerSocket(5432);
} catch (IOException e) {
e.printStackTrace();
}

for (;;) {
Espera o try {
estabelecimento Socket s1 = s.accept();
de conexão
OutputStream s1out = s1.getOutputStream();
Fluxo de Dados DataOutputStream dos = new DataOutputStream(s1out);

// Envia a mensagem
dos.writeUTF("Hello Net World!");

Encerra a o fluxo dos.close();


de dados e a s1.close();
conexão } catch (IOException e) {
e.printStackTrace();
}
}
}
}

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 146
Linguagem de Programação JAVA
JB100 Java Básico
Características Avançadas

TCP/IP
Exemplos:
Este é segunda parte. A criação de um cliente.

API import java.net.*;


import java.io.*;

public class TestClient {


public static void main(String args[]) {
try {
Objeto Socket, veja
os parâmtros no Construtor // Endereço IP é Localhost
“”Endereço IP” Socket s1 = new Socket("127.0.0.1", 5432);
e “Número da Porta” do
Servidor InputStream is = s1.getInputStream();
DataInputStream dis = new DataInputStream(is);

Fluxo de Dados System.out.println(dis.readUTF());

dis.close();
s1.close();
Leitura do Fluxo } catch (ConnectException connExc) {
System.err.println("Could not connect to the server.");
} catch (IOException e) {
e.printStackTrace();
}
}
}

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 147
Linguagem de Programação JAVA
JB100 Java Básico
Características Avançadas

TCP/IP
Cenário da Conexão Servidor e Cliente

TCP/IP

IP
129.1.13.1
Fluxo de Dados
Porta
5432 Hello...

TestServer TestClient
Mensagem

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 148
Linguagem de Programação JAVA
JB100 Java Básico

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 149
Linguagem de Programação JAVA
JB100 Java Básico
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 Atividades


• Diagrama de Seqüência • Diagrama de Componentes
Principais • Diagrama de Colaboração • Diagrama de Distribuição
Diagramas: • Diagrama de Estados • Diagrama de Pacotes
• Diagrama de Classes
• Diagrama de objetos

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 150
Linguagem de Programação JAVA
JB100 Java Básico
Introdução a UML

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.

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 151
Linguagem de Programação JAVA
JB100 Java Básico
Introdução a UML

Casos de Uso
Diagramas de Caso de Uso e Extensões

Pedir lista dos


matriculados

Sistema de
cobrança Professor
Matrícula nos Selecionar curso
Cursos para ensinar

Aluno
Manter informação de Manter informações dos
aluno cursos

Gerenciar
Gerar catalogo
Manter informação de
professor

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

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 152
Linguagem de Programação JAVA
JB100 Java Básico
Introdução a UML

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 formulário cursos


de registro de matrícula disponíveis
Ator (José) entrar com chave de
acesso
validar acesso

entrar com o
semestre

criar nova matrícula


apresentar em tela

obter cursos

Diagrama de Seqüência

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 153
Linguagem de Programação JAVA
JB100 Java Básico
Introdução a UML

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.

2: validar acesso
1:entrar com chave 3:entrar com o
de acesso semestre

formulários de registro
4:criar nova matrícula
Ator (José)
5:apresentar
em tela

cursos disponíveis formulário de matrícula


6:obter cursos
Diagrama de Colaboração

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 154
Linguagem de Programação JAVA
JB100 Java Básico
Introdução a UML

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.

Adicionar Aluno

Matrícula aberta/inicialize
Criação Atribuição Curso númeroDeAlunos = 0 Curso Aberto
faça: Crie o faça: Atribuir um Entrada: Registre
objeto curso professor ao curso um aluno
cancelarCurso
cancelarCurso
cancelarCurso

Registro fechado
[númeroDeAlunos>=3
Curso Cancelado Registro fechado ]
faça: envie notificação [númeroDeAlunos<3]
de cancelamento
Registro fechado [número
de alunos =10]^Curso
.Criar relatório
Curso Encerrado
faça: relate curso
cancelarCurso esta cheio Curso Completado
faça: Gerar lista de
alunos

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 155
Linguagem de Programação JAVA
JB100 Java Básico
Introdução a UML

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.
Cliente Vendas Estoque

Fazer Pedido

Processar Pedido

Separar Produtos

Enviar Pedido

Receber Pedido Cobrar Cliente

Pagar Fatura

Fechar Pedido

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 156
Linguagem de Programação JAVA
JB100 Java Básico
Introdução a UML

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
Interfaces com Regras de Banco de Dados
Usuário Negócios {abstrata}

Interface Interface
Oracle MySQL

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 157
Linguagem de Programação JAVA
JB100 Java Básico
Introdução a UML

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.

Pessoa

Funcionários
Professores Alunos
Administrativo
1
1
1 1
Matricula Curso

1
tem
1..*
Disciplinas

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.

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 158
Linguagem de Programação JAVA
JB100 Java Básico
Introdução a UML

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.

:Aluno
Nome: “Fulano de Tal”
Data: 23-02-2001

201-23-02-01:Matricula
Matricula: 201-23-02-01
Curso: Adm Empresas

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 159
Linguagem de Programação JAVA
JB100 Java Básico
Introdução a UML

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

Disciplina.classr Aluno.class Professores.class

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 160
Linguagem de Programação JAVA
JB100 Java Básico
Introdução a UML

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.

<<TCP/IP>> Servidor
<<TCP/IP>>
Servidor de Banco de
Cliente A 0..* 1 de Aplicação 1 1
Dados

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 161
Linguagem de Programação JAVA
JB100 Java Básico

Transformando modelos UML


em código Java

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 162
Linguagem de Programação JAVA
JB100 Java Básico
Transformando diagramas UML em código Java

Implementação Java
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:

1 public class 4
2
Tapplet
extends
Applet { Compilação
}

Código fonte Bytcode


(java) (java) <HTML>
<body>
..
</body>
</HTML>
3
Arquivo
HTML
1
O programa Java
import java.awt.Graphics;

public class Hello extends java.applet.Applet Primeiro Passo:


{ Criação do programa Java,
public void paint(Graphics g) um Applet.
{ Segundo Passo:
g.drawString("Hello", 15,15); Compilar o programa
}
}

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 163
Linguagem de Programação JAVA
JB100 Java Básico
Transformando diagramas UML em código Java

Implementação Java

3
A página HTML, Hello.html
<HTML>
<CAPTION>Hello</CAPTION>
<TR><TD> Terceiro Passo:
<APPLET CODE="Hello.class" WIDTH=100 HEIGHT=100> Criação a página HTML,
</APPLET> o nome será Hello.html.
</TD></TR>
</HTML>

A execução

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.

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 164
Linguagem de Programação JAVA
JB100 Java Básico
Transformando diagramas UML em código Java

Modelagem UML
A Modelagem UML. Do programa Hello:

Hello

g.drawString
paint()
(“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

Applet

Hello

paint() Graphics

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.

Applet

public class Hello extends java.applet.Applet

Hello

public void paint(Graphics g) paint() Graphics


{
g.drawString("Hello", 15,15); import java.awt.Graphics;
}

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 165
Linguagem de Programação JAVA
JB100 Java Básico
Transformando diagramas UML em código Java

Modelagem UML - Pacotes


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:

Principais
pacotes java org javax sun
da Linguagem
Java

As classes Applet
lang applet awt (pacote applet) e
Graphics (pacote) awt
que colaboram com
a classe Hello

beans io rmi

Principais
subpacotes
do pacote
Java net math security

sql text util

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 166
Linguagem de Programação JAVA
JB100 Java Básico
Transformando diagramas UML em código Java

Modelagem
ModelagemUML
UML- Pacotes

java
Hello applet

awt

lang

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:

lang

awt applet

import java.awt.Graphics;

public class Hello extends java.applet.Applet


{
public void paint(Graphics g)
{
g.drawString("Hello", 15,15);
}
}

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 167
Linguagem de Programação JAVA
JB100 Java Básico
Transformando diagramas UML em código Java

Modelagem UML - Pacotes


Esta figura demonstra uma visão mais detalhada dos pacotes e as respectivas classes e
atributos.

java
Hello applet

awt

lang

Component Object
(from awt) (from lang)

Container Graphics
(from awt) ....
abstract void drawString(AttributedCharacterIterator iterator, int x, int y)
abstract void drawString(String str, int x, int y)
AudioClip
....

Panel
(from awt)
Interface AppletStub

Applet
AppletConte
xt

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 168
Linguagem de Programação JAVA
JB100 Java Básico
Transformando diagramas UML em código Java

Modelagem UML - Diagrama de Seqüência

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.

:Thread :Toolkit :ComponenPeer :target Hello


run

run callbackLoop

handleExpose
paint

Diagrama de Seqüência

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 169
Linguagem de Programação JAVA
JB100 Java Básico
Transformando diagramas UML em código Java

Modelagem UML e Codificação em Java


Herança Múltipla Vejamos a codificação Java:
public class Cliente
{
String nome; Atributo
public String getNome()
{
return this.nome;
}
Métodos public void setNome(String nome)
{
this.nome = nome;
}
}

public class ClientePessoaJuridica extends Cliente public interface Pessoa


{ {
public ClientePessoaJuridica() public boolean getDependente(int dependente);
{ }
System.out.println("Nome: " + getNome());
} Assinatura do método
}

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)
{ Implementação do
return (dependente>0)?true:false; método assinado
} na Interface Pessoa
}

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 170
Linguagem de Programação JAVA
JB100 Java Básico

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 171
Linguagem de Programação JAVA
JB100 Java Básico
Utilitários

JavaDoc (Documentação)

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>

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 Construtor Método Atributo


Interface
@see Cria um link com outra X X X X
página HTML
@deprecated Informa quais métodos X X X X
estão ultrapassados
@author Nome do Autor X
@param Documenta o parametro X X
@throws Documenta Exceções X X
@Exception
@return Documenta o returno (valor X
e tipo)

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 172
Linguagem de Programação JAVA
JB100 Java Básico
Utilitários

JavaDoc (Documentação)
Javadoc
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

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 173
Linguagem de Programação JAVA
JB100 Java Básico
Utilitários

JavaDoc (Documentação)
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;
}
}

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 174
Linguagem de Programação JAVA
JB100 Java Básico
Utilitários

JavaDoc (Documentação)

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.

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 175
Linguagem de Programação JAVA
JB100 Java Básico
Utilitários

Jar (Compactação, Agrupamento e Distribuição)


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.

Sintaxe: jar opções [meta-arq] nome-arquivo-destino [nome-arquivo-entrada]

Argumento Descrição
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.

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.

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 176
Linguagem de Programação JAVA
JB100 Java Básico
Utilitários
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:

public class Hello Esta classe Java requer um parâmetro


{ que deve ser passando na chamada
public static void main (String arg []) da classe, se o parâmetro não for
{ String s = "world"; informado, isto provocará
System.out.println("Hello " + arg[0]); uma exceção
}
}

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.

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 177
Linguagem de Programação JAVA
JB100 Java Básico
Utilitários

Javap (Desmontagem)
Javap
Faz a desmontagem de código ou descompilação. Sintaxe:
javap <opções> <classes>
Lista das principais opções:
Argumento Descrição
-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.
Código fonte

Código fonte, veja exemplo abaixo:


public class Hello
{
public static void main (String arg [])
{
System.out.println("Hello”);
}
}

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[]);
}

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 178
Linguagem de Programação JAVA
JB100 Java Básico

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 179
Linguagem de Programação JAVA
JB100 Java Básico
Apêndices
A - Convenção de Código no Java
B - Sistema de Codificação Unicode
C - Registrando Fonte de Dados
D - Notação UML

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 180
Linguagem de Programação JAVA
JB100 Java Básico
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

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 181
Linguagem de Programação JAVA
JB100 Java Básico
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

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 182
Linguagem de Programação JAVA
JB100 Java Básico
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.

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 183
Linguagem de Programação JAVA
JB100 Java Básico
Apêndice C

Registrando Fonte de Dados

Agora selecione o drive

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

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 184
Linguagem de Programação JAVA
Apêndice D JB100 Java Básico
Notação UML

DIAGRAMAS EM QUE MODELO A QUE


SÍMBOLO GRÁFICO NOME
APARECE USUALMENTE PERTENCEM

ASSOCIAÇÂO DE Diagrama de Classes, Classes de Objetos


AGREGAÇÃO Diagrama de Componentes. Componentes

Diagrama de Classes, Classes de Objetos


ASSOCIAÇÂO DE
COMPOSIÇÃO Diagrama de Componentes. Componentes

Diagrama de Casos de Uso, Caso de Uso


ASSOCIAÇÂO DE Diagrama de Classes, Classes de Objetos
DEPENDÊNCIA Diagrama de Componentes, Componentes
Diagrama de Implantação. Componentes

Diagrama de Casos de Uso, Caso de Uso


ASSOCIAÇÂO DE
GENERALIZAÇÃO
Diagrama de Classes. Classes de Objetos

Diagrama de Casos de Uso, Caso de Uso


ASSOCIAÇÂO Diagrama de Classes, Classes de Objetos
REGULAR Diagrama de Componentes, Componentes
Diagrama de Implantação. Componentes
Diagrama de Casos de Uso, Caso de Uso
ATOR Diagrama de Seqüência. Caso de Uso

CASO DE USO Diagrama de Casos de Uso. Caso de Uso

Nome da Classe

Atributos

CLASSE Diagrama de Classes. Classes de Objetos


Operações

Nome do Componente COMPONENTE Diagrama de Componentes Componentes

Diagrama de Estados, Classes de Objetos


Nome do Estado
ESTADO
Diagrama de Atividades. Caso de Uso

Diagrama de Estados, Classes de Objetos


ESTADO FINAL
Diagrama de Atividades Caso de Uso

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 185
Linguagem de Programação JAVA
Apêndice D JB100 Java Básico

Notação UML

Diagrama de Estados, Classes de Objetos


ESTADO INICIAL Diagrama de Atividades. Caso de Uso

Nome da “Interface” ou <<interface>>


Nome da “Interface”

Operação1 ()
Operação2 ()
Operação3 () “INTERFACE” Diagrama de Componentes Componentes

INTERVALO DE
EXECUÇÃO DE Diagrama de Seqüência Caso de Uso
OPERAÇÂO

MENSAGEM DE
Diagrama de Seqüência Caso de Uso
RETORNO
MENSAGEM E
CHAMADA DE
Diagrama de Seqüência Caso de Uso
OPERAÇÂO
“Síncrona”
MENSAGEM E
CHAMADA DE
Diagrama de Seqüência Caso de Uso
OPERAÇÃO
“Assíncrona”

NÓ Diagrama de Implantação Componentes

texto NOTA Em qualquer diagrama

Diagrama de Seqüência, Caso de Uso


identificador:Classe ou :Classe
OBJETO
Diagrama de Atividades Caso de Uso
Em qualquer diagrama em que é
necessário representar um
Nome do Pacote PACOTE conjunto de coisas que devem
estar agrupadas para efeito de
uma organização apropriada
Diagrama de Estados, Classes de Objetos
TRANSIÇÃO DE
ESTADO
Diagrama de Atividades Caso de Uso

AUTODELEGAÇÃO Diagrama de Seqüência Caso de Uso

Rildo F Santos (rildosan@uol.com.br)


© Copyright e-tecnologia.com, 2002 Versão: 3.0 186
Linguagem de Programação JAVA
JB100 Java Básico

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.

Imagens:
Google, Flickr e Banco de Imagem.

Rildo F dos Santos (rildosan@uol.com.br)


Rildo F Santos (rildosan@uol.com.br) 187
© Copyright e-tecnologia.com, 2002 Versão: 3.0
Linguagem de Programação JAVA
JB100 Java Básico

Licença:

Rildo F Santos (rildosan@uol.com.br) 188


© Copyright e-tecnologia.com, 2002 Versão: 3.0