Upload
vuongquynh
View
227
Download
4
Embed Size (px)
Citation preview
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
Revisão 3.0 27/01/09
Autor: Rildo F Santos ([email protected])
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
2
Estrutura do Curso
Introdução
Programação
Orientada
a Objetos
Características
Avançadas
Introdução
a UML
Utilitários
Apresenta arquitetura da linguagem Java
Apresenta comandos e funcionalidades
básicas
Fundamentos
da linguagem
Principais aspectos da programação
orientada a objetos
Apresentar características avançada da
Linguagem (Threads, networking e etc)
Apresentar uma visa geral da UML e seus
os principais componentes
Demonstrar os principais utilitários da
linguagem Java (Jar, JadaDoc e etc)
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
3
Conteúdo
Introdução
breve apresentação
gerando aplicações
Instalação do JDK
O primeiro programa
Fundamentos da linguagem Java
Estrutura da linguagem
Palavras Reservadas
Tipos de Dados
Inicialização de variáveis
Operadores
A classe String
A classe StringBuffer
Casting
Fluxo de Controle
Arrays
Passagem de Parâmetros
A classe Math
Empacotamento de Classes
Conversão de Tipos
A referência this
Coleções
Pacotes
Programação Orientada a Objetos
Classes
Objetos
Métodos
Construtores
Atributos e variáveis
Exemplo de classe
Exercício
Abstração de Dados
Relacionamento
Herança
Herança Múltipla
Comparação: Classes vs Interfaces
A referência Super
Associação
Navegação
Rolename
Agregação
Composição
Multiplicidade
Constraint
Encapsulamento
Polimorfismo
Acessibilidade
Características Avançadas
Instanceof
Exception
Formatando Números e Datas
Constantes
Threads
Serialization
TCP/IP
Introdução a UML
Utilitários
JavaDoc
Jar
JDB
Javap
Apêndice
Convenção de Código no Java
Unicode
Notação UML
Versão do JSDK 1.3
Este material foi preparado para trabalhar com a versão JSDK 1.3 (veja: http://java.sun.com/j2se/1.3/index.jsp),
entretanto todos os exemplos funcionam perfeitamente na versão 6 (versão atual)
Nota
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
4
Apresentar as características básicas da linguagem Java, assim
como, sua estrutura, funcionalidades, métodos, classes, APIs
(Application Program Interface) e recursos avançados.
Você está preparado ?
Para aprendermos uma nova linguagem de programação é necessário ter alguns
conhecimentos como:
- Lógica de Programação;
- Conhecer um Sistema Operacional, por exemplo, Windows, Unix, Linux ou MacOS;
- Saber editar e compilar programas e;
Conhecer uma outra Linguagem de Programação é importante, porém não
imprescindível.
Expectativas após o Curso:
Objetivo deste curso:
Ao final deste curso você deverá estar apto a:
• Utilizar a linguagem Java para criar aplicações simples;
• Descrever e usar as características de linguagem orientada a
objetos com Java, tais como: Herança, Abstração de Dados,
Encapsulamento e Polimorfismo;
• Conhecer o tratamento de exceções;
• Descrever e usar “sockets” para fazer acesso a servidores e
clientes;
• Conhecer UML básica;
Objetivo
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
5
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
6
Java
Uma breve apresentação...
Surgimento:
Java é uma linguagem de programação criada em 1995 por James Gosling e sua
equipe. A linguagem é de propriedade da Sun Microsystem.
Logo Java ganhou popularidade, um bom exemplo disto são os “Applets”, aqueles
pequenos aplicativos que executam nos navegadores, que durante muito tempo foi o
foco da linguagem Java.
Com o passar do tempo, o número de desenvolvedores aumentou e a linguagem
amadureceu sendo hoje considerada o principal ambiente de desenvolvimento, tanto
para Internet quanto para ambiente cliente/servidor tradicional.
Algumas das características da linguagem Java:
• Orientação a objetos
• Portabilidade (isto que dizer que o mesmo programa criado no
Windows2000, pode ser executado em Linux, por exemplo, ou qualquer outro
Sistema Operacional, sem a necessidade de fazer ajustes).
Entretanto, a linguagem Java vai além da computadores, sendo executada em
diversos dispositivos como telefone celulares, televisores, cartões inteligentes e etc.
O Java é reconhecido como a principal linguagem no mundo dos Servidores de
Aplicações e ambiente sem fio (wireless).
Introdução a linguagem Java
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
7
•Orientação a objetos: A linguagem é orientada a objetos a partir
de sua arquitetura, permitindo herança, polimorfismo,
encapsulamento, abstração de dados, persistência de objetos e
reúso de código.;
Independência de plataforma (Portabilidade): Possibilidade do
mesmo código fonte ser executado em diversos sistemas
operacionais, tais como Solaris, AIX, Linux, MacOS, Win32,
PalmOS, OS/390 e etc);
Dinamismo: A natureza dinâmica do Java, sendo uma extensão
natural de seu projeto orientado a objetos, permite a extensibilidade
durante a execução.
Alto desempenho: Suporte a vários recursos, como
multithreading, compilação em Jus-in-time, atomicidade do código e
suporte a protocolos de rede (TCP/IP)
Facilidade de manutenção de programas.
A linguagem não tem:
Ponteiros do sistema operacional;
Defines;
Sobrecarga de operadores;
Herança múltipla de classes e
Função e/ou procedure.
Principias características:
Cargabe Collection (gerenciamento dinâmico da memória);
Java Virtual Machine (JVM);
Código seguro.
O que é o Java?
Java é:
Uma linguagem de programação;
Um ambiente de desenvolvimento;
Um ambiente de aplicação;
Java é o resultado de uma busca por uma plataforma de
programação que pudesse fornecer segurança, portabilidade
(independência de sistema operacional) e escalabilidade.
Os primeiros objetivos alcançados com o desenvolvimento desta
nova linguagem foram:
Introdução a linguagem Java
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
8
Diferenças entre o Java e o C++
Java é sintática e morfologicamente muito parecido com a linguagem C++,
entretanto, existem diferenças:
Inexistência de aritméticas de ponteiros (ponteiros são apenas referências);
Arrays são objetos;
Strings são objetos;
Gerenciamento automático de alocação e deslocação de memória (Garbage
Collection);
Não há sobrecarga de operadores;
Não há métodos com lista de argumentos de tamanho variável;
Não existem diretivas de pré-compilação (#define, #ifde);
Não existem Templates;
Não existe Herança Múltiplas com classes, apenas com interfaces;
Não existem funções, mas apenas métodos de classes;
Necessita de ambiente de execução (runtime), ou seja, a JVM (Java Virtual
Machine).
Introdução a linguagem Java
public class Hello
{
public static void main (String arg [])
{
System.out.println("Hello” + “\n”);
}
}
#include <iostream.h>
int main ()
{
cout << “Hello \n" ;
return 0;
}
Java
C++
Veja abaixo um exemplo de um simples programa escrito em Java e em C++.
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
9
Portabilidade: “A independência de plataforma”
O Java é independente de plataforma. Isto significa que o desenvolvedor não terá que
se preocupar com particularidades do sistema operacional ou do hardware, focando o
seu esforço no código em si. Mas o que isto realmente significa?
Na maioria das linguagens é preciso gerar uma versão para cada plataforma que se
deseja utilizar, exigindo em muitos casos, alterações também no código fonte. Em Java
o mesmo programa pode ser executado em diferentes plataformas. Veja o exemplo
abaixo:
?
O mesmo código fonte
Introdução a linguagem Java
public class HelloWorldApp{public static void main (String arg []){
System.out.println("Hello World!");}
}
Compilação:
> javac Hello.java
Execução:
> java Hello
Sistema Operacional e
Processadores diferentes
Hello
World
Hello
WorldHello
World
"write once, run anywhere."
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
10
Gerando Aplicações
Para criarmos aplicações ou programas na linguagem Java temos que executar os
alguns passos: Edição, Compilação e Interpretação.
A Edição é a criação do programa, que também é chamado de código fonte.
Com a compilação é gerado um código intermediário chamado Bytecode, que é um
código independente de plataforma.
Na Interpretação, a máquina virtual Java ou JVM, analisa e executa cada instrução do
código Bytecode.
Na linguagem Java a compilação ocorre apenas uma vez e a interpretação ocorre a cada
vez que o programa é executado.
Javac myProgram.java
Java myProgram
1
2
3
Introdução a linguagem Java
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
11
Instalação do ambiente de desenvolvimento (JDK)
O Java Development Kid (JDK) é conjunto de ferramentas para compilar, depurar,
executar e documentar um programa escrito em java.
As versões para Solaris, Linux e Windows podem ser obtidas no endereço:
www.java.sun.com (Página oficial da linguagem).
Procedimentos de Instalação:
Para instalar o JDK, basta executar o programa de instalação e seguir as instruções.
Caso o JDK esteja compactado será necessário descompactá-lo primeiro, os formatos
mais populares de arquivos compactados são zip (para Windows) e tar (para Unix).
Após a instalação é necessário configurar o ambiente:
No windows: Acrescentar no Autoexec.bat:
SET JAVA_HOME=C:\JDK1.3
PATH=%JAVA_HOME%\bin
A variável JAVA_HOME deve ter o mesmo nome do diretório onde foi instalado o JDK.
O próximo passo é instalar a documentação, ela geralmente está em arquivo
compactado, ao descompacta-la selecionar a unidade de disco, por exemplo: “C:\”,
pois, o diretório padrão da documentação (docs) já está definido no arquivo
compactado. Caso você tenha instalado o JDK em outro diretório que não seja o
padrão, você deverá especificar no momento da instalação. A documentação está
no formato HTML, o arquivo principal o index.html.
Introdução a linguagem Java
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
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
12
Instalação do ambiente de desenvolvimento (JDK)
documentação
bin:
Onde estão todos os arquivos necessários para compilar (javac), depurar (jdb) e
executar (java).
demo:
Onde estão os arquivos de demonstração e exemplos da linguagem Java.
docs:
Onde está a documentação do ambiente da Linguagem Java no formato HTML
include:
Onde estão os arquivos escritos em linguagem C, os “header”, que são usados na
integração de Java e a Linguagem C.
Include-old:
Onde estão os arquivos escrito em linguagem C, os “header”, entretanto, os arquivos
são de versão mais antiga.
jre:
Ambiente de execução do Java necessário para distribuir a aplicação aos clientes.
lib:
Onde estão as bibliotecas Java, também chamadas de APIs. A extensão dos arquivos
é .jar.
Resumo:
Após a instalação, você deverá ter uma estrutura de diretórios como aparece na
figura:
Introdução a linguagem Java
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
13
Instalação do ambiente de desenvolvimento (JDK)
A figura demonstra uma visão do pacote de desenvolvimento JDK e também do
ambiente de execução (JRE). Ambos são necessários para desenvolver uma aplicação.
Para os clientes, os usuários finais, precisam apenas do ambiente de execução JRE.
Aplicativos como os Applets executam através do Browser (Internet Explorer ou
Netscape) geralmente a VM que está embutida nestes navegadores.
Ambiente para os desenvolvedores
Ambiente necessário nos
Clientes (usuários finais)
Sistema Operacional
Introdução a linguagem Java
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
14
O Compilador javac
Argumento Descrição
-classpath path Localização das classes. Sobrepõe a variável de ambiente
Classpath.
-d dir Determina o caminho onde as classes compiladas sãoarmazenadas
-deprecation Faz a compilação de código em desuso, geralmente de versõesanteriores e faz aviso de advertência
-g Gera tabelas de "debugging" que serão usadas pelo pelo
deupador JDB.
-nowarm Desabilita as mensagens de advertência
-verbose Exibe informações adicionais sobre a compilação
-O Faz otimização do código
-depend Faz a compilação de todos os arquivos que dependem do arquivoque está sendo compilado. Normalmente somente é compilado o
arquivo fonte mais as classes que este invoca.
Sintaxe: javac [opções] NomedoArquivo.java
Veja abaixo a lista dos principais argumentos:
Exemplos:
> javac Hello.java
> javac -d . Hello.java
> javac -deprecation Hello.java
> javac -O -deprecation -verbose Hello.java
> javac -O Hello.java
Introdução a linguagem Java
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
15
O Interpretador java
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= valor
Possibilita redefinição de valores de propriedades. Pode ser usado
várias vezes.
-jar Indica o nome do arquivo (com extensão .jar) que contém a classe a ser
executada.
-X Exibe a lista de opções não padronizadas do interpretador
-v ou -verbose Exibe informações extras sobre a execução, tais como, mensagens
indicando que uma classe está sendo carregada e etc
Lista de
Argumentos
Define a lista de argumentos que será enviada a aplicação
Sintaxe: java [opções] NomedoArquivo [lista de Argumentos]
Veja abaixo a lista das principais opções:
Alguns Exemplos:
> java Hello
> javac -version
> java -D nome=“Meu Nome” Hello
> java -verbose Hello
> javac Hello MeuNome
Introdução a linguagem Java
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
16
Java Virtual Machine
A JVM é parte do ambiente de "runtime" Java e é a responsável pela
interpretação dos bytecodes (programa compilado em java), ou seja, a execução
do código.
A JVM consiste em conjunto de instruções, conjunto de registradores, a pilha
(stack) , garbage-collected heap e a área de memória (armazenamento de
métodos).
Funcões da JVM:
Carregar de forma segura todas as classes do programa (protegendo contra
ataques premeditados, por exemplo, Cavalos de Tróia)
Verificar se os bytecodes aderem às especificações da JVM e se não violam a
integridade e segurança da plataforma.
Interpretar o código.
Em tempo de execução estes bytecodes são carregados, são verificados através
do Bytecode Verifier (uma espécie de vigilante) e somente depois de verificados
serão executados.
J
V
M
Programa
Compilado
Programa
Fonte
Javac <programafonte.java>
Class Loader
Byte Code Verifier
Runtime
Java <programafonte>
Introdução a linguagem Java
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
17
Coletor de Lixo:
A linguagem Java tem alocação dinâmica de memória em tempo de execução.
No C e C++ (e em outras linguagens) o programa desenvolvido é responsável pela
alocação e deslocamento da memória. Isto geralmente provoca alguns problemas.
Durante o ciclo de execução do programa, o Java verifica se as variáveis de
memória estão sendo utilizadas, caso não estejam o Java libera automaticamente
esta área para o uso.
Garbage Collection
Introdução a linguagem Java
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
18
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!
Introdução a linguagem Java
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
19
Escrevendo um pequeno programa
public class Hello
{
public static void main (String arg [])
{ String s = "world";
System.out.println("Hello " + s);
}
}
modificador
Nome da classe
Método
principal
Classe
(corresponde
ao arquivo
que será gravado
do disco)
Classe java
método
Lista de argumentos
(o tipo em questão é String)
Tipo de dado
Variável
Roteiro para criar um programa em Java:
1 - Fazer a assinatura da classe, isto equivale a declaração:
public class NomedaClasse {
2 - Declarar as variáveis, também chamadas de fields:
int i =0 ;
Neste caso não temos nenhum variável de classe ou field
3 - Fazer a assinatura dos métodos:
public static void main (String args[]){
4 - Escrever o corpo do método:
String s= “world”;
System.out.println(“Hello” + s);
5 - Para encerrar o método, note que o corpo do método está entre chaves “{...}“.
}
6 - Para encerrar a classe, segue o mesmo princípio do método. Use chaves “}“.
7 - Salve o arquivo. Observe que o nome do arquivo deve ser o mesmo nome da
classe.
Hello.java
8 - Compilar o programa. Sintaxe: javac <NomedaClasse.java>.
Javac Hello.java
9 - Agora execute o arquivo. Sintaxe: java <NomedaClasse>
Java Hello
Introdução a linguagem Java
Atributo da
Classe System
Dissecando o código
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
20
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.
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
21
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
22
Fundamentos da Linguagem Java
Estrutura da Linguagem
Comentários:
Temos três tipos permitidos de comentários nos programas feitos em Java:
• // comentário de uma única linha
• /* comentário de uma ou mais linhas */
• /** comentário de documentação */ (este tipo de comentário é usado pelo utilitário
Javadoc, que é responsável por gerar documentação do código Java)
Exemplo Descrição
int x=10; // valor de x Comentário de linha
/*
A variável x é integer
*/int x;
Exemplo onde o comentário usa mais que uma linha.
Todo o texto entre "/*" e "*/", inclusive, são ignorados pelo
compilador
/**
x -- um valor inteiro representa
a coordenada x*/
int x;
Todo o texto entre o "/**" e "*/", inclusive, são ignorados
pelo compilador mas serão usados pelo utilitário javadoc.
Ponto e vírgula, Blocos e o espaço em branco:
• No Java, os comandos são terminados com o sinal de ponto e vírgula (;)
• Um bloco tem início e fim representados pelo uso das chaves { };
• O uso do espaço em branco permite uma melhor visualização dos comandos e em
conseqüência facilita a sua manutenção.
Exemplo:
Bloco da Classe
public class TestEstrutura
{
public void sayHello(String hello)
{
System.out.println("Hello ");
}
}
Bloco do MétodoPonto e virgula
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
23
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
public class Hello
{
public static void main (String arg [])
{ String s = "world";
System.out.println("Hello " + s);
}
}
Identificador
(nome da classe)
Método
principalClasse
Identificador
(nome do método)
Veja que primeiro
foi definido
o tipo de dado,
String, e depois o
nome do Identificador
(nome do variável)
--------------------------- Compiler Output ---------------------------
TestIdentificador.java:3: illegal start of type
private 1nome;
Veja o código abaixo onde são apontados os identificadores
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
24
Palavras Reservadas abstract do implements private throw boolean double import protected throws break else instanceof public transient byte extends int return true case false interface short try catch final long static void char finally native super volatile class float new switch while continue for null synchronized default if package this
Palavras Reservadas
Fundamentos da Linguagem Java
As Palavras Reservadas, quer dizer que nenhuma das palavras da lista acima podem ser
usadas como identificadores, pois, todas elas foram reservadas para a Linguagem Java.
Veja o exemplo abaixo:
public class TestPalavraReservada
{
private int return =1;
public void default(String hello)
{
System.out.println("Hello ");
}
}
Este programa provocará erros ao ser compilado:
--------------------------- Compiler Output ---------------------------
TestEstrutura.java:3: <identifier> expected
private int return =1;
^
TestEstrutura.java:6: <identifier> expected
public void default(String hello)
Palavra reservada
Palavra reservada
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
25
Tipos de Dados
Existem tipos básicos ou primitivos e os tipo de referência.
Sintaxe padrão:
<Tipo de dado> <nome da variável>; ou
<Tipo de dado> <nome da variável> = valor da variável;
<Tipo de dado> <nome da variável> = valor da variável, <nome da variável> =
valor da variável... ;
Tipo Lógico - boolean: true e false
Exemplo boolean fim = true;
Tipo Textual - char e String (String é uma classe)
Um caracter simples usa a representação do tipo char. Java usa o sistema de
codificação Unicode (Veja Apêndice B). Neste sistema o tipo char representa um
caracter de 16-bit.
O literal do tipo char pode ser representado com o uso do („ „). Exemplos:
a = „b‟;
„\n‟ – nova linha
„\r‟ – enter
„\u????‟ – especifica um caracter Unicode o qual é representado na
forma Hexadecimal.
„\t‟ – tabulação
„\\‟ - \
„\” ”‟ - “”
String (String é uma classe)
O tipo String é um tipo referência que é usado para representar uma seqüência de
caracteres.
Exemplo:
String s = “Isto é uma string”, s1;
Inteiros – byte, short, int e long
Possuem somente a parte inteira, ou seja, não suportam casas decimais.
Exemplos:
int i1 = 10, int i2 = 11;
byte b = 1;
Código de escape
Fundamentos da Linguagem Java
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
26
Ponto Flutuante
São os tipos que têm suporte às casas decimais e maior precisão numérica.
Existem dois tipos em Java: o float e o double.
Veja alguns exemplos:
3.14 Um ponto flutuante simples;
6.02E23 Um valor de ponto flutuante largo;
2.718F Um valor de ponto flutuante simples;
123.4E+306D Um valor de ponto flutuante usando o tipo double.
Exemplos de declarações:
float f = 3.1;1
float div = 2.95F;
double d1 = 6.35, d2 = 6.36, d3 = 6.37;
double pi = 3.14D
Regra:
Os tipos float e double quando aparecem no mesmo programa é necessário
identificá-los, para que não comprometa a precisão numérica:
float f = 3.1F;
double d = 6.35;
Uma vez não identificado, ao tentar compilar o programa, será emitida uma
mensagem de erro.
Tamanho Tipo Faixa
8 bits byte -128 a 128
16 bits short -32.768 a 32.767
32 bits int -2.147.483.648 a 2.147.483.647
64 bits long 9.223.372.036.854.775.808 a
9.223.372.036.854.775.807
Tamanho Tipo Faixa
32 bits IEEE 754-1985 Float 1,4E-45 a 3,4E+38
64 bits IEEE 754-1985 Double 4,9E-324 a 1,7E+308
Fundamentos da Linguagem Java
Tipos de Dados
Precisão
7 dígitos
15 dígitos
Nota (1) Toda vez que uma variável tipo float não tem a literal F, esta variável internamente é tratada como se fosse um inteiro
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
27
Inicialização de variáveis
Fundamentos da Linguagem Java
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.
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
28
Operadores
Os operadores na linguagem Java, são muito similares ao estilo e funcionalidade
de outras linguagens, como por exemplo o C e o C++.
Exemplos:
int a = 1;
int b = a + 1;
int c = b - 1;
int d = a * b;
short s1 = -1;
short s2 = 10;
short s1++;
int c = 4 % 3;
Operadores Lógicos:
> Maior que
< Menor que
<= Menor que ou igual
>= Maior que ou igual
== Igual
!= Diferente
Exemplos:
i > 10;
x == y;
“Test” != “teste”
!y
x || y
Operadores Matemáticos:
+ Adição
- Subtração
* Multiplicação
/ Divisão
++ Incremento
-- Decremento
% Módulo- Negativo (unário)
+ Positivo (unário)
! Not (negação) && And || OR
Fundamentos da Linguagem Java
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
29
Outros Operadores:
instanceof Faz a comparação do objeto que está “instanciado” no objeto
Exemplos:
instanceof:
Objeto obj = new String(“Teste”);
if (obj instanceof String) System.out.println(“verdadeiro”)
new:
Hello hello = new Hello();
Precedências de Operadores:
. [ ] ( )
++ - ! ~ instanceof
new (type) expressão - O type é coerção de tipo
* / %
+ -
<< >> >>>
Exemplo:
Com a precedência definida pelo Java
int c = 4 / 2 + 4;
Neste caso, primeiro ocorrerá a divisão e após a soma.
Com a precedência definida pelo desenvolvedor
int a = 4 / (2 + 4);
Já neste caso, primeiro ocorrerá a soma e depois a divisão.
new Este operador é usado para criar novas “instance” de classes
Fundamentos da Linguagem Java
Operadores
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
30
Operador Nome Descrição
& AND sobre bits Os bits no resultado são configurados como 1 se os bits
correspondentes nos dois operandos forem ambos 1
| OR inclusive sobre
bits
Os bits no resultado são configurados como 1 se pelo menos um
dos bits correspondentes nos dois operandos for 1
^ OR exclusivo sobre
bits
Os bits no resultado são configurados como 1 se somente um dos
bits correspondentes nos dois operandos for 1
<< Deslocamento para
esquerda
Desloca os bits do primeiro operando para a esquerda pelo número
de bits especificado pelo segundo operando; preenche a partir da
direita com bits 0.
>> Deslocamento para
direita com extensãode sinal
Desloca os bits do primeiro operando para a direita pelo número
de bits especificado pelo segundo operando. Se o primeirooperando for negativo, preenche com 1s a partir da esquerda; caso
contrário, preenche com 0s a partir da esquerda.
>>> Deslocamento para
direita com extensão
de zero
Desloca os bits do primeiro operando para a direita pelo número
de bits especificado pelo segundo operando; 0s são inseridos a
partir da esquerda
~ Complemento de um Todos os bits são configurados como 1 e todo os bits são
configurados como 0.
Java fornece extensa capacidade de manipulação de bits. Todos os dados são
representados internamente como uma seqüência de bits. Cada bit pode assumir o
valor de 0 ou 1. No geral uma seqüência de bits formam um byte, que é a unidade de
armazenamento padrão, para uma variável tipo byte. Os tipos de dados são
armazenados em quantidade maiores que byte. Os operadores sobre os bits são
utilizados para manipular os bits de operandos integrais (isto é aqueles do tipo byte,
char, short, int e long).
Manipulação de bits e os operadores sobre bits
Exemplos de manipulação do bits:
Right Shift (>>)
128 >> 1 <=> 128/21 = 64
256 >> 4 <=> 256/24 = 16
-256 >> 1 <=> -256/24= -16
Left Shift (<<)
128 << 1 <=> 128 * 21 = 256
16 << 2 <=> 16 * 22 = 64
Fundamentos da Linguagem Java
Operadores
Operadores Binários:
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
31
Podemos realizar operações de Pré e Pós incremento e de Pré e Pós decremento.
Veja os exemplos:
Pré-incremento:
Pré-incremento = ++a; Exemplo: a = 10, b = 11, c = a + ++b => c = 22
Pós-incremento = a++; Exemplo: a = 10, b = 11, c = a + b++ => c = 21
Pós-decremento:
Pré-decremento = --x; Exemplo: x = 1, y = 1, z = x + --b => z = 1
Pós-decremento = x--; Exemplo: x = 1, y = 1, z = x - b-- => z = 0
Observe que isto ocorre devido a precedência de operadores. Primeiro é feito a
atribuição e depois o incremento.
Operador Exemplo Equivalência
++ x++, ++x x = x + 1
-- x--, --x x = x - 1
+= x += y x = x + y
-= x -= y x = x - y
*= x *= y x = x * y
/= x /= y x = x / y
&= x &= y x = x & y
|= x |= y x = x | y
^= x ^= y x = x ^ y
%= x %= y x = x % y
Lista de
Exemplos
Fundamentos da Linguagem Java
Operadores
Exemplo:
public class TesteOperador {
public static void main(String args[]) {
int x = 1;
int y = 1;
int z = x - y--;
System.out.println("o valor z: " + z);
}
}
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
32
public class TestString
{ public static void main(String arg[])
{
String s1 = "Hello";
String s2 = new String("hello");
//equals
if (s1.equals(s2))
{ System.out.println("São iguais"); }
else
{ System.out.println("São Diferentes"); }
//equalsIgnoreCase
System.out.println("equalsIgnoreCase");
if (s1.equalsIgnoreCase(s2))
{ System.out.println("São iguais"); }
else
{ System.out.println("São Diferentes"); }
//Alguns métodos
//indexOf, charAt, substring
String frase = "Vovo viu a uva";
System.out.println("Posição: " + frase.indexOf('a'));
System.out.println("Nova frase: " + frase.substring(0,4));
System.out.println("A letra é: " + frase.charAt(5));
//concat
String nome = "James ”; String sobrenome = "Gosling ";
String nomeCompleto = nome.concat(sobrenome);
System.out.println("O nome é: " + nomeCompleto);
}
}
Exemplo:
String
A classe String
Objetos String são sequências de caracteres Unicode
Exemplo: String nome = “Meu nome”
Principais métodos:
Substituição: replace,
Busca: endWiths, startsWith, indexOf e lastIndexOf
Comparações: equals, equalsIgnoreCase e compareTo
Outras: substring, toLowerCase, toUpperCase, trim, charAt e length
Concatenação: concat e operador +
Exemplo: O operador + é utilizado para concatenar objetos do tipo String,
produzindo uma nova String:
String PrimeiroNome = “Antonio”;
String SegundoNome = “Carlos”;
String Nome = PrimeiroNome + SegundoNome
Fundamentos da Linguagem Java
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
33
public class TestStringBuffer
{
public static void main(String arg[])
{
//new instance
StringBuffer b1 = new StringBuffer();
StringBuffer b2, b3;
b2 = new StringBuffer(25);
b3 = new StringBuffer("Teste, ");
/*para exibir o conteúdo é necessário
usar o método toString */
System.out.println("b1:" + b1.toString() );
System.out.println("b2:" + b2.toString() );
System.out.println("b3:" + b3.toString() );
b3.append("vamos testar novamente");
System.out.println("b3:" + b3.toString() );
b3.insert(0, "A x B ");
System.out.println("b3:" + b3.toString() );
b3.delete(0,4);
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() );
}
}
Exemplo:
Objetos StringBuffer são uma seqüência mutável de caracteres Unicode
Construtores:
StringBuffer – Cria um buffer vazio
StringBuffer(int capacidade) – Cria um buffer com a capacidade especificada
StringBuffer(String initialstring) – Cria um buffer contendo uma string informada.
Principais métodos: append, insert, delete, ...
Fundamentos da Linguagem Java
StringBuffer
Várias formas
de declaração
Usando os métodos
para manipular
o objeto StringBuffer
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
34
Casting (coerção de tipos)
byte
int
charshort
long
float
double
Conversão
Explícita
Conversão
Implícita
Java faz a promoção de tipos para garantir que os valores sejam suportados pelas
faixas, contudo, a linguagem Java não suporta conversões arbitrárias de tipos de
variáveis.
Devemos explicitar a conversão entre tipos de variáveis. Veja o exemplo abaixo:
public class TestCasting
{
public static void main(String args[])
{
byte a = 1;
byte b = 3;
byte c = a + b;
/* Linha errad, pois a operação adição
sofre casting implicita */
//Correção o casting explicito
byte c = (byte) (a + b);
System.out.println(c);
}
}
Casting implícito
Por força do operador
matemático o Java promoveu a
valor resultante de a + b para
um valor inteiro, o que provoca
estouro da faixa de byte, e por
sua vez provoca um erro
Casting explícito
após a soma de a + b, o valor
da soma é convertido para byte
Hierarquia de conversão:
Fundamentos da Linguagem Java
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
35
Objetos
Os objetos não são convertidos, mas sim suas referências. Uma referência de uma
classe qualquer pode ser sempre usada para fazer referência a um objeto de uma de
suas subclasses. Quando isso acontece, a referência somente poderá ser utilizada
para acesso aos membros da classe, ficando os membros da subclasse
“inacessíveis”, embora com seus valores mantidos. A conversão desse tipo (de
subclasse para classe) é chamada de implícita.
Veja os exemplos abaixo:
import java.awt.*;
public class CastObjeto
{
public CastObjeto()
{
Window janela = new Frame();
janela.pack();
janela.setTitle("Titulo da Janela");
...
}
}
Conversão ilegal, pois, o
objeto janela não “enxerga”
os métodos de Frame,
embora o método exista,
pois o objeto
é do tipo Frame
Window
Frame
SuperClasse
SubClasse
Hierarquia de classes:
Fundamentos da Linguagem Java
Casting (coerção de tipos)
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
36
Casting ( Conversão de tipos ) Objetos
import java.awt.*;
public class CastObjeto
{
public CastObjeto()
{
Window janela =new Frame();
Frame janela1 = (Frame) janela;
janela1.setTitle("Titulo da Janela");
}
}
Conversão legal, pois, a
janela é um objeto do
tipo Frame e está sendo
atribuído a uma referência
do mesmo tipo
A conversão contrária, ou seja, de referência a classe para referência a subclasse, é
possível. Entretanto, essa conversão somente será válida se a referência à subclasse
passar a apontar para um objeto compatível com ela.
SuperClasse
SubClasseConversão
implícita
Conversão
explícita
As Interfaces seguem a mesma regra das classes.
Fundamentos da Linguagem Java
Casting (coerção de tipos)
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
37
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
sofre casting implicita */
//byte c = i + i;
//Correção o casting explicito
byte c = (byte) (a + b);
System.out.println(c);
//Exemplo 2
int ia = 1;
long lb = 3;
/*
Perda de Precisão - causa erro
*/
//int ic = ia + lb; //linha errada -> Casting
//Correção o casting explicito
int ic = ia + (int) lb;
System.out.println(ic);
}
}
O resultante da soma foi promovido
para tipo int, quando atribuímos a
variável , que é do tipo byte, a
operação provoca erro, pois, a faixa
de byte é menor que a faixa de int.
Uma vez aplicado o casting a
operação de soma é realizado e
depois é convertida para o type byte.
Casting explícito:
(byte) (a + b)
Casting implícito: (a + b)
Fundamentos da Linguagem Java
Casting (coerção de tipos)
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
38
Fluxo de Controle
Java como qualquer outra linguagem de programação, suporta instruções e laços
para definir o fluxo de controle. Primeiro vamos discutir as instruções condicionais
e depois as instruções de laço.
Antes, porém, vamos entender a necessidade dos blocos. Um bloco é o conjunto
de instruções delimitadas por chaves “{... }”. Exemplo:
{
int i = 10;
System.out.println(“Hello”);
i++
}
bloco
Os blocos povoam métodos, instruções condicionais, laços e etc, ou seja,
podemos encontrá-los sempre dentro de um programa Java.
Construções condicionais:
if (<expressão boolean>)
<declarações>...
else
<declarações>...
switch (<expressão>) {
case <expressao char-int>:
<declarações>...
break;
case <expressao char-int>:
<declarações>...
default:
<declarações>...
}
(<expressão boolean>) ? <expressão if-true>
: <expressão if-false>
Fundamentos da Linguagem Java
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
39
A instrução if
Sintaxes: if (expressão boolean) instrução
Exemplo: if (x>y) System.out.println(x);
if (expressão boolean) { //Bloco de instruções }
Exemplo: if (x>y) {
System.out.println(x);
y++;
}
if (expressão boolean)
{ //Bloco de instruções }
else
{ //Bloco de instruções }
Exemplo: if (x>y) {
System.out.println(x);
y++;
}
else {
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 }
Mais de uma instrução
é usado a estrutura de
bloco
Fundamentos da Linguagem Java
Fluxo de Controle
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
40
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:
saldo > 0
status = Negativo
status = Positivosim
não
Lógica
if (saldo > 0)
{
status = “Positivo”;
}
else
{
status = “Negativo”;
}
Código
Fundamentos da Linguagem Java
Fluxo de Controle
if (saldo > 0)
status = “Positivo”;
else
status = “Negativo”;
OU
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
41
A instrução if
Neste exemplo apresentaremos a instrução if com múltiplas opções. Veja a
lógica e também a implementação da do código:
saldo médio
> 5000
sim
não
Lógica
public class ifCompostoExemplo
{
public static void main(String args[])
{
int limitecheque;
int saldomedio = 15000;
if (saldomedio > 5000)
{
limitecheque = 1000;
}
else if (saldomedio > 3000 &&
saldomedio <= 5000)
{
limitecheque = 800;
}
else if (saldomedio > 2000 &&
saldomedio <= 3000)
{
limitecheque = 600;
}
else if (saldomedio > 1000 &&
saldomedio <= 2000)
{
limitecheque = 400;
}
else
{
limitecheque = 0;
}
System.out.println("Limite cheque
especial..." + limitecheque);
}
}
Código
saldo médio >
3000 and <=5000
saldo médio >
2000 and <= 3000
Limite cheque
=1000
Limite cheque
=800
Limite cheque
=600
sim
sim
não
Limite cheque
=0
não
saldo médio >
1000 and <= 2000
simLimite cheque
=400
não
Fundamentos da Linguagem Java
Fluxo de Controle
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
42
A instrução switch
Switch é uma alternativa para seleção múltipla de escolha, entretanto, ela tem
algumas diferenças da estrutura if - if else. Como, por exemplo, o tipo de dado
válido na expressão é somente do tipo char e os tipos inteiros (int, byte, short,
long).
Sintaxes:
switch (expressao char-integer)
{
case expressao1:
// instruções
case expressao2:
// instruções
case expressao3:
// instruções
default:
// instruções
}
Exemplo:
public class switchSimplesExemplo
{
public static void main(String args[])
{
char opcao = 'a';
String selecao = "";
switch (opcao)
{
case 'a':
selecao += „a‟;
case 'b':
selecao += 'b';
case 'c':
selecao += 'c';
default:
selecao += "d";
}
System.out.println(selecao);
}
}
Será impresso “abcd”
Após a impressão do valor, achamos mais uma diferença em relação ao if - if
else, a instrução Switch executa todas as opções após uma opção válida. Por
exemplo, se valor inicial da variável opção for igual „c‟, teremos o seguinte
resultado para a variável selecao = „cd‟.
A instrução switch
Fundamentos da Linguagem Java
Fluxo de Controle
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
43
Fundamentos da Linguagm Java
A instrução switch.
Para que a instrução switch execute apenas uma opção, desprezando as demais é
necessário incluirmos a instrução break. Bem como o próprio nome da instrução
sugere este sai da instrução switch.
Sintaxes:
switch (expressao char-integer)
{
case expressao1:
// instruções
break;
case expressao2:
// instruções
break
case expressao3:
// instruções
break
default:
// instruções
}
public class switchBreakExemplo
{
public static void main(String args[])
{
char opcao = 'b';
String selecao = "";
switch (opcao)
{
case 'a':
selecao += 'a';
break;
case 'b':
selecao += 'b';
break;
case 'c':
selecao += 'c';
break;
default:
selecao += "d";
}
System.out.println(selecao);
}
}
Será impresso “b”
A instrução switch com
a instrução break
Note que tanto a instrução default quanto a break são opcionais, depende da
lógica a utilizada.
Fundamentos da Linguagem Java
Fluxo de Controle
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
44
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:
case 10sim
não
Lógica
public class switchCompostoExemplo
{
public static void main(String args[])
{
String avaliacao ="";
int nota = 8;
switch (nota)
{
case 10:
avaliacao = "Excelente";
break;
case 9:
avaliacao = "Ótimo";
break;
case 8:
avaliacao = "Bom";
break;
case 7:
avaliacao = "Satisfatório";
break;
default:
avaliacao = "Regular";
}
System.out.println("Avaliação: "
+ avaliacao);
}
}
Código
case 9
case 8
avaliacao =
“Excelente”
avaliacao =
“Ótimo”
avaliacao =
“Ótimo”
sim
sim
não
avaliacao =
“Regular”
não
case 7sim
avaliacao =
“Ótimo”
não
Fundamentos da Linguagem Java
Fluxo de Controle
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
45
A instrução switch.
Neste exemplo apresentaremos a instrução switch sem o break com múltiplas
opções. Veja a diferença:
case S
sim
não
Lógica
public class switchSemBreakExemplo
{
public static void main(String args[])
{
char opcao = 'B';
String selecao = "";
switch (opcao)
{
case 'S': //Super luxo
selecao += " Ar condicionado +";
case 'L': //Luxo
selecao += " Direção hidráulica +";
case 'B': //Básico
selecao += " Trio Elétrico +";
default:
selecao += " Alarme";
}
System.out.println(selecao);
}
}
Código
Ar condicionado
sim
sim
não
Alarme
não
case L Direção hidráulica
case S Trio Elétrico
Fundamentos da Linguagem Java
Fluxo de Controle
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
46
Operador Ternário
E por fim o operador ternário, Java, oferece uma maneira simples de avaliar uma
expressão lógica e executar uma das duas expressões baseadas no resultado.
O operador condicional ternário (?:). É muito parecido com a instrução iif()
presente em algumas linguagens, Visual Basic, por exemplo.
Sintaxe:
(<expressão boolean>) ? <expressão true> : <expressão false>
ou
variável = (<expressão boolean>) ? <expressão true> : <expressão false>
saldo > 0
status = Negativo
status = Positivosim
não
Lógica
{
...
Status = (saldo > 0)?
”Positivo”:“Negativo”;
...
}
Código
Neste exemplo apresentaremos uma expressão condicional simples. Veja a
lógica e implementação do código. Faça uma comparação com a instrução if-else.
Lembre-se que podemos aninhar operadores e condições, pois, todos suportam
a recursividade.
Fundamentos da Linguagem Java
Fluxo de Controle
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
47
Laços
O que são laços?
Laços são repetições de uma ou mais instruções até que uma condição seja
satisfeita. A linguagem Java tem dois tipos de laços: os finitos e os infinitos.
Para os laços finitos a execução está atrelada a satisfação de uma condição, por
exemplo:
Laços:
while (<boolean-expression>)
<statements>...
do
<statements>...
while (<boolean-expression>);
for (<init-stmts>...; <boolean-expression>; <exprs>...)
<statements>...
Fundamentos da Linguagem Java
Fluxo de Controle
Já os infinitos estes executarão sempre, independente de condição.
Se o valor da variável a não for igual
10.
então
incrementar um na variável
senão
imprimir a variável valor
Isto quer dizer que a instrução de
incremento vai repetir dez vezes.
true a++
Em Java, temos três instruções que suportam laços ou “loops”. São elas:
while, do-while e for.
a = 10 a++
sim
não
Imprimir a
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
48
A instrução while.
Ela executa uma instrução ou bloco de instruções, enquanto uma determinada
condição não for satisfeita. Ela faz a validação antes de executar as instruções.
Sintaxe:
while (expressao boolean)
instrução java
Exemplo:
public class whileExemplo2
{
public static void main(String args[])
{
int d = 10;
while (d >= 0)
System.out.println("Contagem Regressiva " + d--);
}
}
Este código será executado 10
vezes, ou seja até a condição
ser satisfeita
Sintaxe:
while (expressao boolean)
{
//Bloco
}
Exemplo:
public class whileExemplo
{
public static void main(String args[])
{
int d = 1;
while (d<= 10)
{
System.out.println("7 x " + d + " = " + 7*d);
d++;
}
}
}
Este código produzirá a Tabuada do 7
Neste exemplo o laço é finito, ou seja, irá
executar até a condição estar satisfeita
A instrução while
Fundamentos da Linguagem Java
Fluxo de Controle
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
49
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++);
}
....
Fundamentos da Linguagem Java
Fluxo de Controle
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
50
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.
Fundamentos da Linguagem Java
Fluxo de Controle
valor < 20 Valor++
sim
não
Lógica
{
...
while(valor <20) valor++
System.out.println(valor);
...
}
Código
Imprime valor
Sai do Laço
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
51
A instrução do-while.
Ela tem uma pequena diferença da instrução while, enquanto a instrução while
verifica a expressão boolean (lógica) antes e somente depois executa a instrução
ou o bloco de instruções, a instrução do-while executa primeiro e depois verifica a
condição.
Sintaxe:
do
instrução java
while(expressão boolean)
Exemplo:
public class dowhileExemplo
{
public static void main(String args[])
{
long d=10;
do
System.out.println(d++);
while (d <=20);
}
}
Este código será executado 10
vezes, ou seja até que a
condição seja satisfeita
Sintaxe:
do {
//Bloco
}
while(expressão boolean)
Exemplo:
public class dowhileExemplo2
{
public static void main(String args[])
{
int d = 100;
do
{
System.out.println("Faixa " + Math.random()*d);
d++;
}
while (d <=110);
}
}
A instrução do-while
primeiro executa
as instruções que
estão dentro de bloco
e depois verifica a
expressão boolean
Fundamentos da Linguagem Java
Fluxo de Controle
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
52
A instrução do-while.
O exemplo abaixo exibe a lógica e implementação do código de laço finito usando a
declaração do-while.
Valor < 20
Valor++
sim
não
Lógica
...
do
{
valor++;
System.out.println(valor);
}
while(valor <20)
...
Código
Imprime valor
Agora faça uma comparação entre a instrução while e do-while:
Fundamentos da Linguagem Java
Fluxo de Controle
valor < 20 Valor++
sim
não
Lógica
{
...
while(valor <20)
valor++;
System.out.println(valor);
...
}
Código
Imprime valor
Sai do Laço
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
53
A instrução for
A instrução for é a mais popular entre as instruções de laço. A instrução for como as
demais instruções de laços repetem uma instrução ou bloco de instruções até que
determinada condição seja satisfeita.
Sintaxes:
for(valor-inicial1, valor-inicial2 ; condição; valor de incremento/decremento)
instrução java;
for(valor-inicial; condição; valor de incremento/decremento)
{
//Bloco de instruções
}
for(;condição; valor de incremento);
for(l;; valor de incremento);
for();
onde:
valor-inicial - valor de inicio (esta variável que pode ser definida dentro do for ou
fora).
Exemplo:
int x;
for(x=1;x<10;x++) instrução Java
ou
For(int x=1;x<10;x++) instrução Java
condição: é expressão lógica, Exemplo:
For(x=1;x<10;x++) instrução Java
valor de incremento: valor que incrementaremos ou decrementaremos
For(x=1;x<10;x--) instrução Java
Fundamentos da Linguagem Java
Fluxo de Controle
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
54
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;
for(d=180; d <=190; d++) System.out.println("Faixa 180-190 : " + Math.random()*d);
for(d=200; d <=210; d++)
{
System.out.println("Faixa 200-210: " + Math.random()*d);
}
int i;
for(d=220,i=10; d <=230; d++, i++)
{
System.out.println("Faixa 220-230 " + Math.random()*d);
System.out.println("Valor de i " + i);
}
for(d=230,i=20; d <=240 && i < 35; d++, i++)
{
System.out.println("Faixa 230-240 " + Math.random()*d);
System.out.println("Valor de i " + i);
}
for(i=40; i >= 30; i--)
{
System.out.println("Valor de i 40-30 " + i);
}
}
}
Sem bloco
Com bloco
Trabalhando
com valores
Trabalhando
com valores
e condição
composta
Trabalhando
com ordem
decresente
Fundamentos da Linguagem Java
Fluxo de Controle
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
55
public class forExemplo1
{
public static void main(String args[])
{
int d=170;
for(;d <=190; d++) System.out.println("Faixa 180-190 : " + Math.random()*d);
for(d=200; ;d++)
{
System.out.println("Faixa 200-210: " + Math.random()*d);
if (d>210) break;
}
for(d=210; d < 220;)
{
System.out.println("Faixa 210-220: " + Math.random()*d);
d++;
}
int i=10;
for(d=220; d <=230; d++)
{
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)
{
System.out.println("Valor de i 40-30 " + i);
}
}
}
A instrução for
Veja abaixo mais exemplos, desta vez, com algumas variações possíveis da
instrução for:
Sem declarar
valor-inicial
Sem condição.
A condição está
associado a
instrução if
Sem valor de
incremento ou
decremento.
For aninhados
Decrementado
de dois em dois
Note que a instrução break pode ser usada para sair de instrução de laço (while,
do-while e for).
Fundamentos da Linguagem Java
Fluxo de Controle
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
56
Lógica
..
for(i=10; i >= 0; i-=2)
{
System.out.println("Valor
de i 10-0 " + i);
}
...
Código
Agora faça uma comparação entre a instrução do while, do-while e for. Quem
será mais rápido ?
A instrução for
O exemplo abaixo demonstra a lógica e implementação do código para a instrução
for:
i >=0
i=i-2
sim
não
Imprime i
i=10
Fundamentos da Linguagem Java
Fluxo de Controle
..
for(i=10; i >= 0; i-=2)
System.out.println("Valor
de i 10-0 " + i);
...
OU
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
57
Label (rótulo)
Em Java temos uma estrutura de bloco chamada Label. Esta defini um bloco de
instruções que podem ser executadas, devido sua lógica, que é similar ao comando
goto da Linguagem Basic. Esta estrutura não é muito usual.
Sintaxe:
<nome-da-label>:
instrução java
ou
<nome-da-label>:
{
//Bloco de instruçõe
}
Exemplo:
public class labelExemplo
{
public static void main(String args[])
{
int d=1;
label_one:
for(d=1; d <=10; d++)
System.out.println("Faixa de 0..10: " +d);
label_two:
{
for(; d <=20; d++)
System.out.println("Faixa de 10..20: " +d);
}
}
}
Veja a label e a instrução
for que parte da label_one
Fundamentos da Linguagem Java
Fluxo de Controle
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
58
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;
}
}
}
}
Label (rótulo)
Outro exemplo de Label, desta vez usando a instrução continue
A instrução continue
Às vezes precisamos pular para aquela ou esta parte do programa sem passar pelo
resto das instruções.
Fundamentos da Linguagem Java
Fluxo de Controle
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
59
Exemplo 1 Exemplo 2
String nomes[ ];
nomes = new String[3]
names[0] = "Duke";
names[1] = "Jane";
names[2] = "Tarzan";
String nomes[ ] = {"Duke", "Jane","Tarzan"};
Exemplo 3 Exemplo 4
MinhasDatas dates[ ];
dates = new MinhasDatas[2];
dates[0] = new MinhasDatas(22, 7, 2000);
dates[1] = new MinhasDatas(01, 4, 1999);
MinhasDatas dates[ ] = { new MinhasDatas[2], new
MinhasDatas(22, 7, 2000) , new MinhasDatas(01, 4,
1999); }
Arrays
Os arrays são objetos. Devem possuir um tamanho definido no momento de sua
instanciação, por exemplo:
int[ ] arrayInt = new int[5], ou
int[ ] arrayInt
arrayInt = new int[5]
Os elementos de array são acessados pelo índice, que sempre deverá começar em
0. Não são permitidos índices inválidos, que resultam em exceção.
ArrayOutOfBoundsException.
Os arrays podem receber variáveis do tipo primitivo (int, double, char, boolean,
short e etc) ou do tipo referência, objetos, (String, Double, Integer e etc).
Quando um Arrays é redimensionado todos os elementos são perdidos.
Exemplo:
float ArrayReDim[ ] = new float[5];
ArrayReDim[ ] = new float[15];
Exemplo: Inicialização de Arrays
Arrays Multi-Dimensionais:
Declaração correta:
double duplaDim [ ] [ ] = new double [4] [ ];
duplaDim [0] = new double [1];
duplaDim [1] = new double [2];
duplaDim [3] = new double [3];
Declaração Incorreta:
double duplaDim [ ] [ ] = new double [ ] [4 ];
Fundamentos da Linguagem Java
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
60
Propriedades:
Length = retorna a quantidade de elementos de um Array
Exemplo:
int listaNum = new int[20]
for(int i=0; i < listaNum.length; i++ )
{ System.out.println(listaNum[i]); }
Principais Métodos:
arraycopy = faz cópia de array A para o B.
Exemplos:
public class TestArray1 {
public static void main (String args [ ])
{
int[] thisArray = {1,2,3,4,5,6,7,8,9,10};
for (int i =0; i < thisArray.length; i++)
{
System.out.println("Conteúdo" + thisArray[i]);
}
}
}
Declara e atribui os
valores para array
Imprime no
console os itens
do thisArray
public class TestArray2 {
public static void main (String args [ ])
{
String[] estadosul = new String[3];
estadosul[0]="RS";
estadosul[1]="SC";
estadosul[2]="PR";
for (int i =0; i < estadosul.length; i++)
{
System.out.println("Conteúdo " + estadosul[i]);
}
}
}
Declara e atribui os
valores para thisArray
Imprime no console os
itens do array
Fundamentos da Linguagem Java
Arrays
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
61
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.
Fundamentos da Linguagem Java
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
62
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
Fundamentos da Linguagem Java
Passagem de Parâmetros
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
63
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));
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)));
}
}
Fundamentos da Linguagem Java
Exemplo:
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
64
Empacotamento de Classes
É possível trabalhar com vários tipos de dados, desde números binários, hexadecimal,
boolean, string, etc. Em muitos casos há a necessidade de fazer conversão de um
tipo de dado para outro. Bem, começaremos com a conversão de tipos primitivos para
tipo referência (objetos), esta operação também é chamada de Wrapper Class.
Veja abaixo a tabela que associa os tipos.
Exemplos:
public class TestWrapperClass {
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);
}
}
Fundamentos da Linguagem Java
boolean
Boolean
byte
Byte
Char
Character
short
Short
int
Integer
long
Long
float
Float
double
Double
Tipo primitivo
Tipo referência
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
65
Uma lista de exemplos de conversão de um tipo para outro tipo e por aí vai...
Convertendo dados em Java de um tipo para outro.
> Convertendo String em integer:
int variavel = 42;
String str = Integer.toString(variavel);
ou
int variavel = 42;
String str = "" + variavel;
ou
int variavel = 42;
String str = String.valueOf(variavel);
> Convertendo String em Long:
long variavel = Long.parseLong(str);
ou
long variavel = Long.valueOf(str).longValue();
> Convertendo String em Double:
double variavel = Double.valueOf(str).doubleValue();
> Convertendo String em Float:
float variavel = Float.valueOf(str).floatValue();
> Convertendo Integer em String:
int variavel = 14;
String str = Integer.toString(variavel);
ou
int variavel = 14;
String str = "" + variavel
Fundamentos da Linguagem Java
Conversão de Tipos
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
66
Mais exemplos:
> Convertendo Integer em código ASCII:
char c = 'C';
int i = (int) c;
> Convertendo Double em String:
String str = Double.toString(i);
> Convertendo Long em String:
String str = Long.toString(l);
> Convertendo Float em String:
String str = Float.toString(f);
> Convertendo Decimal em Hexadecimal:
int i = 12;
String hexstr = Integer.toString(i, 16);
ou
String hexstr = Integer.toHexString(i);
> Convertendo Decimal em Binário:
int i = 12;
String binstr = Integer.toBinaryString(i);
> Convertendo Hexadecimal em Integer:
int i = Integer.valueOf("B8DA3", 16).intValue();
ou
int i = Integer.parseInt("B8DA3", 16);
> Convertendo Boolean em Integer:
i = (b)?1:0;
Fundamentos da Linguagem Java
Conversão de Tipos
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
67
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; }
}
Programação Orientada a Objetos
A referência this
Na classe PessoaJuridica, o uso da palavra this é para
evitar ambigüidade. Note que no método setIdade, o
parâmetro chama-se idade e o atributo também tem o
mesmo nome, ou seja, o mesmo identificador, neste
caso o this separa o atributo do parâmetro.
O Java associa automaticamente a todas as variáveis e métodos referenciados com a
palavra reservada this. Por isso, na maioria dos casos torna-se redundante o uso em
todas as variáveis da palavra this.
Aplicação: Impedir ambigüidade de nome de variáveis.
Restrição: Não pode ser aplicada a métodos estáticos, por exemplo, o método main.
Exemplo:
Existem casos em se faz necessário o uso da palavra this. Por exemplo, podemos
necessitar chamar apenas uma parte do método passando uma instância do argumento
do objeto. (Chamar um classe de forma localizada);
Birthday bDay = new Birthday(this);
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
68
Coleções
import java.util.*;
public class TestHashTable
{
public static void main(String Arg[])
{
Hashtable table = new Hashtable();
table.put("1", "Joao");
table.put("2", "Jose");
table.put("3", "Maria");
table.put("4", "Marta");
table.put("5", "Pedro");
table.put("6", "Mateus");
String find = (String) table.get("4");
System.out.println(find);
}
}
Hashtable (API: Java.util)
A tabela de hash é uma estrutura de dados que permite procurar os itens armazenados
em tabela utilizando uma chave associada. O formato padrão de entrada de dados na
tabela é chave e valor.
Para construir uma tabela de hash em Java, devemos criar um objeto Hashtable,
utilizando o construtor Hastable.
Para adicionar elementos na tabela usaremos o método put, put(object key, Object
value). Este método é da classe Hashtable. Para recuperar o elemento usado como
chave, devemos usar o método get, get(object key). Para remover um elemento
usamos o método remove.
Exemplo:
Implementação
de tabela Hash
e uso dos métodos
put e get
API
Fundamentos da Linguagem Java
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.
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
69
Enumeration (API: Java.util.Enumeration)
Retorna uma enumeração de uma coleção (Tabela Hash, por exemplo) especificada.
Principais métodos: hasMoreElements e nextElements.
import java.util.Enumeration.*;
import java.util.*;
public class EnumerationExemplo
{
public static void main(String Arg[])
{
Hashtable table = new Hashtable();
table.put("1", "Joao");
table.put("2", "Jose");
table.put("3", "Maria");
table.put("4", "Marta");
table.put("5", "Pedro");
table.put("6", "Mateus");
Enumeration e = table.elements();
while(e.hasMoreElements()){
String valor = (String) e.nextElement();
System.out.println(valor);
}
}
}
Usando a Interface
Enumeration, podemos
imprimir todos os
valores contidos
na tabela Hash
Tabela Hash
e métodos
API
Exemplo:
Fundamentos da Linguagem Java
Coleções
import java.util.Iterator.*;
...
Iterator i = table.values().iterator();
while(i.hasNext()){
String valor = (String)i.next();
System.out.println(valor);
}
Opcionalmente podemos usar
Iterator que tem a funcionalidade
parecida com Enumeration
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
70
Vector (API: Java.util)
A classe Vector possibilita a criação de vetor dinâmico para armazenamento de
referências de objetos, que pode ser indexado por número inteiro. Métodos principais:
addElement(), remove(), size(), element() entre outros
import java.util.*;
public class TestVector
{
public static void main(String Arg[])
{
Vector v = new Vector();
Integer y;
for(int x=0;x<5;x++)
{
y = new Integer(x);
v.addElement(y);
}
Object[] objArray = v.toArray();
for(int x=0;x<5;x++)
{
System.out.println(objArray[x]);
}
}
}
Exercício: Use Enumeration para listar todos os elementos de Vector.
Exemplo:
Declaração do Vector
Adiciona valores ao
Vector. Note que estes
valores são do tipo referência,
ou seja, objetos
Converte um Vector
para um array .
API
Fundamentos da Linguagem Java
Coleções
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
71
ArrayList ( API: Java.util).
ArrayList é array dimensionável da Interface List parecido com Vector. No exemplo
abaixo é permitido que os valores sejam duplicados, porém, desordenados. Principais
métodos: add, remove, clear, size, isEmpty, get, set, iterator.
import java.util.*;
public class ListExemplo {
public static void main(String[] args) {
List list = new ArrayList();
list.add("um");
list.add(new Integer(4));
list.add("terceiro");
list.add(new Integer(4));
System.out.println(list);
Vector v = new Vector();
Integer y;
for(int x=0;x<5;x++)
{
y = new Integer(x);
v.addElement(y);
}
List listVector = new ArrayList( v );
System.out.println(listVector);
}
}
Declaração do ArrayList
Inserção de valores na lista.
Veja que estes valores são objetos
Imprime os valores da lista
API
Uma nova coleção
Uma outra construção para a
lista, neste caso ela recebe
uma coleção como argumento
Imprime todos os
valores da lista
Exemplo:
Fundamentos da Linguagem Java
Coleções
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
72
HashSet (API: Java.util)
A classe HashSet Implementa a interface Set, ela também tem suporte da
HashTable. Ela é uma coleção que não pode conter elementos duplicados.
Principais métodos: add, clear, remove, size, iterator e isEmpty.
import java.util.*;
//Com ordem e sem repetição
public class SetExample {
public static void main(String[] args) {
Set set = new HashSet();
set.add(”dois");
set.add("3rd");
set.add(new Float(11.1F));
set.add(”quarto");
set.add(new Float(11.1F));
System.out.println(set);
}
}
API
Declaração do HashSet
Inserção de valores na lista.
Veja que estes valores são objetos
Imprime os valores da lista
Exemplo:
Fundamentos da Linguagem Java
Coleções
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
73
Fundamentos da Linguagem Java
Coleções
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
74
Pacotes
A linguagem Java é estruturada em pacotes, estes pacotes contém classes que por sua vez
contém atributos e métodos. Pacote é forma de organização da linguagem Java,
prevenindo de problemas como a repetição de identificadores (nomes) de classes e etc.
Podemos usar a estrutura de pacotes para associar classes com semântica semelhante, ou
seja, classes que tem objetivo comum. Por exemplo, colocaremos em único pacote todas
as classes que se referem a regras de negócios.
Exemplo:
Aplicação
Interface de Usuário
ControleRegras de Negócios
Fisicamente os pacotes tem a estrutura de diretório e subdiretório, isto quer dizer
que a Aplicação terá a seguinte formato:
Aplicação
Regras de Negócios
Interface de Usuário
Controle
Pacotes
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
75
Pacotes
Package
Esta instrução deve ser declarado na primeira linha do programa fonte, este instrução serve
para indicar que as classes compiladas faz parte do conjunto de classes (package), ou
sejam uma pacote, indicado pela notação path.name (caminho e nome do pacote).
Sintaxe: package <path.name>;
package MyPck;
public class ClassPkg
{
public ClassPkg()
{
System.out.println("Teste de package...");
}
}
Gerar pacotes: javac -d . *.java
import MyPck.ClassPkg;
public class TestPkg
{
public static void main(String args[])
{
ClassPkg p = new ClassPkg();
}
}
Diretório
Corrente
MyPck
ClassPck.class---
---
---
--- TestPck.class
Pacotes
Import
A instrução import faz importação para o arquivo fonte (.java) das classes indicadas, cujo o
diretório base deve estar configurado na variável de ambiente: CLASSPATH.
Sintaxe: import <classes>;
Exemplos:
import java.awt.Button; import java/awt/Button;
Substituindo os pontos por barras teríamos o caminho
Aqui estaríamos importando somente o objeto Buttonimport java.awt.*;
Neste caso estaríamos importando todos objetos contidos na classe
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
76
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
77
Programação Orientada a 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
Pessoa
nome
idade
getNome()
getIdade()
Nome da Classe
Atributos
Métodos
O nome da classe deve ser identificador único em conjunto de classes, este nome deve
ser substantivo no singular. Exemplo: Produto, Cliente e etc
Tipos de Classes:
• Classe Concreta
• Classe Abstrata
O que é uma Classes?
“Uma classe descreve um conjunto de objetos com propriedades e comportamentos
semelhantes e com relacionamentos comuns com outros objetos”
Classe
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
78
Exemplo:
A classe Pessoa. Classe concreta.
public class Pessoa {
//Atributos
private String nome;
private int idade;
//métodos
public String getNome(){
return nome; }
public void setNome(String
nome){
this.nome = nome; }
public int getIdade(){
return idade; }
public void setIdade(int
idade){
this.idade = idade; }
}
Classe Concreta:
É uma classe que tem assinatura e a implementação de métodos.
Programação Orientada a Objetos
Exemplo de diagrama de classe
usando Rational Rose (notação Unified)
Classe
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
79
Exemplo:
A classe Pessoa. Classe Abstrata
Classe Abstrata:
É uma classe que tem apenas assinatura de métodos sem implementação.
Programação Orientada a Objetos
Classe
public abstract class Pessoa
{
protected String nome;
public abstract String getnome();
public abstract void setnome(String nome);
}
Se uma classe é abstrata se métodos
também são
Observe que os métodos não implementados. Simplesmente assinados.
Diferenças ente Classe Abstrata e Concreta:
Classe Abstrata Classe Concreta
Os métodos devem ser somente assinadosOs métodos podem ser assinados e
implementados
Não pode sofrer “instance” Poder sofrer “instance”
Relacionamento somente através de herança Todos os tipos de relacionamentos
Classe Abstrata:
Em um relacionamento onde a classe Pai é abstrata e a filha é uma classe
concreta esta deve implementar os métodos assinados na classe Pai.
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
80
Exemplos de Objetos:
O que são Objetos ?
São qualquer coisa na natureza que possua propriedades (características) e
comportamentos (operações).
Exemplo: uma pessoa, uma cão e etc
Orientação a Objetos:
O termo orientação a objetos significa organizar o mundo real como uma coleção de
objetos que incorporam estrutura de dados e um conjunto de operações que
manipulam estes dados.
Estrutura de um objeto
Objetos combinam propriedades (atributos) e comportamentos (operações).
Podemos dizer que objeto é espécie da classe, ou seja, uma “instance” da classe
Propriedades Comportamentos
Bonita
Jovem
Inteligente
Andar
Correr
Falar
Chorar
Dançar
Objeto: Pessoa
Programação Orientada a Objetos
Objetos
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
81
Exemplos de Objetos:
O que são Objetos ?
São qualquer coisa na natureza que possua propriedades (características) e
comportamentos (operações).
Exemplo: uma pessoa, uma cão e etc
Orientação a Objetos:
O termo orientação a objetos significa organizar o mundo real como uma coleção de
objetos que incorporam estrutura de dados e um conjunto de operações que
manipulam estes dados.
Estrutura de um objeto
Objetos combinam propriedades (atributos) e comportamentos (operações).
Podemos dizer que objeto é espécie da classe, ou seja, uma “instance” da classe
Programação Orientada a Objetos
Objetos
Cliente: clientehomem
nome = Felipe
cpf = 039.217.908-22
idade = 22
Classe: Cliente e objetos
nome
cpf
idade
Cliente
Cliente: clientemulher
nome = Marina
cpf = 022.200.708-12
idade = 16
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
82
public class CalculaData {
private int day, month, year;
public float calcDays(int age )
{
return 365.25F * age;
}
}
Métodos
Programação Orientada a Objetos
método
Métodos são os comportamentos de um objeto. A declaração é feita da seguinte
forma:
< modificador > < tipo de retorno > < nome > ( < lista de argumentos > )
< bloco >
< modificador > -> segmento que possui os diferentes tipos de modificações
incluíndo public, protected, private e default (neste caso não precisamos declarar o
modificador).
< tipo de retorno > -> indica o tipo de retorno do método.
< nome > -> nome que identifica o método.
< lista de argumentos > -> todos os valores que serão passados como
argumentos.
Exemplos: public void somaDias (int dias) { }
private int somaMes(int mês) { }
protected String getNome() { }
int getAge(double id) { }
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
83
Métodos
Programação Orientada a Objetos
Método é a implementação de uma operação. As mensagens identificam os métodos
a serem executados no objeto receptor.
Para chamar um método de um objeto é necessário enviar uma mensagem para ele.
Por definição todas as mensagens tem um tipo de retorno, por este motivo em Java,
mesmo que método não retorne nenhum valor será necessário usar o tipo de retorno
chamado “void” (retorno vazio).
ContaCorrente
conta
saldo
setDeposito
getSaldo
setSaque
public class ContaCorrente {
private int conta=0;
private double saldo=0;
public double getSaldo(){
return saldo;
}
public void setDeposito(int valordeposito)
{
return saldo +=valordeposito;
}
public void setSaque(double valorsaque)
{
return saldo -=valorsaque;
}
}
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
84
Orientação a ObjetosProgramação Orientada a Objetos
public class Mamifero {
private int qdepernas;
private int idade;
public Mamifero(int idade)
{
this.idade = idade;
}
public Mamifero(int idade, int
pernas)
{
this.idade = idade;
this.qdepernas = pernas;
}
//Métodos
}
Construtores -
Podemos ter mais de um
construtor na mesma
classe.
Construtores
O que são construtores?
Construtores são um tipo especial de método usado para inicializar uma “instance”
da classe.
Toda a classe Java deve ter um Construtor. Quando não declaramos o
“Construtor default”, é inicializado automaticamente pelo Java. Mas existem
casos que se faz necessário a declaração explícita dos construtores.
O Construtor não pode ser herdado. Para chamá-lo a partir de uma subclasse
usamos a referência super.
Para escrever um construtor, devemos seguir algumas regras:
1ª O nome do construtor precisa ser igual ao nome da classe;
2ª Não deve ter tipo de retorno;
3ª Podemos escrever vários construtores para mesma classe.
Veja abaixo o exemplo:
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
85
public class Disciplina {
private int cargaHoraria;
private String nome;
public Disciplina(String nome, int
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)
( qdeHoras * 0.1);
return cargaHoraria =
horasPlanejamento + qdeHoras;
}
}
Atributos
Variáveis
temporárias
Atributos e variáveis
Programação Orientada a Objetos
Os atributos são pertencentes a classe, eles podem ser do tipo primitivo ou
referência (objetos), os seus modificadores podem ser: public, private, protected ou
default.
O ciclo de vida destes atributos estão vinculados ao ciclo de vida da classe.
Variáveis Locais:
São definidas dentro dos métodos. Elas têm o ciclo de vida vinculado ao ciclo do
método, também são chamadas de variáveis temporárias
Modificador
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
86
Exemplo de Classe
Programação Orientada a Objetos
Livro1
Legenda:
1 – Objeto no mundo real
2 – Modelo de implementação da classe Livro
3 – Codificação da classe Livro
public class Livro extends Object {
public Livro() {
}
private int isbn;
private String titulo;
private String autor;
public int getISBN(){
return isbn;
}
public void setISBN(int isbn){
this.isbn=isbn;
}
public String getTitulo(){
return titulo;
}
public void setTitulo(String titulo){
this.titulo=titulo;
}
public String getAutor(){
return autor;
}
public void setAutor(String autor){
this.autor=autor;
}
}
}
2
3
Criar o objeto Livro
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
87
Exercício sobre modelo de Classe
Programação Orientada a Objetos
1 (Identifique o objeto no mundo real)
2 Descreva o conceito:
Nome da Classe
Atributos 1
Atributos 2
Atributos 3
Métodos 1
Métodos 2
Métodos 3
3 Faça o desenho da classe:
public class <nome da classe> {
public <nome da classe> () {
}
private <tipo> atributo;
private <tipo> atributo;
private <tipo> atributo;
public <tipo> <nome método(lista de param...){
return <tipo de retorno>;
}
public <tipo> <nome método(lista de param...) {
this.atributo=valor param;
}
public <tipo> <nome método(lista de param...){
return <tipo de retorno>;
}
public <tipo> <nome método(lista de param...) {
this.atributo=valor param;
}
}
4 Faça a codificação do modelo de classe:
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
88
O que é abstração?
Podemos dizer abstração é generalização.
Qual é a função da abstração ?
A função da abstração é capturar as propriedades e os comportamentos essenciais,
como se fosse uma fatoração, desta forma determina-se o que é importante e o que
não é.
Aeronave
Caça Helicóptero Passageiros
Mamífero
Vaca Urso Cavalo
Para discutirmos sobre classes abstratas é necessário falarmos sobre a abstração de
dados.
As classes Aeronave e Mamífero neste caso são abstratas e ambas representam um
domínio.
Programação Orientada a Objetos
Abstração de Dados
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
89
Uma operação abstrata só determina a existência de um comportamento não definindo
uma implementação. Classes Abstratas - Exemplo:
Classes Abstratas
Uma classe abstrata é uma classe que:
• Provê organização
• Não possui “instances”
• Possui uma ou mais operações (métodos) abstratas
Pessoa
Pessoa
Física
Pessoa
Jurídica
getNome()
getNome() getNome()
Classe Abstrata
Funcionário
Analista Programador
Classe concreta
Classe concreta
Classe Abstrata
Programação Orientada a Objetos
Abstração de Dados
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
90
Classes Abstratas
Pessoa
Pessoa
Física
Pessoa
Jurídica
getNome()
getNome() getNome()
Classe Abstrata
Classe concreta
public abstract class Pessoa {
protected String idPessoa;
protected int idade;
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)
{ }
}
Programação Orientada a Objetos
Abstração de Dados
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
91
Classes Abstratas
Pessoa
Pessoa
Física
Pessoa
Jurídica
getNome()
getNome() getNome()
Classe Abstrata
Classe concreta
public class PessoaFisica extends Pessoa {
public PessoaFisica(String nome)
{
super(nome);
}
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; }
}
Programação Orientada a Objetos
Abstração de Dados
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
92
Um relacionamento é a conexão entre itens. É representado graficamente como um
caminho, que tem tipos diferentes de linhas para distinguir os tipos de
relacionamentos.
Ao construir as abstrações, descobrimos que são poucas as classes que trabalham
sozinhas. Em vez disso, a maioria das classes colaboram com outras classes de várias
maneiras.
Portanto, quando estamos modelando, devemos identificar as classes, atributos, métodos e
relacionamentos.
Existem alguns tipos principais de relacionamentos entre classes e objetos:
• Herança
• Associação
• Agregação
• Composição
Veja a definição de relacionamento:
Exemplo: Hierarquia de Classes
Pessoa
Aluno Funcionário
ProfessorPessoal
Administrativo
Terceiro
Professor
Autônomo
Pessoal
Operacional
SubClasses
SuperClasse
Relacionamento:
1 - Pessoa é a SuperClasse de Terceiro, Aluno e de Funcionário,
estas são subclasse de Pessoa.
2 - Terceiro e Funcionário são SuperClasse de Professor e Pessoal Administrativo e de
Professor Autônomo e Pessoal Operacional respectivamente.
E estas são subclasse de Terceiro e Funcionário.
Programação Orientada a Objetos
Relacionamento
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
93
Herança é o mecanismo pelo qual elementos mais específicos incorporam a estrutura e
comportamento de elementos mais gerais,
Uma classe derivada herda a estrutura de dados e métodos de sua
classe “base”, mas pode seletivamente:
• adicionar novos métodos
• estender a estrutura de dados
• redefinir a implementação de métodos já existentes
Uma classe “pai” proporciona a funcionalidade que é comum a todas as suas classes
derivadas, filhas, enquanto que uma classe derivada proporciona a funcionalidade
adicional que especializa seu comportamento.
Exemplo:
Graduação Pós-Graduação
Curso
Universitário
Especialização Extensão
Hierarquia de Classes
Podemos dizer que Graduação é tipo de Curso Universitário, assim como Curso de
Especialização ou de Extensão.
extends
extends
Programação Orientada a Objetos
Herança
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
94
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{
private int codigoTerceiro;
public Terceiro(String nome)
{
super(nome);
}
public int getIdade()
{
return 0;
}
public String getNome()
{
return "";
};
}
public class Funcionario extends Pessoa{
private int codigofuncionario;
public Funcionario(String nome)
{
super(nome);
}
public int getIdade()
{
return 0;
}
public String getNome()
{
return "";
};
}
Professor
Autônomo
Pessoal
Operacional
ProfessorPessoal
Administrativo
Programação Orientada a Objetos
Herança
public class Aluno extends Pessoa{
public Aluno(String nome)
{
super(nome);
}
public int getIdade()
{
return 0;
}
public String getNome()
{
return "";
};
}
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
95
Pessoa
AlunoTerceiro
public class ProfessorAutonomo
extends Terceiro{
public ProfessorAutonomo(
String nome)
{
super(nome);
}
}
public class PessoalOperacional
extends Terceiro{
public PessoalOperacional(
String nome)
{
super(nome);
}
}
public class Professor
extends Funcionario{
public Professor(
String nome)
{
super(nome);
}
}
public class PessoalAdministrativo
extends Funcionario{
public PessoalAdministrativo(
String nome)
{
super(nome);
}
}
Funcionário
Programação Orientada a Objetos
Exemplo de Herança: Implementação: ProfessorAutonomo, PessoalOperacional,
Professor e Pessoal Administrativo
Herança
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
96
A herança múltipla é quando uma classe tem mais que uma Superclasse associada e
que herde as características de todas elas. Veja a figura abaixo:
Pessoa
Pessoa JurídicaPessoa Física
<<interface>>
Mamífero
Relacionamento:
Pessoa Física é tipo de pessoa, mas também é mamífero.
Na linguagem Java:
A Herança múltipla é somente permitida por contrato, neste caso a Mamífero é uma
Interface, podemos dizer que é tipo especial de classe, que não pode
ter métodos implementados, apenas as assinaturas.
Programação Orientada a Objetos
Herança Múltipla
<<interface>>
Mamífero
Interface:
O que é interface ?
Interface é um contrato entre o cliente, que pode ser classe concreta ou abstrata, e a
interface. Este contrato é garantia que o métodos assinados na interface serão
implementados na classe cliente.
Nota: Na interface também podemos declarar constantes (public static final).
interface Product
{
String getName ();
double getCost ();
}
SuperclasseSuperclasse
Exemplo de Interface
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
97
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 abstract int getIdade();
public void setIdade(int idade){ }
}
public class PessoaJuridica1 extends Pessoa
{
public PessoaJuridica1(String nome)
{
super(nome);
}
public int getIdade()
{
return 0;
}
public String getNome()
{
return "";
};
}
public interface Mamifero {
final int qdeOlhos=2;
public int getQdePernas();
}
public class PessoaFisica1 extends Pessoa
implements Mamifero {
public PessoaFisica (String nome)
{
super(nome);
}
public int getQdePernas(){
return 2; }
public String getNome(){
return “”; }
public int getIdade(){
return 0; }
}
Exercício:
1 - Podemos implementar a herança múltipla na Classe Pessoa? Por que ?
2 - Por que somos obrigado a assinar ou implementar os métodos da Interface Mamifero
na classe PessoaFisica
Programação Orientada a Objetos
Herança Múltipla
implements
extends
extends
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
98
Comparação: classes e interfaces
Tipo Classe Concreta Classe Abstrata Interface
Herança extends(simples)
extends(simples)
implements(múltipla)
Permite a
implementação
de Métodos
sim não não
Permite a
declaração de
Dados
sim sim sim(somente final)
Programação Orientada a Objetos
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
99
Superclasse
Subclasse
public class Empregado {
private double salario;
public Empregado(){
salario=0.00;
}
public double getSalario(){
return this.salario;
}
}
public class Gerente extends Empregado {
private double bonus = .15;
public Gerente(){
//referência ao Construtor
super();
}
public double getSalario(){
//referência ao método getSalario
return super.getSalario() +
(super.getSalario()*this.bonus);
}
}
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:
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
100
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
public class Usuario {
public Senha m_Senha;
Usuario() {
}
}
public class Senha {
public Usuario m_Usuario;
Senha() {
}
}
Usuario Senha
Associação
classe classe
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
101
Programação Orientada a Objetos
Navegação
Navegação
Navegação é uma associação unidirecional
public class Pedido
{
public ItemPedido item[];
public Pedido()
{
}
}
public ItemPedido
{
public ItemPedido()
{
}
}
Pedido tem a responsabilidade de identificar
quais são seus itens. Já os itens não tem a
responsabilidade de saber a qual pedido que
eles pertencem.
O Código Java:
Pedido
ItemPedido
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
102
Programação Orientada a Objetos
public class Pessoa {
public Empresa Empregador[];
Pessoa() {
}
}
Rolename
Definição de RoleName:
É um identificador (nome) do papel da associação, podendo cada ponta ter um nome
especifico.
public class Empresa {
public Pessoa Empregado;
Empresa() {
}
}
As rolename neste caso são usadas identificadores dos atributos (das classes).
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
103
Programação Orientada a Objetos
Agregação
public class Roda {
public Pneu pneu;
Roda() {
}
Roda(int aro, String modelo) {
pneu = new Pneu(aro,modelo)
}
Definição de Agregação:
Um forma especial de associação, que especifica o relacionamento parte-todo entre o
agregado (o todo) e o componente (a parte).
Veja o exemplo abaixo:
public class Pneu {
public Roda roda;
Pneu() {
}
}
Pneu
Roda
roda
pneu
Todo
Parte de
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
104
Programação Orientada a Objetos
Composição
Cliente Pedido
ItemPedido
Produto
Definição de Composição:
Uma forma de agregação com propriedade bem-definida e tempo de via coincidente das
partes pelo todo; as partes com multiplicidade não fixada poderão ser criada após a própria
composição, mas, uma vez criadas, vivem e morrem com elas; essas partes também
podem ser removidas explicitamente antes da morte do elemento composto.
Todo
Parte de
um todo
Dados do Pedido
N• 19069
Cliente 1 – Cliente A
Data: 01/01/2002
It Descrição Qt Preço
--------------------------------
01 Produto A 10 12,40
02 Produto B 01 2,40
03 Produto C 11 5,60
04 Produto D 09 2,23
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
105
Programação Orientada a Objetos
Multiplicidade
Cliente Pedido
0..*1 0..*1
ItemPedido
1
1..*
Produto
1
*
1
1..*
*
1
Definição de Multiplicidade:
A especificação de uma faixa de números cardinais, que um conjunto pode assumir.
Todo
Parte de
um todo
Dados do Pedido
N• 19069
Cliente 1 – Cliente A
Data: 01/01/2002
It Descrição Qt Preço
--------------------------------
01 Produto A 10 12,40
02 Produto B 01 2,40
03 Produto C 11 5,60
04 Produto D 09 2,23
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
106
Programação Orientada a Objetos
Exemplo de implementação de Composição e multiplicidade
Cliente Pedido
0..*1 0..*1
ItemPedido
1
1..*
Produto
1
*
1
1..*
*
1
public class ItemPedido {
public Pedido m_Pedido;
public Produto
m_Produto;
ItemPedido() {
}
}public class Produto {
public ItemPedido m_ItemPedido[];
Produto() {
}
}
public class Pedido {
public ItemPedido m_ItemPedido[];
Pedido() {
}
}
public class Cliente {
public Pedido m_Pedido[];
Cliente() {
}
}
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
107
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.
Pedido Cliente
Pedido
Produto
AnaliseCredito
{se Pedido.Cliente.AnaliseCredito é ruim,
então pedido.ePrePago deve ser verdadeiro}
1
*
*
1
* 1faz
Constraint
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
108
<<negócio>>Vendedor
PercentualDeComissao
<<negócio>>Prestacao
DataDeVencimentoValorDaPrestacao
<<negócio>>Cliente
SituacaoFinanceira
<<negócio>>Produto
QtdeEmEstoque
<<negócio>>Venda
DataDaVenda
<<negócio>>ItemDeVenda
QtdeVendida
<<negócio>>VendaAPrazo
1 1..*
é composta de
*
1
corresponde
*
1
é realizada por
1..*
1
é realizada para
1 1..*
compreende
Programação Orientada a Objetos
Exemplo de modelo de classes
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
109
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.
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
110
Programação Orientada a Objetos
É uma proteção adicional dos dados do objeto de possíveis modificações impróprias,
forçando o acesso a um nível mais baixo para tratamento do dados.
Operações/métodos/interface
pública
Dados/Atributos/propriedades
privada
Encapsulamento (“data hiding”)Encapsulamento é definido como uma técnica para minimizar dependências entre
“módulos” através da definição de interfaces externas. Também conhecido como:
O fenômeno da “caixa preta”
Encapsulamento
public class Empregado {
private double salario;
public Empregado(){
salario=0.00;
}
public double getSalario(){
return this.salario;
}
}
O atributo salario somente poderá ter
um valor atribuído ou alterado,
através de método público.
Através do método getSalario, que
tem modificador public, podemos
manipular ou recuperar o valor do
atributo salario.
Classe Empregado e método
getSalario
O atributo salario
private double salario;
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
111
Programação Orientada a Objetos
A interface (pública) de um objeto declara todas as operações permitidas (métodos)
Todo o acesso aos dados do objeto é feito através da chamada a uma operação (método)
da sua interface.
Encapsulamento - Benefícios
- Segurança:
Protege os atributos dos objetos de terem seus valores corrompidos por outros
objetos.
- Independência:
“Escondendo” seus atributos, um objeto protege outros objetos de complicações de
dependência de sua estrutura interna
Encapsulamento
public class Gerente1 extends Empregado {
private double bonus = .15;
public double getSalario(){
//referência ao método getSalario
return super.getSalario() +
(super.getSalario()*this.bonus);
}
}
public class Empregado {
public Empregado(){
salario=0.00;
}
public double getSalario(){
return this.salario;
}
}
private double salario;
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
112
Definição:
“Polimorfismo” é uma operação que pode assumir múltiplas formas, a propriedade
segundo o qual uma operação pode comportar-se diferentemente em classes diferentes”
(Rumbaugh)
O polimorfismo é o responsável pela extensibilidade em programação orientada a objetos.
Polimorfismo
overloading
overriding
Overloading:
Possibilidade de reúso do nome do método para diferentes implementações, em tempo de
execução, a aplicação, escolherá o método adequado para cada chamada, veja o
exemplo.
TesteSoma Soma
somar(int a, int b)
somar(float a, float b)
somar(char a, char b)
somar(long a, long b))
Para cada tipo de dados existe um método, o reúso do nome do método é permitido,
entretanto a lista de argumentos deve ser diferente, veja o exemplo acima: o método
somar é definido várias vezes, entretanto com a lista de argumentos diferente, desta
forma evitaremos problemas como ambigüidade.
Programação Orientada a Objetos
Polimorfismo
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
113
public class EmpregadoExemplo {
private double salario;
public void setSalario(int diastrabalhados,
double valorhora ){
this.salario = diastrabalhados *
valorhora * 8;
}
public double getSalario(){
return this.salario;
}
}
public class Engenheiro extends
EmpregadoExemplo {
public static void main(String args[])
{
Engenheiro eng = new Engenheiro();
eng.setSalario(22, 35.00);
System.out.println(eng.getSalario());
}
}
O método setSalario é herdado da Superclasse (Empregado), entretanto para cada cargo
(tipo de empregado) ele tem uma implementação diferente. Por exemplo:
- Para Engenheiro e Secretária salário = (Dias Trabalhados x Valor hora)
- Para Gerente salário = (Dias Trabalhados x Valor hora) + Bônus
- Para Diretor salário = (Dias Trabalhados x Valor hora) + Bônus + Participação nos
lucros.
Overrinding - Exemplo:
Empregado
setSalario()
getSalario()
Engenheiro
getSalario()
Gerente
getSalario()
Diretor
getSalario()
Secretária
getSalario()
Programação Orientada a Objetos
Polimorfismo
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
114
O método setSalario (continuação)
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;
}
}
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);
}
}
Programação Orientada a Objetos
Polimorfismo
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());
}
}
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
115
Programação Orientada a Objetos
Overrinding
Uma subclasse pode mudar o comportamento herdado da Superclasse, ou seja, um método
herdado poderá ser alterado. Veja o exemplo abaixo:
O método getSaldo é herdado da Superclasse (Conta Bancária), entretanto para cada
tipo de Conta ele tem uma implementação diferente. Por exemplo:
- Para apurar o saldo da Conta Corrente saldo atual = (soma dos depósitos + saldo
anterior) - saques
Para a conta poupança seria saldo atual = (soma dos depósitos + saldo anterior + juros)
- saques
Para a conta de investimentos seria saldo atual = (soma dos aplicações + saldo anterior
+ juros) - resgates - ir
Conta Bancária
getSaldo()
Conta Corrente
getSaldo()
Conta Poupança
getSaldo()
Investimentos
getSaldo()
Exercício:
Faça a implementação das classes acima.
Polimorfismo
As subclasse podem modificar o comporamento de método herdado da super classe,
entretanto temos que seguir algumas regras:
- Manter o mesmo nome do método
- Manter o mesmo tipo de retorno
- Manter a lista de argumentos.
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
116
Acessibilidade
Acessibilidade ou Visibilidade
Os níveis de controle tem o seguinte papel de tornar um atributo, um método ou classe
visível ou não.
Exemplo:
Se um atributo foi declarado dentro de uma classe chamada TestA e este atributo tem o
nível de controle private. Somente esta classe poderá fazer acesso a este atributo, ou seja,
somente classe TestA o enxergará, todas as demais, não poderão fazer acesso direto a
este atributo.
public class TestA {
private int a=1;
}
Para contornar a situação poderíamos fazer duas coisas, a primeira: alterar o nível de
controle do atributo a, na classe TestA, para public, desta forma a classe TestB o
enxergaria. Todavia, as boas práticas de programação não recomendam fazer isto.
A segunda: é uma maneira mais elegante de resolvemos o problema, podemos criar
métodos públicos na classe TestA, por exemplo, getA e setA, aí sim, através destes
métodos seria possível manipular o atributo da classe TestA.
public class TestB extends
TestA{
private int b=a;
}
TestB.java:3: a has private access in TestA
private int b=a; ^
A linguagem Java tem para os atributos e métodos quatro níveis de controles: public,
protected, default e private.
Para classes tem dois níveis: public e default (também chamado de pacote ou de friendly).
Este níveis de controle são os responsáveis pela acessibilidade ou visibilidade de atributos,
e métodos.
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
117
Acessibilidade
Acessibilidade ou Visibilidade
public class
public sublass
Exemplos:
class
public sublass
protected class
public sublass
public default protected
A tabela abaixo demonstra a acessibilidade para cada nível de controle
Modificador Mesma
Classe
Mesmo
Package
SubClasse Universo
Public sim sim sim sim
Protected sim sim sim não
Private sim não não não
Default sim sim não não
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
118
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
119
Programação Orientada a Objetos
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');
if (obarray[3] instanceof Character)
{
System.out.println("Character");
}
}
}
Instanceof
O operador instanceof é usado para identificar qual é o tipo do objeto esta “instanciado”.
Verifica qual é
objeto que está
contido na terceira
posição do obarray
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
120
Exceções
Exception
O que são exceções ?
Exceções em Java são anomalias que podem acontecer durante a execução de um
programa. Existem diversos tipos de exceções, desde erros de sintaxes até falha de
equipamento, como, erro de leitura e gravação.
Para o tratamento de exceções, usamos as declarações try, catch e finally.
A declaração try indica a parte do código aonde poderá ocorrer uma exception,
Já a declaração catch faz a captura da exceção, caso venha a ocorrer.
A declaração finally, que é opcional, é utilizada para definir novo bloco de instruções
ou finalizar objetos que estão abertos, por exemplo, conexões. A execução desta
declaração é independente, da declaração catch, ou seja, mesmo que não aconteça
nenhuma exceção os comandos e/ou instruções dentro da declaração finally serão
executados.
Exemplo:
try {
// código que pode ocasionar uma exception
}
catch(Classe Exceção objeto exceção)
{
// tratamento do erro
}
finally {
// código
}
ou
try {
// código que pode ocasionar uma exception
}
catch(Classe Exceção objeto exceção)
{
// tratamento do erro
}
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
121
Exceções
Estruturas básica das classes de exceção:
Exception
Throwable
Exception Error
IOException RuntimeException
EOFException FileNotFoun
ExceptionArithmeticException
NullPointerException
IndexOfBoundException
AWTError JVMError
Exceptions mais comuns:
ArithmeticException - int i = 12 / 0
NullPointerException - ocorre quando um objeto não foi instanciado.
NegativeArraySizeException - ocorre quando é atribuído um valor nulo para um array.
ArrayIndexOutOfBoundsException - ocorre quando foi violado o índice do array, ou
seja, elemento não existe.
Categorias de Exceptions:
Existem três grandes categorias de exceções em Java. De fato, a classe
Java.lang.Throwable age como uma classe pai , para que todos os objetos disparados
possam ser capturados pela declaração catch.
Podemos usar a classe Throwable, para tratar as exceções, entretanto, existe uma
subclasse que tratam erros específicos, por exemplo:
- Exception, IOEception, SQLExceptoion, RuntimeException assim por diante
Para maiores detalhes devemos consultar a documentação.
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
122
Exceções
Exception
Declare ou Manipule as Exception:
Na construção de um código, o desenvolvedor deve prever maneira para tratar possíveis
erros. Existem duas formas de fazer isto. A primeira é com o uso da declaração try e
catch, como foi visto anteriormente, e a segunda maneira é indicando que a exceção
não é dirigida para este método, neste caso usamos a palavra reservada throws para
que jogará a exceção para o método chamador.
Sintaxe:
throws <classe de exceção>
Exemplo:
public void troublesome( ) throws IOException
public class TestThrows
{
public static void main(String args[])
{
try
{
new TestThrows().divisao(10,0);
}
e.printStackTrace();
{
System.out.println("Deu erro " + e);
}
}
public void divisao(int d1, int d2) throws ArithmeticException
{
System.out.println("Divisao: " + d1/d2);
}
}
Criando uma Exception
É permitido que o desenvolvedor crie suas próprias classes de exceção.
Cria uma trilha da
ocorrência da exceção
Lança a exceção
para o método main
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
123
Exceções
Exception
Exemplo:
public class ExceptionExemplo
{
public static void main (String args[ ])
{
int status = 0;
String greetings [ ] = { "Hello word" ,
"No, I mean it!", "HELLO WORLD!"};
try {
for(int i=0; greetings.length > i;i++)
System.out.println(greetings[i]);
}
catch(ArrayIndexOutOfBoundsException e)
{
System.out.println("Exceção: " + e);
status = 1;
}
finally
{
System.exit(status);
}
}
}
Implementação
do tratamento
de exceção
Neste exemplo o código funciona perfeitamente, entretanto a implementação do
controle de exceção, cumpre seu papel, de prevenção a falhas.
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
124
Exceções
Exception
Exemplo:
public class ExceptionBadExemplo
{
public static void main (String args[ ])
{
int status = 0;
String greetings [ ] = { "Hello word" ,
"No, I mean it!", "HELLO WORLD!"};
try {
for(int i=0; 4 > i;i++)
System.out.println(greetings[i]);
}
catch(ArrayIndexOutOfBoundsException e)
{
System.out.println("Exceção: " + e);
status = 1;
}
finally
{
System.exit(status);
}
}
}
Implementação
do tratamento
de exceção
Hello word
No, I mean it!
HELLO WORLD!
Exceção: java.lang.ArrayIndexOutOfBoundsException
Neste segundo exemplo forjamos um erro na instrução for ( o valor colocando na
condição é maior que o índice do array), isto resulta em uma exceção, que foi
devidamente capturada, pela instrução catch, e tratada veja abaixo:
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
125
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;
import java.text.NumberFormat;
public class DecimalFormat1 {
public static void main(String args[]) {
//Cientifico
DecimalFormat df = new DecimalFormat("0.000E0000");
System.out.println( df.format(1234.56));
//Percentual
NumberFormat nf = NumberFormat.getPercentInstance();
System.out.println(nf.format(0.67));
}
}
67%
Os valore
serão
exibidos no
seguinte
formato:
1,235E000
3
Mascara
Instancia
Observe que o ponto indica a separação decimal e virgula a separação de milhar
Principais símbolos:
Símbolo Significado
0 Representação o valor 0
# Representação qualquer valor
, (virgula) Separação de milhar
. (ponto)_ Separação de decimal
- Representação valores negativos
; Separador de mascara, por exemplo: quando
uma mesma mascara de duas formatações:
###.##;(00.##)
$ Representação de valores monetários
Características Avançadas
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
126
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;
import java.text.NumberFormat;
public class DecimalFormatMask {
public static void main(String args[]) {
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));
df.applyPattern("#,###.00");
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));
}
}
Características Avançadas
APIs
O valor sem formatação
Criando máscaras e a
impressão do valor
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
127
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)
Características Avançadas
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
128
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()));
}
}
Características Avançadas
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
129
Constantes
Características Avançadas
Para declarar uma variável, um método, um bloco ou até mesmo uma classe como
constante usamos o modificador final.
Entretanto, o uso deste modificador deve obedecer a certas restrições como:
• Uma classe constante não pode ter subclasses;
• Um método constante não pode ser sobrescrito;
• O valor para variável constante deve ser definido no momento da declaração ou através
de um construtor, para variáveis membro, uma vez atribuído o valor, este não mudará
mais.
public final class TestFinalPai
{
private final int VALOR;
public TestFinalPai(int V)
{
VALOR = V;
}
}
public class TestFinalFilho extends TestFinalPai
{
public TestFinalFilho() {
super(10);
}
public static void main(String args[])
{
}
}
TestFinalFilho.java:1: cannot inherit from final TestFinalPai
public class TestFinalFilho extends TestFinalPai
Veja o exemplo:
Quando compilamos
a classe um erro é gerado
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
130
Constantes
Características Avançadas
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.
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
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
131
Threads
t1
Execução
t3 t5 t2
fila
T1.start()
Características Avançadas
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.
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
132
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
ms)
Suspende a execução de uma Thread pelo tempo
especificado, o tempo é um valor em milisegundo.
Principal vantagem: Economiza processamento de CPU.
Aplicação: Controle Diversos, processo de sincronização
etc
static void yield() Suspende a execução da Thread corrente e dá a
oportunidade de execução para a próxima Thread da fila
de execução de mesma prioridade.
boolean isAlive() Verifica se a Thread está ativo (se foi iniciada e ainda
seu processamento não terminou). Não importa se a
Thread está em execução ou não.
Prioridades:
Método Descrição
setPriority() Ajusta o valor da prioridade da Thread
getPriority() Pega o valor prioridade da Thread
Obs: Podemos usar os valores constantes:
Thread.MIN_PRIORITY, Thread.NORM_PRIORITY, Thread.MAX_PRIORITY,
Exemplo:
...
public int total(int valor) {
synchronized (this) {
valorTotal += valor;
}}
Características Avançadas
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.
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
133
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)
Características Avançadas
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.
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
134
Threads
Características Avançadas
public class TestThread {
public static void main(String args[]) {
Xyz r = new Xyz();
Thread t = new Thread(r);
t.start();
}
}
class Xyz implements Runnable {
int i;
public void run() {
i = 0;
while (true) {
System.out.println("Hello " + i++);
if ( i == 50 ) break;
}
}
}
Este exemplo demonstra a implementação de uma Thread simples
“instance” da
Thread
O método start()
solicita a execução
da Thread
A interface Runnable é responsável pelos
métodos run()
No método run() é
implementado o
corpo do método
Corpo do
método run()
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
135
Threads
Características Avançadas
public class TestThread1 {
public static void main(String args[]) {
Xyz r = new Xyz();
Thread t1 = new Thread(r);
Thread t2 = new Thread(r);
t1.start();
t2.start();
}
}
class Xyz implements Runnable {
int i;
public void run() {
i = 0;
for(;;) {
System.out.println(Thread.currentThread());
System.out.println(i++);
if (i == 50) break;
}
}
}
Este exemplo é parecido com anterior, entretanto, agora é demonstrado a execução de
duas Threads.
“instances” da Thread
O método start()
solicita a execução
das Threads
A interface Runnable é responsável pelos
métodos run()
No método run() é
implementado o
corpo do método
Corpo do
método run()
é a parte do
código que será
repetido
Retorna a referência
da Thread corrente
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
136
Threads
Características Avançadas
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());
t0.setPriority(Thread.MAX_PRIORITY);
t0.start();
System.out.println("Prioridade t1 " + t0.getPriority());
System.out.println("----------------------------------");
t1.setPriority(Thread.MIN_PRIORITY);
t1.start();
System.out.println("Prioridade t1 " + t1.getPriority());
System.out.println("----------------------------------");
}
}
class TestPrior implements Runnable {
int i;
public void run() {
i = 0;
try {
for(;;) {
Thread.sleep(5);
System.out.println(Thread.currentThread());
System.out.println(i++);
if ( i == 50 ) break;
}
}catch(Exception e) {
}
}
}
Prioridades: Usamos
o método setPriority para
definir e getPriority para
saber qual é a prioridade
da Thread
Para usar:
O método sleep(),
somos forçados
usar o controle
de exceção: try-catch
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
137
Threads
Características Avançadas
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;
try {
for(;;) {
Thread.yield();
System.out.println(Thread.currentThread());
System.out.println(i++);
if ( i == 50 ) break;
}
}catch(Exception e) {}
}
}
Este exemplo mostra a funcionalidade do método yield().
Suspende a execução da Thread
corrente e dá a oportunidade de
execução a próxima Thread da fila
de execução de mesma prioridade.
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
138
Threads
Características Avançadas
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();
}}
Este exemplo é divido em duas partes. A primeira parte não implementa o recurso de
sincronismo.
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
139
Threads
Características Avançadas
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
{ Thread.sleep(5); }
catch(Exception err)
{ System.err.println("Erro: " + err); }
if (Thread.currentThread().getName().equals("deb"))
{
saldo -= 1;
}
else
{
saldo += 1;
}
System.out.println(Thread.currentThread().getName() + " Saldo: " + saldo);
}
}}
Implementação
do sincronismo
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
140
Serialization
Características Avançadas
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;
}
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
141
Serialization
Características Avançadas
import java.io.*;
import java.util.*;
public class TestSerializeVector {
TestSerializeVector()
{
Vector v = new Vector();
for(int x=0;x<5;x++)
v.addElement(new Integer(x));
try {
FileOutputStream f = new FileOutputStream ("vector.ser");
ObjectOutputStream s = new ObjectOutputStream (f);
s.writeObject (v);
s.close ();
} catch (IOException e) {
e.printStackTrace ();
}
}
public static void main (String args[]) {
new TestSerializeVector();
}
}
Este exemplo é divido em duas partes. A primeira exibe como gravar um objeto em
arquivo. Gravar objeto vetor no arquivo Vector.ser
Os dados do
objeto
Gravação
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
142
Serialization
Características Avançadas
import java.io.*;
import java.util.*;
public class TestUnSerializeVector {
TestUnSerializeVector () {
Vector v = null;
Object obj = null;
try {
FileInputStream f = new FileInputStream ("vector.ser");
ObjectInputStream s = new ObjectInputStream (f);
System.out.println(s);
v = (Vector) s.readObject ();
s.close ();
} catch (Exception e) {
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();
}
}
A segunda parte demonstra como recuperar o objeto e os dados gravados em um
arquivo. Nome do arquivo Vector.ser (objeto vector)
Recuperação
Note que é
necessário fazer
a coerção de tipo
(Vector)
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
143
Serialization
Características Avançadas
import java.io.*;
import java.util.Date;
import java.util.*;
public class TestSerialize {
public void doSerialize()
{
try
{ FileOutputStream ostream = new FileOutputStream("dados.ser");
ObjectOutputStream p = new ObjectOutputStream(ostream);
p.writeInt(12345);
p.writeObject("Today");
p.writeObject(new Date());
p.flush();
ostream.close();
} 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);
istream.close();
System.out.println("String: " + today);
System.out.println("Date: " + date);
System.out.println("int: " + i);
} catch (Exception e) {
e.printStackTrace ();
}
}
TestSerialize()
{ doSerialize();
unDoSerialize();
}
public static void main(String args[])
{
new TestSerialize();
}
}
Gravação
Recuperação
Para cada tipo
de dados foi
usado o método
apropriado.
Objeto = readObject
Int = readIn
Este exemplo mostra como
criar um método para fazer
a gravação e outro para
fazer a recuperação.
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
144
TCP/IP
Características Avançadas
Servidor
ServerSocket(port #)
ServerSocket.accept()
Sockect()
(Fluxo de Mensagens)
InputStream
OutputStream
Socket.close()
Cliente
ServerSocket(host,
port #)
(tentativa de
conexão)
(Fluxo de Mensagens)
InputStream
OutputStream
Socket.close()
TCP/IP Socket Connections
API java.net possiblita a implementação de Datagram Sockets e Stream Sockets. Com
Soquetes de Fluxo, podemos estabelecer conexão entre um cliente e servidor, enquanto
perdurar a conexão podemos trocar mensagens, este fluxo de mensagem é controlado,
casa haja algum problema entre as mensagens enviadas e recebidas, elas podem ser
corrigidas. Este serviço é chamado orientado a conexão, o protocolo utilizado é TCP.
Já os Soquetes Datagramas, as mensagens são transmitidas em pacotes, entretanto, o
fluxo de troca de mensagens não são controlados, isto quer dizer, que eles podem ser
perdidos (nunca chegar ao seu destino, por exemplo) entre outras coisas. Este serviço é
chamado serviço sem conexão, o protocolo utilizado é UDP.
Abaixo um esquema válido para Serviço orientada a conexão (TCP)
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
145
TCP/IP
Principais métodos:
Métodos Descrição
ServerSocket(port #,
number clientes)
Estabelece a porta em que um servidor espera a
conexão. O segundo parâmetro para o construtor
é quantidade de clientes que podem esperar uma
conexão e ser processada pelo servidor, se as
filas estiverem repletas, as conexão são
recusadas automaticamente.
accept Espera o estabelecimento de uma conexão,
retorna o objeto socket (quando estabelecido uma
conexão)
sockets responsável pelo gerenciamento dos serviços
baseados em conexão.
close Fecha a conexão
setSoTimeout(int timeout) Estabele um timeout em milesegundos
public int getSoTimeout() Retorna o tempo estabelecido para timeout
Classe de Exceptions:SocketException
Características Avançadas
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
146
TCP/IP
Características Avançadas
import java.net.*;
import java.io.*;
public class TestServer {
public static void main(String args[]) {
ServerSocket s= null;
try {
s = new ServerSocket(5432);
} catch (IOException e) {
e.printStackTrace();
}
for (;;) {
try {
Socket s1 = s.accept();
OutputStream s1out = s1.getOutputStream();
DataOutputStream dos = new DataOutputStream(s1out);
// Envia a mensagem
dos.writeUTF("Hello Net World!");
dos.close();
s1.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
Exemplos:
Este exemplo é divido em duas partes. A primeira exibe como criar um Servidor.
API
Objecto
ServerSocket Número da Porta
Fluxo de Dados
Encerra a o fluxo
de dados e a
conexão
Espera o
estabelecimento
de conexão
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
147
TCP/IP
Características Avançadas
import java.net.*;
import java.io.*;
public class TestClient {
public static void main(String args[]) {
try {
// Endereço IP é Localhost
Socket s1 = new Socket("127.0.0.1", 5432);
InputStream is = s1.getInputStream();
DataInputStream dis = new DataInputStream(is);
System.out.println(dis.readUTF());
dis.close();
s1.close();
} catch (ConnectException connExc) {
System.err.println("Could not connect to the server.");
} catch (IOException e) {
e.printStackTrace();
}
}
}
Exemplos:
Este é segunda parte. A criação de um cliente.
Objeto Socket, veja
os parâmtros no Construtor
“”Endereço IP”
e “Número da Porta” do
Servidor
Fluxo de Dados
Leitura do Fluxo
API
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
148
TCP/IP
Características Avançadas
Cenário da Conexão Servidor e Cliente
TestServer TestClient
TCP/IP
129.1.13.1
IP
Porta
5432 Hello...
Mensagem
Fluxo de Dados
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
149
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
150
Introdução a UML
O Quê é a UML?
A UML (Linguagem de Modelagem Unificada) é uma linguagem-padrão para elaboração
da estrutura de projetos de software. A UML poderá ser usada para:
• Visualização
• Especificação
• Construção de modelos e diagramas
• Documentação.
A UML é adequada para a modelagem de sistemas, cuja a abrangência poderá incluir
sistemas de informação corporativos a serem distribuídos a aplicação baseadas em Web
e até sistemas complexos embutidos de tempo real.
A UML é apenas uma linguagem e, portanto, é somente uma parte de um método para
desenvolvimento de software. Ela é independente do processo, apesar de ser
perfeitamente utilizada em processo orientado a casos de usos, centrado na arquitetura,
iterativo e incremental.
• Diagrama de Caso de Uso
• Diagrama de Seqüência
• Diagrama de Colaboração
• Diagrama de Estados
• Diagrama de Classes
• Diagrama de objetos
• Diagrama de Atividades
• Diagrama de Componentes
• Diagrama de Distribuição
• Diagrama de Pacotes
Principais
Diagramas:
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
151
Casos de Uso
O que são Caso de Uso?
São diagramas de que permitem visualizar, especificar e documentar o comportamento
de um elemento. Esses diagramas fazem com que sistema, subsistemas e classes
fiquem acessíveis e compreensíveis, por apresentarem uma visão externa sobre como
esses elementos podem ser utilizados no contexto.
Definição:
Caso de Uso é uma descrição de um conjunto de seqüências de ações, inclusive
variantes, que um sistema pode produzir um resultado de valor observável por um ator.
A representação gráfica é uma elipse.
Elementos:
Ator:
Um ator representa um conjunto coerente de papéis que os usuários de casos de uso
desempenham quanto interagem com esses casos de uso. Geralmente um ator
representa um papel, que pode ser de pessoa, de um sistema ou de um dispositivo.
Cenários:
Podemos definir os cenários como uma “descrição” de um Caso de uso. O caso de uso
deve ser descrito através de cenários. Devem ser construídos tantos cenários quantos
forem necessários para se entender completamente todo o sistema. Podem ser
considerados como teste informais para validação dos requisitos do sistema.
Introdução a UML
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
152
Diagramas de Caso de Uso e Extensões
Professor
Selecionar curso
para ensinar
Pedir lista dos
matriculados
Gerenciar
Manter informação de
aluno
Manter informação de
professor
Gerar catalogo
Manter informações dos
cursos
Sistema de
cobrançaMatrícula nos
Cursos
Aluno
Casos de Uso
Generalização:
Entre casos de uso é parecida à generalização existente entre as classes.
No caso de uso a generalização significa que o caso de uso filho herda o
comportamento e o significado do caso de uso pai; o filho poderá acrescentar ou
sobrescrever o comportamento de seu pai; poderá ser substituído em qualquer
local qual o pai apareça.
Include:
Quando você estiver se repetindo em dois ou mais caso de uso separados,
devemos evitar a repetição
Extends:
Quando estivermos descrevendo uma variação em comportamento normal,
entretanto, querendo fazer uma descrição mais controlada, explicando os pontos
de extensão no caso de uso.
Realizes:
Especifica a colaboração entre os casos de uso
Use (obsoleto): Especifica que a semântica do elemento de origem depende da
semântica da parte pública do destino
Introdução a UML
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
153
Diagrama de Seqüência
O que é Diagramas de Seqüência?
É um diagrama que exibe a colaboração dinâmica entre os vários objetos de um sistema.
O principal aspecto deste diagrama é que a partir dele percebe-se a seqüência de
mensagens enviadas entre os objetos. Ele mostra a interação entre os objetos, alguma
evento que acontecerá em um ponto específico da execução do sistema.
formulários
de registro
formulário
de matrícula
cursos
disponíveis
Ator (José) entrar com chave de
acessovalidar acesso
entrar com o
semestre
criar nova matrículaapresentar em tela
obter cursos
Diagrama de Seqüência
Introdução a UML
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
154
Diagrama de Colaboração
O que é Diagramas de Colaboração?
É um diagramas que mostra a colaboração dinâmica entre os objetos, semelhante ao
diagrama de seqüência. No diagrama de colaboração, além de mostrar a troca de
mensagens entre os objetos, percebe-se também os objetos com os seus
relacionamentos. A interação de mensagens é mostrada em ambos os diagramas. Se a
ênfase do diagrama for o decorrer do tempo, é melhor escolher o diagrama de seqüência,
mas se a ênfase for o contexto do sistema, é melhor dar prioridade ao diagrama de
colaboração. Podemos também escolher ambos.
O diagrama de colaboração é desenhado como um diagrama de objeto, onde os diversos
objetos são mostrados juntamente com seus relacionamentos. As setas de mensagens
são desenhadas entre os objetos para mostrar o fluxo de mensagens entre eles. As
mensagens são nomeadas, que entre outras coisas mostram a ordem em que as
mensagens são enviadas. Também podem mostrar condições, interações, valores de
resposta e etc. O diagrama de colaboração também pode conter objetos ativos, que
executam paralelamente com outros.
6:obter cursos
Ator (José)
formulários de registro
2: validar acesso
1:entrar com chave
de acesso3:entrar com o
semestre
4:criar nova matrícula
formulário de matrículacursos disponíveis
5:apresentar
em tela
Diagrama de Colaboração
Introdução a UML
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
155
Diagrama de Estado
O que é Diagrama de Estado?
É um diagrama que tipicamente complementa a descrição das classes. Pois este
diagrama exibe todos os estados possíveis que objetos de uma certa classe podem se
encontrar. E mostra também quais são os eventos do sistemas que provocam tais
mudanças.
Não necessário escrever o diagrama de estado para todas as classes de um sistema,
mas apenas para aquelas que possuem um número definido de estados conhecidos e
onde o comportamento das classes é afetado e modificado pelos diferentes estados.
Diagramas de estado capturam o ciclo de vida dos objetos, subsistemas e sistemas.
Eles mostram os estados que um objeto pode possuir e como os eventos (mensagens
recebidas, tempo, erros, e condições sendo satisfeitas) afetam estes estados ao passar
do tempo.
Registro fechado
[númeroDeAlunos<3]
cancelarCurso�
cancelarCursocancelarCurso
Registro fechado
[númeroDeAlunos>=3
]
Registro fechado [número
de alunos =10]^Curso
.Criar relatório
Matrícula aberta/inicialize
númeroDeAlunos = 0
Curso Completado
faça: Gerar lista de
alunos
Criação
faça: Crie o
objeto curso
Atribuição Cursofaça: Atribuir um
professor ao curso
Curso Aberto
Entrada: Registre
um aluno
Adicionar Aluno
Curso Encerrado
faça: relate cursoesta cheio
Curso Cancelado
faça: envie notificação
de cancelamento
cancelarCurso�
Introdução a UML
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
156
Diagrama de Atividade
O que é Diagrama de Atividade?
É um diagramas que exibe o fluxo seqüencial das atividades, é geralmente utilizado para
demonstrar as atividades executadas por uma operação específica do sistema, como por
exemplo seleção de um item do menu principal. Consistem em estados de ação, que
contém a especificação de uma atividade a ser desempenhada por uma operação do
sistema. Decisões e condições, como execução paralela, também podem ser mostrados
na diagrama de atividade. O diagrama também pode conter especificações de
mensagens enviadas e recebidas como partes de ações executadas.
Diagramas de atividade capturam ações e seus resultados. Eles focam o trabalho
executado na implementação de uma operação (método), e suas atividades numa
instância de um objeto. O diagrama de atividade é uma variação do diagrama de estado e
possui um propósito um pouco diferente do diagrama de estado, que é o de capturar
ações (trabalho e atividades que serão executados) e seus resultados em termos das
mudanças de estados dos objetos.
Fazer Pedido
Cliente
Processar Pedido
Separar Produtos
Enviar Pedido
Cobrar Cliente
Fechar Pedido
Receber Pedido
Pagar Fatura
Vendas Estoque
Introdução a UML
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
157
Diagrama de Pacotes
Como podemos definir o diagrama de pacotes?
A definição de Pacote é uma generalização, ou seja, um agrupamento, com o propósito de
organizar as Classes de Objetos em grupos. Esta abordagem facilita a análise a medida
que o número de Classes de Objetos cresce num do cenário. O tipo de relacionamento é
linha pontilhada com uma seta que indica dependência.
A notação usada pela UML para representar pacotes é:
Nome do Pacote
Exemplo: As classes pertencentes ao Sistema de Matrícula podem ser agrupadas em três
pacotes:
• UI (Interface com usuário)
• Regras de Negócio
• Interfaces de Banco de Dados
Interfaces de
Banco de Dados
{abstrata}
Interfaces com
UsuárioRegras de
Negócios
Interface
Oracle
Interface
MySQL
Introdução a UML
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
158
Diagrama de Classes
O que é um Diagrama de Classes?
É um diagrama que demonstra a estrutura estática das classes de um sistema e seus
relacionamentos. Classes podem se relacionar com outras através de diversas maneiras:
associação (conectadas entre si), dependência (uma classe depende ou usa outra classe),
especialização (uma classe é uma especialização de outra classe), ou em pacotes
(classes agrupadas por características similares). Todos estes relacionamentos são
mostrados no diagrama de classes juntamente com as suas estruturas internas, que são
os atributos e operações. O diagrama de classes é considerado estático já que a estrutura
descrita é sempre válida em qualquer ponto do ciclo de vida do sistema. Um sistema
normalmente possui alguns diagramas de classes, já que não são todas as classes que
estão inseridas em um único diagrama e uma certa classes pode participar de vários
diagramas de classes.
1..*
1
1
tem
Professores
Pessoa
AlunosFuncionários
Administrativo
Curso
Disciplinas
Matricula11
1
Uma classe num diagrama pode ser diretamente implementada utilizando-se uma
linguagem de programação orientada a objetos que tenha suporte direto para
construção de classes. Para criar um diagrama de classes, as classes têm que estar
identificadas, descritas e relacionadas entre si.
Introdução a UML
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
159
Diagrama de Objetos
O que é um Diagrama de Objetos?
É um diagrama que exibe uma variação do diagrama de classes e utiliza quase a mesma
notação. A diferença é que o diagrama de objetos mostra os objetos que foram
“instanciados” das classes. O diagrama de objetos é como se fosse o perfil do sistema em
um determinado momento de sua execução. A mesma notação do diagrama de classes é
utilizada, entretanto há duas diferenças: os objetos são escritos com seus nomes
sublinhados e todas as instâncias num relacionamento são mostradas. Os diagramas de
objetos não tem a mesma importância do diagramas de classes, mas eles são muito úteis
para exemplificar diagramas complexos de classes ajudando muito em sua compreensão.
Diagramas de objetos também são usados como parte dos diagramas de colaboração,
onde a colaboração dinâmica entre os objetos do sistema são mostrados.
Nome: “Fulano de Tal”
Data: 23-02-2001
:Aluno
Matricula: 201-23-02-01
Curso: Adm Empresas
201-23-02-01:Matricula
Introdução a UML
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
160
Diagrama de Componente
O que é um Diagrama de Componente?
É um diagrama que exibe o sistema por um lado funcional, expondo as relações entre
seus componentes e a organização de seus módulos durante sua execução.
O diagrama de componente descreve os componentes de software e suas dependências
entre si, representando a estrutura do código gerado. Os componentes são a
implementação na arquitetura física dos conceitos e da funcionalidade definidos na
arquitetura lógica (classes, objetos e seus relacionamentos). Eles são tipicamente os
arquivos implementados no ambiente de desenvolvimento.
Curso.jar Pessoa.jar
Aluno.class Professores.classDisciplina.classr
Introdução a UML
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
161
Diagrama de Distribuição
O que é Diagrama de Distribuição?
É um diagrama que exibe a arquitetura física do hardware e do software no sistema.
Pode apresentar os atuais computadores e periféricos, juntamente com as conexões que
eles estabelecem entre si e pode mostrar também os tipos de conexões entre esses
computadores.
Especifica-se também os componentes executáveis e objetos que são alocados para
mostrar quais unidades de software são executados e em quais computadores são
executados.
O diagrama de distribuição demonstra a arquitetura “runtime” de processadores,
dispositivos físicos e de software que executam no ambiente onde o sistema
desenvolvido será utilizado. É o último diagrama da topologia do sistema, descrevendo
a estrutura de hardware e software que executam em cada unidade.
O diagrama de distribuição é composto por componentes, que possuem a mesma
simbologia dos componentes do diagrama de componentes, nodes, que significam
objetos físicos que fazem parte do sistema, podendo ser uma computador cliente em
uma Rede, um computador Servidor, uma impressora, um roteador, etc., e conexões
entre estes nodes e componentes que juntos compõem toda a arquitetura física do
sistema.
Cliente AServidor
de Aplicação
Servidor
de Banco de
Dados
<<TCP/IP>><<TCP/IP>>
0..* 1 1 1
Introdução a UML
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
162
Transformando modelos UML
em código Java
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
163
Implementação Java
Transformando diagramas UML em código Java
import java.awt.Graphics;
public class Hello extends java.applet.Applet
{
public void paint(Graphics g)
{
g.drawString("Hello", 15,15);
}
}
Nossa proposta é apresentar o mais simples exemplo de aplicação UML e Java, por
isso, não temos intenção de esgotar o tema UML.
Nosso exemplo é um velho conhecido, o programa Hello. Bem vamos começar pela
implementação do código e depois faremos uma engenharia reversa para obtermos os
diagramas e demais itens UML. Veja os passos abaixo:
public class
Tapplet
extends
Applet {
}
Código fonte
(java)Bytcode
(java)
Compilação
<HTML>
<body>
..
</body>
</HTML>
Arquivo
HTML
12
3
4
O programa Java
1
Primeiro Passo:
Criação do programa Java,
um Applet.
Segundo Passo:
Compilar o programa
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
164
Implementação Java
<HTML>
<CAPTION>Hello</CAPTION>
<TR><TD>
<APPLET CODE="Hello.class" WIDTH=100 HEIGHT=100>
</APPLET>
</TD></TR>
</HTML>
A página HTML, Hello.html
3
4
A execução
Terceiro Passo:
Criação a página HTML,
o nome será Hello.html.
Para encerrar Quarto Passo:
Execução do programa, podemos
usar o Browser, mas neste caso usamos o
AppletViewer, que é utilitário Java, que
que exibe Applet, a partir de páginas HTML
Bem agora vamos para segunda parte, que é a modelagem dessa aplicação usando
UML.
Transformando diagramas UML em código Java
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
165
Modelagem UML
A Modelagem UML. Do programa Hello:
Hello
paint()g.drawString
(“Hello”, 15, 15)
O programa Hello pode ser representado graficamente pela figura acima, é claro que foi
omitido os detalhes e a implementação do método paint é feito através de nota
Hello
paint() Graphics
Applet
Agora temos um modelo de fato, veja os relacionamentos (herança e navegação) entre
as classes e a definição do método paint. O exemplo abaixo faz um mapeamento entre
o código Java e modelo UML.
Hello
paint() Graphics
Applet
import java.awt.Graphics;
public class Hello extends java.applet.Applet
public void paint(Graphics g)
{
g.drawString("Hello", 15,15);
}
Transformando diagramas UML em código Java
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
166
Modelagem UML - Pacotes
Transformando diagramas UML em código Java
java org sunjavax
Bem como já dissemos, (Veja Miscelania - Pacotes) a linguagem Java é estruturada em
pacotes, estes pacotes contém classes que por sua vez contém atributos e métodos.
Podemos usar a estrutura de pacotes para associar classes com semânticas semelhante,
ou seja, classes que tem objetivo comum. Veja a estrutura abaixo:
applet awt
net
rmiiobeans
lang
math security
utiltextsql
As classes Applet
(pacote applet) e
Graphics (pacote) awt
que colaboram com
a classe Hello
Principais
pacotes
da Linguagem
Java
Principais
subpacotes
do pacote
Java
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
167
Modelagem UML
Transformando diagramas UML em código Java
java
awt
applet
lang
Hello
Modelagem UML - Pacotes
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:
import java.awt.Graphics;
public class Hello extends java.applet.Applet
{
public void paint(Graphics g)
{
g.drawString("Hello", 15,15);
}
}
appletawt
lang
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
168
Transformando diagramas UML em código Java
java
awt
applet
lang
Hello
AppletConte
xt
Applet
AppletStub
Panel(from awt)
Container(from awt)
Component(from awt)
AudioClip
Object(from lang)
Graphics....
abstract void drawString(AttributedCharacterIterator iterator, int x, int y)
abstract void drawString(String str, int x, int y)
....
Esta figura demonstra uma visão mais detalhada dos pacotes e as respectivas classes e
atributos.
Modelagem UML - Pacotes
Interface
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
169
Transformando diagramas UML em código Java
Podemos fazer a modelagem da ordenação de eventos usando uma Diagrama de
Sequência, Veja o diagrama logo abaixo. A sequência se inicia com a execução do
objeto Thread que, por sua vez,
1 - invoca o método run() de Toolkit.
2 - O objeto Toolkit então chama uma de seus próprios métodos, callbackloop() que,
a seguir, chama ...
3 - handleExpose de ComponentPeer.
4 - O objeto ComponentPeer então chama o método paint() de seu alvo. O objeto
ComponentPeer assume que seu atributo é um Component, (Hello) e assim o método
paint() é executado de forma polimorfica.
Modelagem UML - Diagrama de Seqüência
:Thread :Toolkit :ComponenPeer :target Hello
run
run callbackLoop
handleExposepaint
Diagrama de Seqüência
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
170
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 ClientePessoaFisica extends Cliente implements Pessoa
{
public ClientePessoaFisica()
{
setNome("Duke");
System.out.println("Nome: " + getNome());
System.out.println("Tem dependente: " + getDependente(0));
}
public boolean getDependente(int dependente)
{
return (dependente>0)?true:false;
}
}
public interface Pessoa
{
public boolean getDependente(int dependente);
}
public class Cliente
{
String nome;
public String getNome()
{
return this.nome;
}
public void setNome(String nome)
{
this.nome = nome;
}
}
public class ClientePessoaJuridica extends Cliente
{
public ClientePessoaJuridica()
{
System.out.println("Nome: " + getNome());
}
}
Implementação do
método assinado
na Interface Pessoa
Assinatura do método
Atributo
Métodos
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
171
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
172
Utilitários
JavaDoc (Documentação)
Opção Valor Descrição
-d path de saída Diretório onde será gerado os arquivos HTML
-sourcepath path Especifica o diretório raiz dos fontes ou dos Package
-public Documenta apenas variáveis e métodos públicos
-private Documenta todas as variáveis e métodos
Sintaxe: Javadoc [Opções] package/arquivo < package/arquivo>
Exemplo: javadoc MinhasClasses.class
Tags para Documentação: Usar: /** e */
Tag Declaração Class e
Interface
Construtor Método Atributo
@see Cria um link com outra
página HTMLX X X X
@deprecated Informa quais métodos
estão ultrapassadosX X X X
@author Nome do Autor X
@param Documenta o parametro X X
@throws
@Exception
Documenta Exceções X X
@return Documenta o returno (valor
e tipo)X
Javadoc
É uma utilitário do JDK que gera a documentação dos programas java, geralmente
em formato HTML.
Localização JDK1.X/BIN/Javadoc.
Sintaxe padrão: javadoc <arquivofonte.java>
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
173
usage: javadoc [options] [packagenames] [sourcefiles] [classnames]
[@files]
-overview <file> Read overview documentation from HTML file
-public Show only public classes and members
-protected Show protected/public classes and members
(default)
-package Show package/protected/public classes and
members
-private Show all classes and members
-help Display command line options
-doclet <class> Generate output via alternate doclet
-docletpath <path> Specify where to find doclet class files
-1.1 Generate output using JDK 1.1 emulating doclet
-sourcepath <pathlist> Specify where to find source files
-classpath <pathlist> Specify where to find user class files
-bootclasspath <pathlist> Override location of class files loaded
by the bootstrap class loader
-extdirs <dirlist> Override location of installed extensions
-verbose Output messages about what Javadoc is doing
-locale <name> Locale to be used, e.g. en_US or en_US_WIN
-encoding <name> Source file encoding name
-J<flag> Pass <flag> directly to the runtime system
Provided by Standard doclet:
-d <directory> Destination directory for output files
-use Create class and package usage pages
-version Include @version paragraphs
-author Include @author paragraphs
-splitindex Split index into one file per letter
-windowtitle <text> Browser window title for the documenation
-doctitle <html-code> Include title for the package index(first)
page
-header <html-code> Include header text for each page
-footer <html-code> Include footer text for each page
-bottom <html-code> Include bottom text for each page
-link <url> Create links to javadoc output at <url>
-linkoffline <url> <url2> Link to docs at <url> using package list at
<url2>
-group <name> <p1>:<p2>.. Group specified packages together in overview
page
-nodeprecated Do not include @deprecated information
-nosince Do not include @since information
-nodeprecatedlist Do not generate deprecated list
-notree Do not generate class hierarchy
-noindex Do not generate index
-nohelp Do not generate help link
-nonavbar Do not generate navigation bar
-serialwarn Generate warning about @serial tag
-charset <charset> Charset for cross-platform viewing of
generated documentation.
-helpfile <file> Include file that help link links to
-stylesheetfile <path> File to change style of the generated
documentation
-docencoding <name> Output encoding name
Javadoc
JavaDoc (Documentação)
Utilitários
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
174
JavaDoc (Documentação)
Utilitários
Este exemplo exibe como implementar as tags de documentação que serão usados
pelo utilitário Javadoc
import java.util.List;
/**
* @author YourName
* @version 2.0
*/
public class DocExemplo {
/** Declaração e atribuição de x. */
private int x;
/**
* This variable a list of stuff.
* @see #getStuff()
*/
private List stuff;
/**
* O construtor inicia a variavel x.
* @param int x
*/
public DocExemplo(int x) {
this.x = x;
}
/**
* Este método retorna algum valor.
* @throws IllegalStateException se nenhum retorno for encontrado
* @return A lista de valores
*/
public List getStuff()
throws IllegalStateException {
if ( stuff == null ) {
throw new java.lang.IllegalStateException("Erro, sem valor");
}
return stuff;
}
}
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
175
JavaDoc (Documentação)
Utilitários
Exemplo:
Para gerar a documentação digite o seguinte comando:
c:\jdk1.3\bin\javadoc.exe -version -author DocExemplo.java...
Depois chame a página principal “index.html” via Browser.
A figura acima é exemplo de documentação gerada pelo Javadoc.
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
176
Jar (Compactação, Agrupamento e Distribuiçã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.
Jar
É um utilitário do JDK que faz agrupamento de arquivos em único, um arquivo .jar,
geralmente com compressão. Localização JDK1.X/BIN/Jar. É usado também para
fazer a distribuição de aplicação.
Os arquivos Jar podem conter um aplicação inteira, por isso, ele é usado para fazer
distribuição de aplicações. Também é bastante usado com componente Javabeans e
Applet.
Utilitários
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
177
Esta classe Java requer um parâmetro
que deve ser passando na chamada
da classe, se o parâmetro não for
informado, isto provocará
uma exceção
JDB (debug)
É um utilitário do JDK, para fazer depuração de código. O primeiro passo é escrever
um programa em Java e depois aplicar o depurador de código. Principais comandos:
run (chama a máquina virtual),
cont (continução) e
quit ou exit (sai do JDB). Veja o exemplo abaixo:
Utilitários
public class Hello
{
public static void main (String arg [])
{ String s = "world";
System.out.println("Hello " + arg[0]);
}
}
O próximo passa é abrir uma janela “DOS”, chame o depurador jdb
<nomedoprograma> <enter>.
Então ferramenta será inicializada, veja abaixo toda a seqüência de depuração.
Por fim a exceção é localizada, ocorrerá na linha 5.
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
178
Javap (Desmontagem)
Javap
Faz a desmontagem de código ou descompilação. Sintaxe:
javap <opções> <classes>
Lista das principais opções:
Utilitários
public class Hello
{
public static void main (String arg [])
{
System.out.println("Hello”);
}
}
Código fonte, veja exemplo abaixo:
Código fonte
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.
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[]);
}
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
179
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
180
A - Convenção de Código no Java
B - Sistema de Codificação Unicode
C - Registrando Fonte de Dados
D - Notação UML
Apêndices
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
181
Apêndice A
Convenção de Código no Java
Classe - Os nome da classes devem um substantivo e ter a primeira letra
maiúscula o restante em minúsculo. Exemplo: public class Pessoa.
No caso de nome composto o primeiro e segundo nome deve começar com letras
maiúscula. Exemplo: public class PessoaFisica.
Não devemos usar espaço em branco para separa os nomes e nem usar o
sublinhado.
Interfaces - Seguir as mesmas regras para nome de classe
Métodos - Os nomes dos métodos podem ser verbos no infinitivo,
devendo ser escrito em letras minúscula. Exemplo: public int calcular.
Para nome composto usar a seguinte regra a o primeiro nome em minúsculo e a
primeira letra do segundo nome em maiúsculo, veja o exemplo: public int
calcularArea
Constantes - Nomes de constantes devem escritos em letras maiúsculas.
Exemplo: public static final VALOR
Atributos e Variáveis - Os nome dos atributos e/ou variáveis devem ser escritos
em letras minúsculas.
Controles de Estruturas: Através de { } (chaves);
*Espaços - Convencionou-se o uso de quatro espaços para indentações;
Comentários - Vide o capitulo sobre documentação
Para maiores detalhes veja:http://java.sun.com/docs/books/jls/index.html
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
182
Apêndice B
Sistema de Codificação Unicode
O que é Unicode?
Unicode é sistema de codificação que fornece um número único para cada
caracter, Não importa a plataforma, não importa o programa, não importa a língua.
Fundamentalmente, os computadores lidam com números. Gravam letras e outros caracteres na
memória designando um número para cada um deles. Antes de o Unicode ser inventado, havia
centenas de sistemas diferentes de codificação . Nenhum destes sistemas de codificação, no
entanto, poderia conter caracteres suficientes: por exemplo, a União Européia por si só requer vários
sistemas de codificação diferentes para cobrir todas a línguas. Mesmo para uma única língua como o
inglês não havia sistema de codificação adequado para todas as letras, pontuação e símbolos
técnicos em uso corrente.
Estes sistemas de codificação são também conflitantes entre si. Em outras palavras, dois
codificadores podem usar o mesmo número para dois caracteres diferentes ou usar números
diferentes para o mesmo caracter. Qualquer computador em particular (especialmente os servidores)
precisam suportar muitos codificadores diferentes; ainda assim toda as vezes que se passam dados
entre codificadores ou plataformas diferentes, estes dados sempre correm o risco de serem
corrompidos.
O Unicode está mudando tudo isso!
O Unicode fornece um único número para cada caracter, não importa a plataforma, não importa o
programa, não importa a língua. O Padrão Unicode tem sido adotado por líderes do setor de
informática tais como a Apple, HP, IBM, JustSystem, Microsoft, Oracle, SAP, Sun, Sybase, Unisys e
muitos outros. O Unicode é necessário para padrões modernos tais como o XML, Java, ECMAScript
(JavaScript), LDAP, CORBA 3.0, WML, etc. e é a maneira oficial de implementar o ISO/IEC 10646. É
suportado por muitos sistemas operacionais, todos os browsers modernos e muitos outros produtos.
O surgimento do Padrão Unicode Standard e a disponibilidade de instrumentos para suportá-lo está
entre as tendências recentes mais significativas das tecnológicas mundiais de software.
Incorporar o Unicode aos servidores de clientes, aplicações de faixas múltiplas e websites oferece
uma redução significativa nos custos quando comparado ao uso de conjuntos de caracteres legacy.
O Unicode possibilita que um único software ou website seja alvejado através de plataformas,
línguas e países múltiplos sem a necessidade de reengenharia. Isto permite com que dados sejam
transportados através de muitos sistemas diferentes sem que sejam corrompidos.
Mais informações: www.unicode.org
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
183
Apêndice C
Registrando Fonte de Dados
Para registrar um fonte de Dados no Windows98, clique iniciar, configurações,
painel de controle e selecione Fonte de Dados ODBC.
Selecione uma fonte de
dados, por exemplo MS
Access 97 Database e
pressione o botão Adicionar.
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
184
Apêndice C
Informe o nome
da fonte de dados.
Clicar no botão
Selecionar para
informar o
caminho onde ela
se encontra.
Para finalizar
clique em OK
Agora selecione o drive
Registrando Fonte de Dados
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
185
SÍMBOLO GRÁFICO NOMEDIAGRAMAS EM QUEAPARECE USUALMENTE
MODELO A QUEPERTENCEM
ASSOCIAÇÂO DEAGREGAÇÃO
Diagrama de Classes,Diagrama de Componentes.
Classes de Objetos
Componentes
ASSOCIAÇÂO DECOMPOSIÇÃO
Diagrama de Classes,
Diagrama de Componentes.
Classes de Objetos
Componentes
ASSOCIAÇÂO DEDEPENDÊNCIA
Diagrama de Casos de Uso,Diagrama de Classes,Diagrama de Componentes,Diagrama de Implantação.
Caso de Uso
Classes de Objetos
Componentes
Componentes
ASSOCIAÇÂO DEGENERALIZAÇÃO
Diagrama de Casos de Uso,
Diagrama de Classes.
Caso de Uso
Classes de Objetos
ASSOCIAÇÂOREGULAR
Diagrama de Casos de Uso,Diagrama de Classes,Diagrama de Componentes,Diagrama de Implantação.
Caso de Uso
Classes de Objetos
Componentes
Componentes
ATORDiagrama de Casos de Uso,Diagrama de Seqüência.
Caso de Uso
Caso de Uso
CASO DE USO Diagrama de Casos de Uso. Caso de Uso
CLASSE Diagrama de Classes. Classes de Objetos
COMPONENTE Diagrama de Componentes Componentes
Nome do EstadoESTADO
Diagrama de Estados,
Diagrama de Atividades.
Classes de Objetos
Caso de Uso
ESTADO FINAL
Diagrama de Estados,
Diagrama de Atividades
Classes de Objetos
Caso de Uso
Nome da Classe
Atributos
Operações
Nome do Componente
Apêndice D
Notação UML
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected])Rildo F Santos ([email protected])
186
ESTADO INICIALDiagrama de Estados,Diagrama de Atividades.
Classes de Objetos
Caso de Uso
Nome da “Interface” ou
“INTERFACE”Diagrama de Componentes Componentes
INTERVALO DEEXECUÇÃO DE
OPERAÇÂODiagrama de Seqüência Caso de Uso
MENSAGEM DERETORNO
Diagrama de Seqüência Caso de Uso
MENSAGEM ECHAMADA DEOPERAÇÂO“Síncrona”
Diagrama de Seqüência Caso de Uso
MENSAGEM ECHAMADA DEOPERAÇÃO“Assíncrona”
Diagrama de Seqüência Caso de Uso
NÓ Diagrama de Implantação Componentes
texto NOTA Em qualquer diagrama
identificador:Classe ou :Classe
OBJETODiagrama de Seqüência,
Diagrama de Atividades
Caso de Uso
Caso de Uso
Nome do Pacote PACOTE
Em qualquer diagrama em que énecessário representar umconjunto de coisas que devemestar agrupadas para efeito deuma organização apropriada
TRANSIÇÃO DEESTADO
Diagrama de Estados,
Diagrama de Atividades
Classes de Objetos
Caso de Uso
AUTODELEGAÇÃO Diagrama de Seqüência Caso de Uso
<<interface>> Nome da “Interface”
Operação1 ()Operação2 ()
Operação3 ()
Apêndice D
Notação UML
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected]) 187
Notas:
Marcas Registradas:
Todos os termos mencionados e reconhecidos como Marca Registrada e/ou
comercial são de responsabilidade de seus proprietários. O autor informa não estar
associada a nenhum produto e/ou fornecedor apresentado neste material. No decorrer
deste, imagens, nomes de produtos e fabricantes podem ter sido utilizados, e desde já
o autor informa que o uso é apenas ilustrativo e/ou educativo, não visando ao lucro,
favorecimento ou desmerecimento do produto/fabricante.
É expressamente proibido o uso deste material para fins comerciais.
Melhoria e Revisão:
Este material esta em processo constante de revisão e melhoria, se você encontrou
algum problema ou erro envie um e-mail nós.
Criticas e Sugestões:
Nós estamos abertos para receber criticas e sugestões que possam melhorar o
material, por favor envie um e-mail para nós.
Rildo F dos Santos ([email protected])
Imagens:
Google, Flickr e Banco de Imagem.
Linguagem de Programação JAVA
© Copyright e-tecnologia.com, 2002
JB100 Java BásicoJB100 Java Básico
Versão: 3.0
Rildo F Santos ([email protected]) 188
Licença: