Curso Java

Curso de Introduo ao Java
00f80 00
llf00080
80 l898
Daniel Destro do Carmo
Softech Network Informtica
daniel@danieldestro.com.br
Ob]etivo do curso
Conhecer a Plataforma Java
Conhecer a sintaxe e as caractersticas do Java
Conhecer as APIs do Java
Escrever aplicaes simples em Java
Entender e aplicar conceitos da Programao Orientada a Objetos
A Tecnologia Java
A tecnologia Java composta por uma gama de produtos, baseados no poder da rede e na idia
de que um software deveria ser capaz de rodar em diferentes mquinas, sistemas e dispositivos.
Por diferentes dispositivos entendemos: computadores, servidores, notebooks, handhelds, PDAs
(Palm), celulares, TV, geladeiras e tudo mais o que for possvel.
Os programas feitos em Java rodam em diferentes ambientes graas a um componente da
plataforma chamado JVM (Java Virtual Machine) que um tipo de tradutor de cdigo Java para
instrues especficas de cada sistema e dispositivo.
A tecnologia Java foi lanada em 1995, e desde ento tem crescido em popularidade e se tornado
uma plataforma muito estvel e madura. Atualmente a tecnologia Java est em sua segunda
verso, chamada de Java 2 Platform.
A tecnologia Java , basicamente, sub-dividida em:
J2SE (Java 2 Standard Edition)
J2EE (Java 2 Enterprise Edition)
J2ME (Java 2 Micro Edition)
Java Card
Java Web Services
A Tecnologia Java - J28E
A J2SE uma rica plataforma que oferece um completo ambiente para o desenvolvimento de
aplicaes para clientes e servidores. A J2SE tambm a base das tecnologias J2EE e Java Web
Services, e dividida em dois grupos conceituais: Core Java e Desktop Java.
A Sun distribui a J2SE na forma de um SDK (Software Development Kit), em conjunto com uma
JRE (Java Runtime Environment). O pacote do SDK da J2SE vem com ferramentas para:
compilao, debugging, gerao de documentao (javadoc), empacotador de componentes (jar) e
a JRE, que contm a JVM e outros componentes necessrios para rodar aplicaes Java.
A Tecnologia Java - J2EE
A tecnologia J2EE no um produto, mas sim de uma especificao definida pela Sun.
Simplifica as aplicaes empresariais e multi-camadas
baseando nos componentes padronizados, modulares e reusveis, os (EJB)
Oferecendo um conjunto completo de servios para estes componentes
Manipula muitos detalhes do comportamente da aplicao automaticamente
No precisa reaprender a programa, pois se utiliza dos mesmo recursos do Java (J2SE)
Roda em servidores de aplicaes J2EE diferentes e padronizados pela Sun
A tecnologia J2EE no est no escopo deste curso.
A Tecnologia Java - J2ME
A tecnologia J2ME voltada para aplicaes que rodam em pequenos dispositivos como
celulares, PDAs, smart cards e etc. Ela possui uma API bastante completa para o
desenvolvimento de aplicaes para pequenos dispositivos. A tecnologia J2ME no est no
escopo deste curso.
A Tecnologia Java - Web 8ervices
Baseada na tecnologia XML
Usado para troca de informaes pela rede
Muito utilizado por sites de e-commerce
Utiliza padres definidos (SOAP, ...)
A API JAXP (Java API for XML Processing) oferece facilidades para Web Services
O que Java, afinal???
Java uma linguagem de programao
Java um ambiente de desenvolvimento
Java uma completa plataforma de solues para tecnologia
Java
J2EE
J2SE
J2ME
JDBC
JAXP
API
CORBA
RMI
XML
AWT
Swing
JVM
JRE
SDK
JNI
JINI
JSP
Servlet
nstalando o 8DK do Java {J28DK}
Faa o download do J2SDK para a sua plataforma (http://java.sun.com).
Execute o arquivo de instalao fcil instalar (Next, Next, Finish).
Crie uma varivel de ambiente chamada JAVA_HOME, que deve guardar o
caminho do diretrio onde o Java foi instalado e adicione o caminho para os
programas do Java no PATH do seu S.O.:
No Windows:
SET JAVA_HOME=C:\jdk1.5.0
SET PATH=%PATH%;%JAVA_HOME%\bin
No Linux:
export JAVA_HOME=/usr/java/jdk1.5.0
export PATH=$PATH:%JAVA_HOME%/bin
Fundamentos da Linguagem Java
Java no necessita de um editor especfico (Notepad o suficiente)
Existem dezenas de editores completos (IDEs) para Java (livres ou no)
portavel para qualquer ambiente/plataforma - Write once, run everywhere!
Java orientado ao objeto
Os programas em Java, quando compilados, so convertidos para um cdigo intermedirio
(bytecode), que verificado, carregado na memria e ento interpretado pela JVM (Java Virtual
Machine). O Java NO gera executveis, nem cdigo nativo para o SO.
Primeiro Programa em Java
public class PrimeiroPrograma {
public static void main( String[] args ) {
System.out.println( "Meu primeiro programa em Java" );
}
}
Arquivo: PrimeiroPrograma.java
Compilando o cdigo-fonte:
javac PrimeiroPrograma.java
Executando o programa:
java PrimeiroPrograma
Sada gerada:
Meu primeiro programa em Java
Todo programa comea
pelo mtodo main( ).
Que o seu ponto de
partida.
Mtodo man( )
}
A assinatura do mtodo main( ), que o ponto de partida de um programa stand-
alone, deve ser feito como abaixo:
O parmetro passado para o mtodo main( ) um array de Strings, que contm os
valores dos argumentos passados na linha de comando da execuo do programa.
Exemplo:
java PrimeiroPrograma argumento1 argumento2 argumento3
Cada palavra passada como argumento um tem do array, parmetro do main( ).
Comentarios
Os comentrios em Java podem ser por linha ou em bloco:
Por linha:
// isto um comentrio e inicia com duas barras.
Em bloco:
/*
Comentrio em bloco
Aceita mltiplas linhas
No utilize comentrios aninhados
*/
Variaveis de Tipos Primitivos
Em Java, uma varivel deve:
ser declarada antes de ser usada
ter um tipo definido (o tipo no muda)
iniciar o valor da varivel antes de us-la
ser usada dentro do escopo (mtodo ou bloco)
Declarao: <tipo da varivel> <nome da varivel>;
Declarao e atribuio: <tipo> <nome> = <valor>;
64 double
32 float
2
63
- 1 -2
63
64 long
2
31
- 1 -2
31
32 int
2
15
- 1 -2
15
16 short
2
7
- 1 -2
7
8 byte
X 2
16
- 1 0 16 char
X true false 1 boolean
Sem Sinal Valor Mximo Valor Mnimo Tamanho
(bits)
Tipo
Variaveis de Tipos Primitivos
public class TiposPrimitivos {
//declara um int e atribui um valor
int idade = 25;
//declara um float e, depois, atribui um valor
float valor;
valor = 1.99f;
//declarando um boolean
boolean verdadeiroOuFalso = false;
verdadeiroOuFalso = true;
//declarando um char
char letraA = 'A';
letraA = 65; //valor ASCII para 'A'
letraA = '\u0041'; //valor Unicode para 'A'
//declarando um byte
byte b = 127;
//declarando um short
short s = 1024;
//declarando um long
long l = 1234567890;
//declarando um double
double d = 100.0;
//declarao mltipla
int var1=0, var2=1, var3=2, var4;
}
}
8tring
String uma classe que manipula cadeias de caracteres
A classe String possui mtodos para essas manipulaes
Trabalha com Pool de Strings para economizar memria
String str = Isto uma String do Java;
String xyz = new String(Isto uma String do Java);
if( str == xyz ) System.out.println(IGUAL);
else System.out.println(DIFERENTE);
if( str.equals( xyz ) ) {
//MANEIRA CORRETA DE SE COMPARAR O CONTEDO DAS STRINGS
}
System.out.println( Tamanho da String: + str.length() );
System.out.println( SubString: + str.substring(0, 10) );
System.out.println( Caracter na posio 5: + str.charAt(5) );
8tring
Outros mtodos teis da classe String:
String str = Isto uma String do Java;
// O mtodo split quebra a String e vrias outras,
// pelo separador desejado
String[] palavras = str.split( );
int i = str.indexOf(uma); //retorna o ndice da palavra na String
if( str.startsWith(Ol) || str.endsWith(Mundo!) ) {
// testa o comeo e o fim da String retorna boolean
}
str = str.trim(); // elimina os espaos em branco no incio e fim
str = str.replace(a,@); // substitui os caracteres
// substitui uma palavra (usa expresses regulares)
str = str.replaceAll(String,Cadeia de caracteres);
Literais
Um valor literal aquele especificado no prprio cdigo.
As literais podem ser:
boolean:
true e false
inteiro:
10, 0x10, 010 (decimal, hexadecimal e octal, respectivamente)
ponto-flutuante:
1.99, 2.55f, 10.99d, 4.23E+21 (double, float, double e notao cientfica, respectiv.)
Caracteres de escape do tipo char:
'\n' quebra de linha
'\r' retorno de carro
'\t' tabulao
'\\' barra invertida
'\b' backspace
'\f' form feed
'\'' aspa simples
'\' aspa dupla
char:
'A', '\u0041', 65 (caracter ascii, cdigo Unicode e cdigo ascci, respectivamente)
String:
String str = Isto uma literal String;
Palavras-Chaves do Java
O Java possui 53 palavras-chaves e palavras reservadas:
Nenhuma das palavras acima podem ser usadas como identificadores (nomes de variveis,
atributos, classes), ou para outro propsito, a no ser o especificado para aquela determinada
palavra. As palavras goto e const, apesar de reservadas, no tem utilizadade algum no Java.
transient static new if enum char
throws short native goto else catch
throw return long for double case
while this public interface float do byte
volatile synchronized protected int finally default break
void switch private instanceof final continue boolean
try super package import false const assert
true strictfp null implements extends class abstract
dentificadores
As regras para nomeao de identificadores (variveis, nomes de funo, classes ou label)
seguem a seguinte regra:
nomes nomes devem comear com letra ou os caracteres _ ou $
os caracteres seguintes podem conter nmeros, letras, _ ou $
Veja exemplos de nomes de identificadores:
valor // vlido
$preco // vlido
20itens // invlido
_teste // vlido
INT // vlido
Observao: O Java considera diferena entre maisculas e minscula.
Operadores
Veremos agora os operadores da linguagem Java, que agregam
importantes funcionalidades aos programas.
Eles possuem uma ordem de precedncia na execuo da expresso.
Para garantir a ordem de precedncia desejada, agrupe as expresses
com parnteses.
Operadores Unarios
Incremento e Decremento: ++ e --
int a = 0;
int b = a++; // incrementado depois de atribuir
int c = ++a; // incrementado antes de atribuir
b = a--; // decrementado depois de atribuir
c = --a; // decrementado antes de atribuir
Mais e Menos Unrio: + e -
int x = +3; // x recebe o positivo 3
x = -x; // x recebe -3, neste caso
Inverso de Bits: ~
int i = ~1; // i = -2 (os bits foram invertidos)
Complementar booleano: !
boolean falsidade = ! (true); // inverte o valor booleano
Converso de Tipos: (tipo)
double d = 1.99;
int i = (int) d; // converte de double p/ int (perda de preciso)
Operadores Aritmticos
Multiplicao e Diviso: * e /
int um = 3 / 2; // diviso de inteiros gera um inteiro
float umEmeio = (float) 3 / 2; // ocorre promoo aritmtica para float
double xyz = umEmeio * um; // ocorre promoo aritmtica para float
Mdulo: %
int resto = 7 % 2; // resto = 1
Adio e Subtrao: + e -
long l = 1000 + 4000;
double d = 1.0 0.01;
Concatenao:
long var = 12345;
String str = O valor de var + var;
Na concatenao de Strings, as variveis ou literais so promovidos a String antes:
String str = O valor de var + Long.toString( var );
Operadores de Deslocamento
Deslocamento direita: >>
Nmero: 192
Binrio: |00000000|00000000|00000000|11000000|
Right Shift de 1 bit: |00000000|00000000|00000000|01100000|
Right Shift de 7 bits: |00000000|00000000|00000000|00000001|
Nmero: -192
Binrio: |11111111|11111111|11111111|01000000|
Deslocamento esquerda: <<
Nmero: 192
Binrio: |00000000|00000000|00000000|11000000|
Left Shift de 1 bit: |00000000|00000000|00000001|10000000|
Left Shift de 7 bits: |00000000|00000000|01100000|00000000|
Nmero: -192
Binrio: |11111111|11111111|11111111|01000000|
Left Shift de 1 bit: |11111111|11111111|11111110|10000000|
Left Shift de 7 bits: |11111111|11111111|10100000|00000000|
Deslocamento direita, sem sinal: >>>
Nmero: 192
Binrio: |00000000|00000000|00000000|11000000|
Nmero: -192
Binrio: |11111111|11111111|11111111|01000000|
int i = 192 >> 1
int i = 192 >> 7
int i = -192 >> 1
int i = -192 >> 7
int i = 192 << 1
int i = 192 << 7
int i = -192 << 1
int i = -192 << 7
int i = 192 >>> 1
int i = 192 >>> 7
int i = -192 >>> 1
int i = -192 >>> 7
Exercicios
1) Multiplique um nmero por 8, sem utilizar o operador *.
2) Divida um nmero por 2 sem utilizar o operador /.
3) Calcule o resto da diviso de 99 por 4.
Desafio:
Declare um inteiro de valor 10 e mostre na tela o valor do terceiro bit mais significativo (da
direita para a esquerda).
Operadores de Comparao
Comparao ordinal: >, >=, < e <=
Compara tipos primitivos numricos e o tipo char.
boolean b = ( 10 < 3 );
boolean w = (x <= y);
if( x >= y ) { }
Operador instanceof
Compara o tipo da classe de uma referncia de um objeto.
String str = Uma String;
if( str instanceof String ) { } // true
if( srt instanceof Object ) { } // true
Comparao de Igualdade: == e !=
Comparam tipos primitivos, valores literais e referncias de objetos.
if( abc == 10 ) { }
boolean b = ( xyz != 50 );
if( refObj1 == refObj2 ) { }
Operadores de Bits: &, | e ^
Numricos Inteiros:
Operando A: 1
Operando B: 3
Binrio de A: 00000001
Binrio de B: 00000011
A & B: 00000001 = 1
A ^ B: 00000010 = 2
A | B: 00000011 = 3
Booleanos:
true & true = true
true & false = false
true ^ true = false
true ^ false = true
false | false = false
false | true = true
Operadores Lgico de Curto-Circuito: && e ||
if( (a>10) && (b<5) ) {
// isso
}
if( (x==y) || (b<5) ) {
// aquilo
}
boolean b = x && y || z;
Estes operadores no precisam testar toda a expresso.
Ele pra assim que uma das condies o satisfaa.
O retorno da expresso um boolean
Operador Condicional: ?
tambm conhecido como operador ternrio, pois trabalha com 3 operandos.
Ele avalia o primeiro operando.
Caso a avaliao retorne true, ele executa o segundo operando.
Seno, ele executa o terceiro operando.
O segundo e terceiro operandos DEVEM ser do mesmo tipo (seno, use cast).
O cdigo do operador ternrio abaixo:
int x = 10;
int y = (x > 10) ? x : x+1;
semelhante ao cdigo abaixo:
int x = 10;
int y;
if( x > 10 ) {
y = x;
} else {
y = x + 1;
}
Operadores de Atribuio
Estes operadores atribuem um novo valor a uma varivel ou expresso.
O operador = apenas atribui um valor.
Os operadores +=, -=, *= e /= calculam e atribuem um novo valor.
int i = 10;
int dois = 1;
dois += 1; // dois = dois + 1;
int cinco = 7;
cinco -= 2; // cinco = cinco - 2;
int dez = 5;
dez *= 2; // dez = dez * 2;
int quatro = 12;
quatro /= 3; // quatro = quatro / 3;
Converso de Tipos Primitivos
Permite a converso entre tipos diferentes
Deve ser explcito quando for de um tipo maior para um menor (narrowing)
Pode ser implcito (ou explcito) de um tipo menor para um maior (widening)
Converso para tipos menores pode causar perda de preciso e truncamento.
double d = 1.99d;
int i = (int) d; // i recebe o valor 1
short s = 15;
long x = s; // converso widening
long y = (long) s; // no necessrio
O widening segue o sentido das flechas. Narrowing no sentido contrrio.
Promoo Aritmtica
Ocorre com as operaes aritmticas entre tipos primitivos numricos diferentes.
O menor tipo automaticamente convertido para o maior tipo.
public class PromocaoMatematica {
double d = 100.99;
int i = 100;
//aqui ocorre a promoo matemtica
//i convertido para double e ento multiplicado
d = d * i;
//ao contrrio necessrio informar o casting
long x = 12345;
float pi = 3.14f;
x = x * (long) pi;
//ou ento, converte apenas o resultado
x = (long) (x * pi);
}
}
Controles de Fluxo do Programa
Clusula if( ) / else
public class ClausulaIf {
int idade = 20;
if( idade <= 12 ) {
System.out.println( "Criana" );
}
if( idade > 12 && idade <= 19 ) {
System.out.println( "Adolescente" );
}
if( idade > 19 && idade <= 60 ) {
System.out.println( "Adulto" );
}
if( idade > 60 ){
System.out.println( "Idoso" );
}
}
}
public class ClausulaIf {
int idade = 20;
if( idade <= 12 ) {
System.out.println( "Criana" );
}
else if( idade <= 19 ) {
System.out.println( "Adolescente" );
}
else if( idade <= 60 ) {
System.out.println( "Adulto" );
}
else {
System.out.println( "Idoso" );
}
}
}
Clusula if( ) / else
public class ClausulaSwitch {
int numero = 1;
switch( numero ) {
case 1 :
System.out.println( "UM" );
break;
case 2 :
System.out.println( "DOIS" );
break;
case 3 :
System.out.println( "TRES" );
break;
default :
System.out.println( "NENHUM" );
break;
}
}
}
O switch recebe um argumento do tipo int.
Clusula switch( )
Lao while( )
public class LacoWhile {
int i = 0;
//lao while() com bloco de cdigo definido
while( i < 10 ) {
System.out.println( "Linha: " + i );
i++;
}
}
}
A expresso avaliada antes de executar o bloco de cdigo
Ele repete enquanto a expresso for verdadeira (true)
Lao do / while( )
public class LacoWhile {
int i = 0;
//lao do / while() com bloco de cdigo definido
do {
i++;
} while( i < 10 );
}
}
O bloco executado ao menos um vez
Aps a primeira repetio que a expresso avaliada
Lao for( )
A sua estrutura definida como a seguir:
for( iniciao; condio; incremento ) {
bloco_de_cdigo_a_executar
}
public class LacoFor {
for( int i=0; i < 10; i++ ) {
}
}
}
Lao for( ) avanado (Enhanced for loop)
Foi definido a partir do Java 5, com o intuito de facilitar a vida do desenvolvedor,
economizando cdigo e evitando erros ao percorrer arrays e colees
(implementaes de java.util.Collection).
similar ao for each de outras tecnologias.
No possvel controlar o ndice utilizado pelo for, mas pode-se contonar este
problema.
public class LacoForAvancado {
for( String s : args ) {
System.out.println("Argumento: " + s );
}
}
}
List lista = new ArrayList();
// adiciona itens lista
for( String s : lista ) {
System.out.println( s );
}
Clusula break
Aborta a execuo de um lao, quando executado.
public class ClausulaBreak {
char letras[] = { 'A', 'B', 'C', 'D', 'E' };
int i;
for( i=0; i<letras.length; i++ ) {
if( letras[i] == 'C' ) {
break;
}
}
System.out.println( "ltimo ndice: " + i );
}
}
Clusula break rotulada
Aborta a execuo de um lao rotulado, quando executado.
int j = 0, i = 0;
principal1: while( true ) {
for( i=0; i<1000; i++ ) {
if( j == 10 && i == 100 )
break principal1;
}
j++;
}
Clusula continue
Ignora a execuo dos comandos seguintes do bloco, no lao, quando executado.
public class ClausulaContinue {
char letras[] = { 'B', 'X', 'R', 'A', 'S', 'I', 'L' };
int i;
for( i=0; i<letras.length; i++ ) {
if( letras[i] == 'X' ) {
continue;
}
System.out.print( letras[i] );
}
}
}
Clusula continue rotulada
Ignora a execuo dos comandos seguintes do bloco, do lao rotulado, quando executado.
int i=0, j=0;
principal2: for( j=1; j<10; j++ ) {
for( i=1; i<10; i++ ) {
if( (i % j) == 0 ) {
System.out.println( "i=" + i + " j=" + j );
continue principal2;
}
}
j++;
}
Exercicios
1) Faa o clculo do valor da varivel x mais y, inteiros, sem utilizar o operador +.
2) Calcule o valor da multiplicao de um int por um long, atribuindo o valor a um int.
3) Verifique o valor de x, imprimindo uma mensagem quando for maior, menor ou igual a 10,
sem usar if( ).
Programao Orientada ao Ob]eto
O paradgma da Orientao ao Objeto um mecanismo que ajuda a definir a
estrutura de programas, baseado nos conceitos do mundo real, sejam eles reais ou
abstratos.
A Orientao ao Objeto permite criar programas componentizados, separando as
partes do sistema por responsabilidades e fazendo com que essas partes se
comuniquem entre s, por meio de mensagens.
Os conceitos da OO envolvem: Classes, Objetos e seus Relacionamentos, Herana e
Polimorfismo.
Dentre as vantagens que a OO proporciona, podemos destacar o aumento de
produtividade, reuso de cdigo, reduo das linhas de cdigo programadas,
separao de responsabilidades, encapsulamento, polimorfismo, componentizao,
maior flexibilidade do sistema, dentre outras vantagens.
Modelagem Orientada ao Ob]eto
Os sistemas OO podem ser modelados com auxlio da UML (Unified Modeling
Language).
UML uma linguagem de modelagem para especificar, modelar, visualizar e
documentar sistemas OO e no-OO, baseando-se em diagramas.
A UML composta por:
Diagrama de Classes
Diagrama de Seqncia
Diagrama de Objetos
Diagrama de Casos de Uso
outros....
Classes
Uma classe, nada mais , do que a descrio de um conjunto de entidades (reais ou
abstratas) do mesmo tipo e com as mesmas caractersticas e comportamento. As
classes definem a estrutura e o comportamento dos objetos daquele determinado tipo.
Podemos dizer que as classes so, na verdade, modelos de objetos do mesmo tipo.
Entidade do mundo real
Propriedades:
modelo
cor
motor
Comportamento:
liga
desliga
muda marcha
acelera
breca
Modelo UML da classe
class Carro {
String cor;
String modelo;
String motor;
void ligar() {
System.out.println( "Ligando o carro" );
}
void desligar() {
System.out.println( "Desligando o carro" );
}
void acelerar() {
System.out.println( "Acelerando o carro" );
}
void brecar() {
System.out.println( "Brecando o carro" );
}
void mudarMarcha() {
System.out.println( "Marcha engatada" );
}
}
Classes
Ao lado temos o cdigo Java
da classe Carro, definida pelo
modelo UML, com base no
levantamento da entidade
carro do mundo real.
No cdigo definimos:
declarao da classe
declarao dos atributos
declarao dos mtodos
Arquivo: Carro.java
O arquivo do cdigo-fonte sempre
leva o nome da classe, seguido
da extenso .java.
Ob]etos
Um objeto, nada mais do que uma instncia particular de um tipo de dado
especfico (classe), ou seja, em outras palavras, objeto uma entidade, do mundo
computacional, que representa uma entidade do mundo real especificamente. O
objeto criado fica armazenado em uma rea de memria chamada heap.
Os Objetos possuem:
Estado (atributos/propriedades)
Comportamento (mtodos/aes)
Identidade (cada objeto nico)
Os Objetos se comunicam entre sim por
meio de mensagens (chamadas aos
mtodos) e devem ter sua
responsabilidade bem definida no sistema.
Criando uma instncia (objeto) de uma classe:
Carro meuCarro = new Carro( );
Declarao da varivel que
vai guardar uma referncia
para um objeto do tipo Carro.
Operador new
instanca o
objeto.
Construtor da classe
Carro
Ob]etos
As variveis no guardam os objetos, mas sim uma referncia para a rea de memria
onde os objetos esto alocados.
Se criarmos duas instncias da classe Carro e atriburmos
cada instncia para cada uma das duas variveis
diferentes, c1 e c2, temos a situao ao lado.
Carro c1 = new Carro( );
Imagine, agora, duas variveis diferentes, c1 e c2, ambas
referenciando o mesmo objeto. Teramos, agora, um
cenrio assim:
Carro c2 = c1;
Ob]etos
class ExemploCarro {
//criando uma instncia da classe Carro
Carro umCarro = new Carro();
//atribuindo os valores dos atributos
umCarro.modelo = "Gol";
umCarro.cor = "preto";
umCarro.motor = "1.0";
//executando os mtodos do objeto
umCarro.ligar();
umCarro.mudarMarcha();
umCarro.acelerar();
umCarro.brecar();
umCarro.desligar();
//atribuindo null para a varivel diz que
//agora ela no aponta para lugar nenhum
umCarro = null;
}
}
Utilizando a classe Carro:
Package e mport
Package
Os pacotes (packages) servem para organizar e agrupar classes por funcionalidade.
Os pacotes so divididos por uma estrutura de diretrios.
package meuprograma.cadastro;
public class CadastroUsuario {
//...
}
package meuprograma.uteis;
public class ValidacaoCPF {
//...
}
Package e mport
Import
O import deve ser usado para declarar que usaremos classes de outro pacote.
parecido com o include de outras linguagens, como o C/C++, por exemplo.
package meuprograma.cadastro;
import meuprograma.uteis.ValidacaoCPF;
import java.sql.*; //importa classes JDBC
public class CadastroUsuario {
//...
public void cadastrar( Usuario u ) {
//...
if( ValidacaoCPF.validar( u.cpf ) ) {
cadastrar( u );
} else {
throw new Exception(CPF Invlido);
}
//...
}
}
package meuprograma.uteis;
public static boolean
validar (String cpf) {
//fazer a validao
}
}
Package e mport
Import esttico
A partir do Java 5 possvel fazer o import esttico, ou seja, dar import apenas nos
mtodos ou atributos estticos oferecidos por uma classe, e us-los como se fossem
mtodos ou atributos locais sua classe.
import static java.lang.Math.*;
public class TesteImportEstatico {
public static void main(String[] args) {
double d = sin(1);
// O mtodo sin() pertence
// classe Math
}
}
import static java.lang.Math.PI;
public class Calculos {
public double areaCircunferencia(double r) {
return PI * r * r;
}
}
Package e mport
Algo importante a se destacar que as classes possuem um nome e um nome
completo (ou fully qualified name).
O nome da classe aquele informado na definio da classe. Exemplo:
public class MinhaClasse { }
Neste caso o nome da classe MinhaClasse.
O nome completo da classe compreende o nome da classe mais a sua hierarquia
completa de packages a qual pertence. Exemplo:
package meu.pacote;
public class MinhaClasse { }
Neste caso o nome completo da classe meu.pacote.MinhaClasse.
Garbage Collection
Os objetos que no so mais referenciados, so coletados pelo Garbage Collector.
O Garbage Collector libera a memria que no est mais em uso.
Um objeto que perdeu sua referncia eleito a ser coletado, porm no coletado
automaticamente naquele instante.
Quando um objeto se torna eletivo a Garbage Collection:
// objeto criado em memria
MeuObjeto obj = new MeuObjeto( );
// referncia perdida eleito a ser recolhido pelo GC
obj = null;
Para forar a execuo do Garbage Collector:
System.gc( );
Porm, nada garante que o G.C. ser executado naquele instante, nem que as
instncias sem refncias sero recolhidas.
Atributos
Os atributos de uma classe so variveis com o escopo do objeto.
So acessveis e esto disponveis enquanto o objeto estiver disponvel.
Os atributos so iniciados durante a criao do seu objeto.
Durante a criao do objeto, os atributos de:
tipos primitivos numricos recebem 0 (zero) na iniciao;
tipo char recebe o valor '\u0000';
tipo boolean recebe false;
referncia a objetos recebem null na iniciao.
Porm, os atributos podem receber um valor padro, definido na sua declarao,
como no cdigo abaixo:
class UmaClasse {
String valorInicial = "um valor qualquer";
int i = 1000;
}
Atributos Estaticos
Atributos estticos no precisam de uma instncia da classe para serem usados
Eles so compartilhados por todas as instncias da classe
No so thread-safe (cuidado ao us-los)
class Contador {
static int count = 0;
void incrementar() {
count++;
}
}
Contador c = new Contador();
c.incrementar();
System.out.println( Contador.count );
Contador.count++;
System.out.println( c.count );
}
Constantes
Constantes so atributos de uma classe que no mudam de valor
O modificador final indica que o atributo imutvel
public class Matematica {
static final double pi = 3.14;
static double areaCircunferencia( double r ) {
return pi * r * r;
}
static double perimetroCircunferencia( double r ) {
return pi * r;
}
}
Mtodos
A utilidade dos mtodos a de separar, em pedaos de cdigos menores, uma
determinada funo.
aconselhvel criar e manter mtodos pequenos, seguindo uma regrinha bsica: Se
o mtodo tem scroll na tela, quebre-o em mtodos menores. Isso facilita a leitura e o
entendimento do cdigo e a manuteno.
Regras para se criar mtodos:
Serem bem claros e ter uma funo bem definida
Serem pequenos e fceis de entender
Serem reaproveitveis ao mximo
Mtodos
A sintaxe para a declarao dos mtodo a seguinte:
<tipo de retorno> <nome do mtodo>( [lista dos atributos] ) {
// implementao do mtodo
}
O tipo de retorno informa qual o tipo de dados o mtodo retorna. Pode ser um tipo
primitivo ou um tipo de um classe. Caso o mtodo no retorne nada, ele deve ser
void.
O nome do mtodo pode ser qualquer. Prefira seguir os padres de nomenclatura e
dar nomes significativos, de preferncia verbos no infinitivo.
A lista de atributos no precisa ser informada se no h passagem de argumentos.
Caso haja, os argumentos devem ser informados com seu tipo e nome, separados
por vrgula se houver mais de um.
Retorno dos Mtodos
A palavra reservada return causa o retorno do mtodo.
Quando os mtodos so declarados com o tipo de retorno void, ento o mtodo no
pode e nem deve retornar nada.
Os mtodos que retornam algum valor, devem retornar dados do tipo de retorno
declarado, ou de tipos compatveis.
Veja o exemplo:
public class TesteRetorno {
public void naoRetornaNada() {
int i = (int)(Math.random() * 100);
if( i > 50 ) {
return; //aborta o mtodo
}
System.out.println(OK);
}
int somar( int a, int b ) {
return a + b;
}
Carro criarUmCarro() {
Carro c = new Carro();
c.modelo = "Ferrari";
c.cor = "vermelha";
c.motor = "5.0 V12";
return c;
}
}
Mtodos
public class DeclaracaoDeMetodo {
DeclaracaoDeMetodo dm = new DeclaracaoDeMetodo();
dm.fazerAlgo();
dm.imprimirNaTela( "Daniel" );
int soma = dm.somar( 2, 3 );
Carro meuCarro = dm.criarUmCarro();
}
void fazerAlgo() {
//este mtodo no faz nada
}
void imprimirNaTela( String nome ) {
System.out.println( "Meu nome " + nome );
}
int somar( int a, int b ) {
return a + b;
}
Carro criarUmCarro() {
Carro c = new Carro();
c.modelo = "Ferrari";
c.cor = "vermelha";
c.motor = "5.0 V12";
return c;
}
}
Mtodos Estaticos
Mtodos estticos no precisam de uma instncia da classe para serem usados
Mtodos esttico NO podem chamar mtodos no-estticos sem uma instncia
No so thread-safe (cuidado ao us-los)
class MetodoEstatico {
MetodoEstatico me = new MetodoEstatico();
me.metodoNaoEstatico();
me.metodoEstatico();
MetodoEstatico.metodoEstatico();
metodoEstatico();
}
static void metodoEstatico() {
//metodoNaoEstatico(); //ERRADO
// (new MetodoEstatico()).metodoNaoEstatico(); //OK
}
void metodoNaoEstatico() {
metodoEstatico(); //OK
}
}
Construtores
Construtores no so mtodos, so construtores.
Eles fazem a funo de iniciao (start up) do objeto criado.
Se nenhum construtor for declarado, um construtor default ser criado.
Mltiplos construtores podem ser declarados (overloading).
public class MinhaClasse {
//sem construtor default
}
public class MinhaClasse {
public MinhaClasse() {
//Construtor Default
}
}
public class NotaFiscal {
private int numero;
public NotaFiscal() {
this( novoNumero() );
}
public NotaFiscal( int numero ) {
this.numero = numero;
}
public int novoNumero() {
int i;
//gera novo numero em i
return i;
}
}
Construtores
public class Venda {
public Venda() {
}
public void fecharVenda() {
//cria uma NF com um numero gerado
NotaFiscal nf = new NotaFiscal();
//cria uma NF com um numero definido
NotaFiscal nf2 = new NotaFiscal( 12345 );
}
}
Usando os diferentes construtores:
Passagem de Parmetros
Passagem de parmetros, em Java, por valor (no tem por referncia)
Parametros alterados dentro de um mtodo, no sero alterados fora dele
Objeto passado como parmetro apenas passa uma cpia da referncia ao objeto
Referncia alteradas dentro do mtodo, no refletem fora dele.
Alterao no estado de um objeto, como um parmetro, alteram o estado dele fora
//...
int i = 10;
System.out.println( "i=" + i );
alterar( i );
//...
void alterar( int i ) {
i = i * 999;
}
Carro meuCarro = new Carro( );
meuCarro.modelo = "Gol";
meuCarro.cor = "preto";
meuCarro.motor = "1.0 16v";
System.out.println( meuCarro.modelo );
realidade( meuCarro );
sonho( meuCarro );
void realidade( Carro c ) {
// eu quero que ele mude, mas no muda!
// c nunca ser alterado fora do mtodo
c2.modelo = "Porsche";
c2.cor = "prata";
c2.motor = "4.0";
c = c2;
}
void sonho( Carro c ) {
// aqui alteramos o estado do objetos e
// reflete fora do mtodo, mas s um sonho
c.modelo = "Porsche";
c.cor = "prata";
c.motor = "4.0";
}
Contornando o problema de passagem por valor de tipos primitivos:
Utilizar arrays (array um objeto)
//...
int[ ] i = { 1 };
modificar( i );
//...
void modificar( int[ ] i ) {
i[0] = 1234567890;
}
Varargs
No Java 5 foi introduzido o Vargars, que permite a passagem de um nmero varivel
de argumentos a um mtodo.
Dentro do mtodo os argumentos variveis so tratados como arrays do tipo que foi
definido. No caso dos exemplos abaixo, um array de int (int[ ]) ou de String.
Esta funcionalidade alivia o trabalho de o desenvolvedor ter que criar arrays com
valores e passar aos mtodos.
void metodo( int... args ) {
for( int i : args ) {
System.out.println( i );
}
}
void novoMetodo( long i, String... args ) {
for( int s : args ) {
}
}
// chamadas
metodo( 1 );
metodo( 1, 2, 3 );
novoMetodo( 1L, a );
novoMetodo( 9L, a, b, c );
Modificadores de Acesso
Determinam a visibilidade dos membros (atributos e mtodos) da classe e da prpria classe
Devem ser usados na declarao dos membros e da classe
Ao todo so quatro modificadores: public, protected, default e private
[modificador] class Pessoa {
[modificador] String nome;
[modificador] int idade;
[modificador] void imprimirNomeIdade() {
System.out.println("nome="+nome);
System.out.println("idade="+idade);
}
}
public
Pode ser acessado
por todo mundo
protected
Pode ser acessado
por subclasses e
classes do mesmo
pacote
default
Pode ser acessado
por classes do
mesmo pacote
private
Pode ser acessado
apenas pela
prpria classe
JavaBeans
public class Pessoa {
private String nome;
private int idade;
public Pessoa() {}
public void setNome( String nome ) {
this.nome = nome;
}
public void setIdade( int idade ) {
this.idade = idade;
}
public String getNome() {
return nome;
}
public int getIdade() {
return idade;
}
}
Os JavaBeans so componentes Java (classes) bem encapsulados e com um
propsito especfico. Seus atributos no podem ser acessados diretamente, mas
apenas por meio de mtodos set e get. Segundo o encapsulamento, os atributos
no podem ser alterados diretamente.
Arrays
Array uma coleo ordenada de primitivos, referncias para objetos e outras
arrays. Os arrays em Java so homogneos, ou seja, eles s podem conter dados
do mesmo tipo. Os arrays so objetos, e devem ser construdos antes de serem
usados. Os array so iniciados automaticamente quando criados.
Passos para utilizar arrays:
Declarao
Criao
Iniciao
int[ ] umArray;
umArray = new int[ 10 ];
umArray[ 0 ] = 0;
umArray[ 1 ] = 999;
short[][] jogoDaVelha = new short[3][3];
double[] d = { 1.0d, 0.99, 3.14 };
Carro[ ] estoque = new Carro[10];
estoque[0] = new Carro( );
//...
estoque[1].modelo = Gol;
estoque[1].cor = preto;
estoque[1].motor = 1.0;
Arrays
Podemos percorrer os array de forma automtica, usando o lao for( )
O ndice dos arrays vai de 0 (zero) at N-1 (onde N o tamanho do array)
public class PercorrendoArray {
double[] precos = new double[100];
//aqui sabemos o tamanho do array
for(int i=0; i<100; i++) {
precos[i] = i * 2.99;
}
//aqui no importa o tamanho do array
for(int i=0; i<precos.length; i++) {
precos[i] = i * 2.99;
}
}
}
Os arrays no mudam de tamanho
Acessar um ndice inexistente causa uma exceo: ArrayIndexOutOfBoundsException
Herana {extends}
Herana uma caracterstica da POO que permite que classes (filhas) herdem e estendam as
funcionalidades e as caractersticas de outras classes (me).
Uma subclasse (classe filha) uma especializao da sua superclasse (classe me).
Este um relacionamento do tipo um. A subclasse uma superclasse.
Em Java, a herana conseguida atravs da palavra extends
Toda classe, por padro, estende a classe java.lang.Object
Todos os mtodos e atributos (public e protected) so herdados pela subclasse (filha)
Os construtores no so herdados
class MyClass
extends Object {
}
class MyClass {
}
class ClasseB
extends ClasseA {
}
class ClasseA {
}
Diagrama UML
Herana {extends}
Java no permite herana mltipla, ou seja, uma classe herda de apenas uma nica classe.
A palavra super referenca a superclasse.
O construtor da superclasse chamado automaticamente, se outra chamada no for feita.
public class Empregado extends Pessoa {
public Empregado() {
super(); //ocorre automaticamente
}
}
public class Pessoa {
protected String nome;
protected String cpf;
public Pessoa() {}
}
Diagrama UML
public class Gerente extends Pessoa {
}
Herana {extends}
Tomando vantagem da herana:
Todas as classes so subtipos da classe Pessoa.
Podemos dizer que Empregado e Gerente so Pessoas.
public class TesteHeranca {
Pessoa p = new Pessoa();
Pessoa e = new Empregado();
Pessoa g = new Gerente();
}
}
Herana {extends}
Melhorando o modelo: Gerente, ao invs de Pessoa, pode ser definido como um Empregado.
public class RH {
Gerente chefe = new Gerente();
Empregado emp = new Empregado();
pagarSalario( chefe );
pagarSalario( emp );
promoverEmp( chefe, emp );
}
public static void pagarSalario( Empregado e ) {
//faz lanamento do pagamento de salrio
}
public static void promoverEmp( Gerente g, Empregado e ) {
//Apenas um gerente pode promover um empregado
}
}
public class Gerente extends Empregado {
}
Herana {extends}
class ClasseB extends ClasseA {
public void metodo1() {
System.out.println(ClasseB.metodo1());
}
}
}
class ClasseA {
System.out.println(ClasseA.metodo1());
}
}
Overriding (sobrescrita) de mtodos herdados
class TesteAB {
public static
void main(String[] args) {
ClasseA a = new ClasseA();
a.metodo1();
a = new ClasseB();
a.metodo1();
ClasseB b = new ClasseB();
b.metodo1();
b.metodo2();
}
}
Overriding
O overriding (sobrescrita) ocorre quando um mtodo de uma superclasse
sobrescrito por um mtodo de mesmo nome de uma subclasse.
Os mtodos sobrescritos da subclasse no podem ter um modificador mais
restritivo que o modificador do mtodo de sua superclasse.
class ClasseB extends ClasseA {
}
}
class ClasseA {
System.out.println(ClasseA.metodo1());
}
}
Overloading
O overloading (sobrecarregamento) ocorre quando mais de um mtodo com o
mesmo nome implementado.
Overloading pode se dar apenas pela diferenciao dos argumentos do mtodo.
public boolean validar(String cpf) {
return validar( Integer.parseInt( cpf ) );
}
public boolean validar(int cpf) {
//faz as verificaes do CPF
return false;
}
public boolean validar(int cpf, int digito) {
return validar( (cpf*100) + digito );
}
}
ths e super
As palavras reservadas this e super so muito importantes e teis.
this referenca a prpria instncia de dentro de sua classe. Ela no pode ser
usada em mtodos estticos.
super referenca a superclasse de uma classe.
class ThisESuper extends SuperClasse {
private int var1;
ThisESuper ts = new ThisESuper();
ts.metodo1();
}
public ThisESuper() {
super(); //chama o construtor da superclasse
}
public void metodo1(int i) {
this.var1 = i;
//executa o mtodo executar da superclasse
super.executar();
}
}
class SuperClasse {
public void executar() {
}
}
Classes nternas
As classes internas (Inner classes) tambm so chamadas de classes aninhadas.
As classes internas so classes normais, porm so definidas dentro de uma
classe ou mtodo.
As classes internas que no so declaradas dentro de mtodos so chamadas de
classes membro.
public class OuterClass {
private int x;
public class InnerClass {
private int y;
private void innerMethod() {
System.out.println( y = + y );
}
}
public void outerMethod() {
System.out.println( x = + x );
}
}
Neste caso, os nomes
completo das classes
so:
OuterClass e
OuterClass.InnerClass.
Classes nternas
As classes internas precisam de uma instncia da classe externa para serem
criadas. As classes externas atuam como o contexto das classes internas.
As classes internas podem acessar os membros de sua classe externa, bem
como sua instncia.
private int x;
public class InnerClass {
private int y;
private void innerMethod() {
System.out.println( x (externo) = + x );
outerMethod( );
}
}
public void outerMethod() {
System.out.println( x = + x );
}
}
Classes nternas
Para instanciar uma classe interna, de um mtodo esttico ou de outra classe,
devemos fazer o seguinte:
OuterClass o = new OuterClass();
InnerClass i = o.new InnerClass();
Para instanciar uma classe interna, de dentro de sua classe externa, apenas
precisamos fazer assim:
InnerClass i = new InnerClass();
Classes nternas Estaticas
As classes internas estticas pertencem classe externa, ao invs de uma
instncia de objeto da classe externa, em particular.
Ou seja, elas no precisam de uma instncia da sua classe externa.
public static class StaticInnerClass {
}
StaticInnerClass sic = new OuterClass.StaticInnerClass();
}
}
Classes nternas a Mtodos
As classes internas aos mtodos no so consideradas membros da classe, mas
apenas local ao mtodo.
Essas classe tm acesso aos membros da sua classe externa, bem como s
variveis locais e parmetros do mtodo, desde que marcadas como final.
private int m = 10;
public void fazerAlgo( int a, final int b ) {
int x = a + b;
final int y = a b;
class MethodInnerClass() {
public void metodo() {
System.out.println( m = + m );
System.out.println( b = + b );
}
}
MethodInnerClass mic = new MethodInnerClass();
mic.metodo();
}
}
Classes Annimas
Classes Annimas so classes que no possuem um nome.
Ela estendem uma classe ou implementam uma interface. No permitido
estender uma classe e implementar uma ou mais interfaces ao mesmo tempo.
A definio, criao e o primeiro uso ocorrem, de fato, no mesmo lugar.
So, geralmente, muito utilizadas com o Listeners e Action handlers do pacote
grfico swing e awt.
public void umMetodo( ) {
jButton1.addActionListener(
new ActionListener() {
public void actionPerformed( ActionEvent e ) {
System.out.println( Uma ao ocorreu );
}
}
}
Object o = new JButton() {
// estenso da classe JButton
};
Classes Annimas
Exemplo de classe annima.
public class MinhaClasse( ) {
public MinhaClasse() {
//Construtor default
}
public MinhaClasse( String s ) {
//Construtor com parmetros
}
}
MinhaClasse m = new MinhaClasse() {
};
MinhaClasse m2 = new MinhaClasse( teste ) {
};
Ambas so subclasses de MinhaClasse, mas cada uma iniciada de modo
diferente (construtores diferentes).
Converso de Ob]etos
Assim como a converso de tipos primitivos, tambm podemos fazer a converso de objetos.
Podemos converter os tipos, baseando-se na topologia da hierarquia de classes e subclasses.
Subtipos podem ser fcilmente convetidos para seus supertipos, sem explicitar o casting.
Na converso de um supertipo para um subtipo, obrigatoriamente o objeto deve ser do subtipo.
//...
Object obj = new String(Texto);
String str = (String) obj;
Pessoa p = new Gerente();
Empregado e = (Empregado) p;
Gerente g = (Gerente) p;
Empregado emp = (Gerente) p;
//Gerente chefe = new Empregado(); //ERRADO
Classe Abstrata
Quanto mais genricas, as classes podem ser tornar muito abstratas, na hierarqia de classes.
A classe chega a ser to genrica que no precisa de uma instncia dela na aplicao.
Essa classe acaba servindo de modelo para suas subclasses. Essas so as classes abstratas.
A classe abstrata pode ter mtodos implementados, porm deve ter ao menos um mtodo
abstrato, ou seja, um mtodo que uma subclasse concreta deve implementar.
Classes abstratas no podem ser instanciadas.
Imagine um sistema de envio de
mensagens do tipo texto e fax.
No faria sentido ter uma instncia
de Mensagem, mas sim uma de
MensagemTexto ou MensagemFax.
Classe Abstrata
public abstract class Mensagem {
private String from;
private String msg;
public Mensagem( String remetente ) {
from = remetente;
}
public void corpoMensagem(String msg) {
this.msg = msg;
}
public abstract void enviar();
}
public class MensagemTexto extends Mensagem {
public MensagemTexto( String remetente ) {
super( remetente );
}
public void enviar() {
//envia uma mensagem de texto
}
}
public class MensagemFax extends Mensagem {
public MensagemFax( String remetente ) {
super( remetente );
}
public void enviar() {
//envia uma mensagem de fax
}
}
public class ServicoMensagens {
Mensagem m = new MensagemTexto(Daniel);
m.corpoMensagem(Mensagem de teste TXT);
m.enviar();
m = new MensagemFax(Daniel);
m.corpoMensagem(Mensagem de teste FAX);
m.enviar();
}
}
nterface
As interfaces atuam como um contrato para as classes que a implementam.
Nas interfaces voc define os mtodos que devero ser providos pela classes.
As classes que implementam esta interfaces, deve oferecer uma implementao para
cada mtodo definido na sua interface.
As classes podem implementar mais de uma interface.
Pode-se usar interfaces para uso de funes de callback.
public interface ObjetoVoador {
public void voar();
}
public class Aviao implements ObjetoVoador {
public void voar() {
//Eu vo usando turbinas
}
}
public class Passaro implements ObjetoVoador {
public void voar() {
//Eu vo usando asas
}
}
Cada classe implementam o
mtodo sua maneira. Mas o
mais importante que eles
ofeream uma implementao
para aquele mtodo da interface.
Interfaces so adequadas para
se definir formas (interfaces) de
acesso a sub-sistemas,
escondendo detalhes da sua
implementao.
nterface
//...
ObjetoVoador obj = new Aviao();
obj.voar();
//...
Vejamos como utilizar uma interface:
*** Interface Java no tem nada a ver com interfaces grficas.
nterface
public interface CadastroUsuario {
public void inserir( Usuario u ) throws Exception;
}
Agora, vamos ver um exemplo mais prtico de uso de interfaces em Java.
public class CadastroUsuarioBanco implements CadastroUsuario {
public void inserir( Usuario u ) throws Exception {
//insere os dados no banco
}
}
public class CadastroUsuarioArquivo implements CadastroUsuario {
public void inserir( Usuario u ) throws Exception {
//insere os dados no arquivo
}
}
//...
CadastroUsuario cad = new CadastroUsuarioBanco();
cad.inserir( usuario );
cad = new CadastroUsuarioArquivo();
cad.inserir( usuario );
//...
Type 8afe Enums
public enum Cargo {
PROGRAMADOR, ANALISTA, ARQUITETO, COORDENADOR
}
Outra funcionalidade adicionada ao Java 5 foi o Type Safe Enums, que permite se criar
enumeraes em Java, assim como existem em outras tecnologias.
definido pela palavra reservada enum, e cada item da enumerao representado por um
objeto do mesmo tipo do Enum.
A definio de um Enum nada mais do que a definio de um tipo especial de classe. Se
estiverem em outro pacote, precisam ser importadas, como classes normais.
Cargo c = Cargo.PROGRAMADOR;
Cargo x = Enum.valueOf( Cargo.class, ANALISTA );
for( Cargo y : Cargo.values() ) {
System.out.println( y );
}
Type 8afe Enums
public enum Cargo {
PROGRAMADOR( 1000 ),
ANALISTA( 2000 ),
ARQUITETO( 3000 ),
COORDENADOR( 4000 );
Cargo( int salario ) {
this.salario = salario;
}
private int salario;
public int getSalario() {
return this.salario;
}
}
As enumeraes ainda podem conter informaes e mtodos adicionais.
Cargo c = Cargo.PROGRAMADOR;
System.out.println( c + : + c.getSalario() );
Controle de Erros {Excees}
A linguagem Java oferece um precioso mecanismo de controle e tratamento de erros
dos programa, chamado de tratamento de excees. Em Java, todo e qualquer erro
chamado de exceo.
Este mecanismo de tratamento de erros em Java feito pelas diretivas try, catch e
finally. A sintaxe dessas diretivas a seguinte:
try {
cdigo_a_ser_executado
}
catch( Exceo ) {
cdigo_de_tratamento_de_erro
}
finally {
cdigo_sempre_executado
}
Podem existir mltiplos blocos catch no tratamento de erros. Cada um para um tipo
especfico de Exception.
public class TratamentoDeErro {
// array de 6 posies
int[] array = {0, 1, 2, 3, 4, 5};
try {
for(int i=0; i<10; i++ ) {
array[i] += i;
System.out.println("array[" + i + "] = " + array[i]);
}
System.out.println("Bloco executado com sucesso");
}
catch( ArrayIndexOutOfBoundsException e ) {
System.out.println("Acessou um ndice inexistente");
}
catch( Exception e ) {
System.out.println("Outro tipo de exceo ocorreu");
}
finally {
System.out.println("Isto SEMPRE executa!");
}
}
}
Todo erro, ou condio especial, em Java uma subclasse da classe Throwable. Porm existem 3
diferentes tipos de erros:
Erro de Runtime (java.lang.Runtime)
Erro de Sistema (java.lang.Error)
Erro Customizado (java.lang.Exception)
Os erros de Runtime so causados
por bugs do programa, que
desconhecemos, ou seja, uma
condio especial que sequer
havamos imaginado. Os erros de
Runtime so subclasses da classe
Runtime, que subclasse de
Exception.
Os erros de sistema so erros
imprevisveis, causados por falha do
sistema, como acesso a disco, erro do
banco de dados e etc. Estes erros so
subclasses da classe Error.
E os erros Customizados so erros ou
condies especiais previstas no
programa. Essos erros so subclasse
da classe Exception.
Gerando Erros {Excees}
Podemos querer tratar erros de lgica da nossa aplicao. Imagine um aplicativo de controle
bancrio, onde ele controla os dbitos em uma conta corrente. Um cenrio possvel o cliente
tentar fazer um saque no caixa, acima do valor do seu saldo. Poderamos tratar este caso
como uma exceo. Para isso, podemos criar nossa prpria classe de exceo, chamada
SaldoInsuficienteException, que deve ser uma subclasse de Exception. Quando nossa
aplicao identificar o cenrio acima, podemos ento lanar a nossa exceo e tratar isso.
Veja:
try {
if( saldo < valorRetirada ) {
throw new SaldoInsuficienteException( );
}
debitarValorNaConta( valorRetirada );
}
catch( SaldoInsuficienteException e ) {
System.out.println( Saldo Insuficiente para a retirada );
}
A diretiva throw lana um erro, para que um bloco catch o capture e faa o tratamento
necessrio.
Imagine que nossa classe possua um mtodo atmico, ou seja, uma funo especfica que deve ser
executada com sucesso ou abortada por interior. Ao invs de fazer o tratamento de erro dentro dela,
podemos fazer com que o prprio mtodo delegue o erro para o mtodo que o chamou. O exemplo
anterior um bom exemplo para isso. Imagine o seguinte mtodo:
public boolean fazerRetidada( double valorRetirada )
throws SaldoInsuficienteException {
if( saldo < valorRetirada ) {
throw new SaldoInsuficienteException();
}
debitarValorNaConta( valorRetirada );
return true;
}
A diretiva throws repassa um mtodo lanado dentro do mtodo e que no foi tratado por nenhum
bloco catch dentro dele.
Ele agora est mais simples, sem as diretivas try / catch / finally. Agora, ento podemos tratar o erro
num nvel mais alto, ou seja, onde o mtodo de fazerRetidada( ) foi chamado. Exemplo:
try {
fazerRetidada( 10000.0 );
}
catch( SaldoInsuficienteException e ) {
System.out.println( Saldo Insuficiente para a retirada );
}
Criando nossa Exceo customizada:
public class SaldoInsuficienteException extends Exception {
public SaldoInsuficienteException() {
super();
}
public SaldoInsuficienteException(String msg) {
super( msg );
}
}
Pacote java.ang
Este o pacote essencial do Java, e contm as classes centrais para operaes do Java.
O compilador automaticamente importa as classes deste pacote.
Possui classes importantes como: Object, String, StringBuffer, Math e as classes wrapper.
Classe: Object
a classe base do Java, ltimo antecessor de todas as outras classes.
Todas as classes possuem todos os mtodos da classe Object.
Possui os mtodos wait( ), notify( ) e notifyAll( ), que suportam controle de threads, alm dos mtodos
equals() e toString().
Classe: Math
A classe Math possui um conjunto de mtodos e 2 constantes para suportar computao matemtica.
A classe final e no pode ser estendida. O construtor private, portanto no pode ser instanciado.
Constantes: Math.PI e Math.E
Possui mtodo para clculo de: valor absoluto, arredondamento para cima e para baixo, comparao
do maior e menor valor, nmero aleatrio, arredondamento, seno, coseno, tangente e raiz quadrada.
Pacote java.ang
Estas classes encapsulam cadeias de caracteres Unicode (16 bits) e suportam alfabetos
internacionais.
Classe: String
A classe String guarda uma String imutvel.
Uma varivel da classe String aponta para uma rea de memria que contm a String.
Esta classe possui muitos mtodos para manipular a String.
String str = String 1;
String texto = str;
str = Nova String;
if( str.equals( texto ) ) {
//No igual
}
str = str.concat( com novo texto );
Classe: StringBuffer
Um objeto da classe StringBuffer representa uma String que pode ser modificada dinamicamente.
ideal para manipular grande quantidades de textos.
StringBuffer sb = new StringBuffer( Isto uma String );
sb.append( dentro de um StringBuffer );
sb.insert( 11, grande );
StringBuffer rev = new StringBuffer( 12345 );
rev.reverse();
Pacote java.ang
Classes Wrapper (Envoltrias)
Todo tipo primitivo em Java tem uma classe Wrapper correspondente. Esta classe encapsula um
valor de tipo primitivo e imutvel.
Double double
Float float
Long long
Integer int
Short short
Character char
Byte byte
Boolean boolean
Wrapper Class Tipo Primitivo boolean b = false;
Boolean wB = new Boolean( b );
wB = new Boolean( true );
Integer wInt = new Integer( 12345 );
wInt = new Integer( 123 );
int i = wInt.intValue();
if( Character.isDigit( 1 ) ) {}
Long wLong = Long.valueOf( 23L );
Long xLong = new Long( 33 );
//comparao
if( wLong.equals( xLong ) ) {}
Pacote java.ut
O pacote java.util contm classes do framework de collections, modelo de eventos, data, hora,
internacionalizao e classes de outras utilidades (StringTokenizer, etc).
Collections (Colees)
A interface Collection a interface base de todas as classes que implementam uma coleo. Ela
define mtodos para adicionar itens, limpar a coleo, remover itens, transformar para array, iterar
pelos itens, ver o tamanho e etc.
Vector
A classe Vector representa um array dimensionvel. Pode ser acessado por um ndice. O Vector
sincronizado, ou seja, ele sincroniza o acesso de processos concorrentes. O Vector pode armazenar
diferentes tipos de objetos ao mesmo tempo, pois ele recebe um Object como argumento.
Vector vec = new Vector( );
vec.add( String 1 );
Iterator it = vec.iterator( );
while( it.hasNext( ) ) {
String str = (String) it.next( );
}
Pacote java.ut
ArrayList
Esta classe muito similar classe Vector, porm ela no sincronizada, portanto, mais rpida.
ArrayList list = new ArrayList( );
list.add( String 1 );
Iterator it = list.iterator( );
while( it.hasNext( ) ) {
String str = (String) it.next( );
}
List
As classes Vector, ArrayList, LinkedList e outras, implementam a interface List.
Essas colees, ento, podero ser acessadas pelo mtodos comuns da interface List.
List lst = new Vector( );
List lst2 = new ArrayList( );
//...
Pacote java.ut
Hashtable
O Hashtable guarda valores com chave e valor, no permitindo valores null. Para recuperar um valor,
pede-se pelo seu nome (chave). Pode-se pegar um Enumeration com todas as chaves da coleo.
Hashtable numbers = new Hashtable();
numbers.put("one", new Integer(1));
numbers.put("two", new Integer(2));
numbers.put("three", new Integer(3));
Integer n = (Integer)numbers.get("two");
if(n != null) {
System.out.println("two = " + n);
}
Enumeration e = numbers.keys();
while( e.hasMoreElements() ) {
String key = (String) e.nextElement();
System.out.println(key+=+numbers.get(key));
}
Pacote java.ut
Properties
Esta classe uma coleo de propriedades, do tipo chave e valor.
Os dados pode ser escritos ou lidos de uma Stream (ver sobre Stream).
Cada chave da propriedade te seu valor, nico.
Esta classe estende a classe Hashtable.
import java.io.*;
import java.util.*;
public class Propriedades {
File f = new File(C:\\teste.prop);
FileInputStream fis = null;
try {
fis = new FileInputStream( f );
Properties prop = new Properties( );
prop.load( fis );
Enumeration e = prop.keys();
while( e.hasMoreElements() ) {
String chave = (String) e.nextElement();
System.out.println( chave + = + prop.getProperty(chave) );
}
} catch( Exception e ) {
e.printStackTrace();
} finally {
if( fis != null ) try { fis.close(); } catch(Exception e) {}
}
}
}
Pacote java.ut
Properties
Gravando os dados de um Properties:
import java.io.*;
import java.util.*;
public class Propriedades2 {
File f = new File(C:\\teste.prop);
FileOutputStream fos = null;
FileInputStream fis = null;
try {
fis = new FileInputStream( f );
Properties prop = new Properties( );
prop.load( fis );
fis.close();
prop.setProperty( d, D );
prop.setProperty( e, E );
fos = new FileOutputStream( f );
prop.store( fos, null );
} catch( Exception e ) {
e.printStackTrace();
} finally {
if( fos != null ) try { fos.close(); } catch(Exception e) {}
}
}
}
Pacote java.ut
StringTokenizer
Esta classe permite quebrar uma String em tokens (palavras), pelo caracter separador.
StringTokenizer st = new StringTokenizer(isto um teste");
while( st.hasMoreTokens() ) {
System.out.println( st.nextToken() );
}
StringTokenizer st = new StringTokenizer(outro;teste;da;classe,;);
while( st.hasMoreTokens() ) {
System.out.println( st.nextToken() );
}
Pacote java.ut
Date
A classe Date representa um instante de tempo especfico, medido em milisegundos.
O tempo em milisegundos calculado a partir do dia 01/Jan/1970.
Date agora = new Date(); //instante atual
GregorianCalendar
Esta classe uma implementao concreta da classe java.util.Calendar, e ofere mtodos e
funcionalidades para manipular datas no formato do calendrio gregoriano.
Calendar calendar = new GregorianCalendar();
Date trialTime = new Date();
calendar.setTime(trialTime);
System.out.println("ERA: " + calendar.get(Calendar.ERA));
System.out.println("YEAR: " + calendar.get(Calendar.YEAR));
System.out.println("MONTH: " + calendar.get(Calendar.MONTH));
System.out.println("WEEK_OF_YEAR: " + calendar.get(Calendar.WEEK_OF_YEAR));
System.out.println("WEEK_OF_MONTH: " + calendar.get(Calendar.WEEK_OF_MONTH));
System.out.println("DATE: " + calendar.get(Calendar.DATE));
System.out.println("DAY_OF_MONTH: " + calendar.get(Calendar.DAY_OF_MONTH));
System.out.println("DAY_OF_YEAR: " + calendar.get(Calendar.DAY_OF_YEAR));
System.out.println("DAY_OF_WEEK: " + calendar.get(Calendar.DAY_OF_WEEK));
System.out.println("DAY_OF_WEEK_IN_MONTH: " +
calendar.get(Calendar.DAY_OF_WEEK_IN_MONTH));
System.out.println("AM_PM: " + calendar.get(Calendar.AM_PM));
System.out.println("HOUR: " + calendar.get(Calendar.HOUR));
System.out.println("HOUR_OF_DAY: " + calendar.get(Calendar.HOUR_OF_DAY));
//
Auto Boxing / Unboxing
Antes do Java 5, a manipulao de dados entre tipos primitivos e classe wrappers era
trabalhosa e chata. No Java 5 foi inserido o conceito de Auto Boxing e Unboxing, que permite a
converso do tipos primitivos em wrappers e vice-versa, de uma maneira muito mais intuitiva e
produtiva. Este conceito tambm se aplica a passagem de parmetros a mtodos.
Antigamente fazamos assim:
Hoje o uso foi facilitado para:
int x = 10;
Integer i = new Integer(x);
Integer y = x + i.intValue();
x = i.intValue();
i = new Integer(y);
int x = 10;
Integer i = x;
Integer y = x + i;
x = i;
i = y;
Generics
Generics foi introduzido no Java 5, para ajudar o desenvolvedor a escrever cdigo mais claros,
conciso e diminuir a ocorrncia de erros de tempo de execuo, principalmente durante a
manipulao de colees de objetos (ClassCastException).
Com Generics podemos definir qual o tipo de dados vamos trabalhar com uma determinada
coleo ou lista. No exemplo abaixo, implementado sem o uso de Generics, adicionamos
qualquer tipo de objetos na lista e quando os recuperamos, esperando um tipo particular de
objeto, podemos nos deparar com um ClassCastException, como na linha 4, o que comum
ocorrer.
List l = new ArrayList();
l.add( new Integer(1) );
l.add( new Double(2.0) );
Integer i = (Integer) l.get(1);
Com Generics este problema eliminado, e a verificao de tipos feita em tempo de
compilao, no mais em tempo de execuo, evitando problemas futuros.
List<Integer> l = new ArrayList<Integer>();
l.add( new Integer(1) );
l.add( new Double(2.0) ); // erro
Integer i = l.get(1);
Generics
Podemos, inclusive, definir classes (tipos) que tambm aceitam o uso de Generics, para definir
o tipo de objeto que eles trabalharo.
public class ListaLigada<T> {
public <T> buscar( int i ) {
//busca e retorna o item
}
public void adicionar( <T> t ) {
// adiciona item
}
public void remover( <T> t ) {
// remove o item
}
}
/O
A I/O (entrada e sada) do Java pode ser facilmente manipulada utilizando as classes do pacote
java.io, que trabalham com fluxos de dados (data streams), serializao e sistemas de arquivos.
Atualmente existe um novo pacote, chamado de java.nio (new I/O), que uma estenso do pacote
padro de I/O, porm no vamos estud-lo neste curso.
File
Esta classe uma representao abstrata de um arquivo ou diretrio do arquivo de sistemas.
File arq = new File(C:\\texto.txt);
//arq representa o arquivo texto.txt
File dir = new File(C:\\tmp);
//dir representa o diretrio c:\tmp
if( dir.exists() && dir.isDirectory() ) {
String[] arqs = dir.list(); //lista os arquivos
}
A classe File oferece mtodos comuns para verificar se o caminho existe na mquina local, criar ou
remover o arquivo/diretrio com o nome especificado, pegar o caminho completo do arquivo/diretrio,
lista todos os arquivos do caminho do diretrio, verificar as propriedades do arquivo (data, readonly,
etc) e outras funcionalidades.
O Java usa duas representaes para textos: Unicode internamente e UTF para I/O.
No acessaremos os dados destes arquivos diretamente. Para isso faremos uso dos Streams (fluxos)
de entrada e sada de dados, da classe RandomAccessFile ou dos Reader e Writer.
/O
RandomAccessFile
A classe RandomAccessFile oferece recursos para acessar arquivos no-seqencialmente, acessar
uma posio do arquivo, gravar ou ler os dados nele.
O construtor da classe recebe dois argumentos: uma instncia de File e uma String com o modo de
acesso, que pode ser r para leitura e rw para escrita e leitura. Existe um segundo construtor que,
ao invs do File, recebe uma String com o caminho do arquivo e uma String com o modo de acesso.
Se o arquivo no existe, um novo arquivo vazio ser criado.
Em caso de erros, uma exceo do tipo java.io.IOException ou java.io.FileNotFoundException ser
lanada.
Esta classe oferece mtodos para verificar o tamanho (em bytes) do arquivo, pegar a posio corrente
no arquivo e posicionar em numa nova posio, a partir da posio inicial.
A classe oferece mtodos para ler byte a byte do arquivo ou mtodo para ler grupos de bytes, em um
nivel mais alto de tipos de dados, como int, long, char, double, etc.
RandomAccessFile raf = new RandomAccessFile( arq, rw );
//gravando dados no arquivo
raf.writeUTF( Saldo= );
raf.writeDouble( 100.0 );
//lendo a partir da posio inicial
raf.seek( 0 );
String txt = raf.readUTF();
double saldo = raf.readDouble();
raf.close(); //sempre feche o recurso
/O
Streams
Os stream so um meio de fluxo dos dados. Esses dados podem vir
tanto de um arquivo, quanto pela rede ou um dispositivo conectado ao
computador.
Em Java, generalizamos esse fluxo como stream de entrada e sada, o
que facilita e torna padronizado o acesso a esses dados lidos e
gravados.
Existem duas classes abstratas, que so a base dos streams em Java,
que so: InputStream (para entrada de dados) e OutputStream (para
sada de dados).
Esses stream trabalham com bytes de dados, o que pode ser, muitas
vezes, chato de manipular.
Para isso temos os streams de baixo e alto nvel.
Os streams de baixo nvel trabalham com bytes, ou seja, lem e
escrevem bytes. Os streams de alto nvel, lem e escrevem dados num
formato geral (primitivos e Strings), utilizando-se dos streams de baixo
nvel.
/O
Low-Level Streams
As classes FileInputStream e FileOutputStream so duas classes de baixo nvel para leitura e
gravao de dados de um arquivo em disco. Essas duas classes possuem dois construtores, um
construtor recebe um File e o outro recebe uma String com o pathname do arquivo.
Essas classes trabalham apenas com leitura e escrita de bytes dos dados. Para tanto, elas possuem
os mtodos read( ) e write( ), respectivamente. Ambas possuem o mtodo close( ).
A classe FileInputStream possui outros mtodos como: available( ) e skip( ).
FileInputStream fis = new FileInputStream( arq );
byte byteLido = (byte) fis.read();
byte[] bytes = new byte[10];
fis.read( bytes );
System.out.println( bytes );
fis.close();
FileOutputStream fos = new FileOutputStream( arq );
fos.write( String a ser gravada.getBytes() );
fos.close();
Existem ainda outras classes de low-level. So elas: InputStream, OutputStream, que so as classes
pai das classes de stream de baixo nvel. Alm das classes: ByteArrayInputStream,
ByteArrayOutputStream, PipedInputStream e PipedOutputStream.
/O
High-Level Streams
Os filtros de stream de alto-nvel permitem a leitura e a escrita de dados de outros tipos alm dos
bytes dos dados. Essas classes estendem as classes FilterInputStream e FilterOutputStream para
entrada e sada. Na verdade as classes no lem diretamente de um arquivo, mas sim de um outro
stream.
DataInputStream dis = new DataInputStream( fis );
double d = dis.readDouble();
String s = dis.readUTF();
dis.close();
fis.close(); //feche todos os streams
DataOutputStream dos = new DataOutputStream( fos );
dos.writeDouble( 100.99 );
dos.writeUTF(Texto String UTF);
dos.close();
fos.close(); //feche todos os streams
Existem ainda outras classes de high-level. So elas: BufferedInputStream, BufferedOutputStream,
que so as classes que utilizam buffer de memria. Alm das classes: PrintStream, para gravar tipos
primitivos como representaes de caracter e a classe PushbackInputStream.
/O
Reader e Writer
Os reader e writer so baseado na leitura e escrita de dados no formato Unicode.
Os arquivo devem conter apenas dados no formato UTF.
Os Readers e Writers podem ser low-level e high-level. Um bom exemplo de classes Readers e
Writers low-level so as classe FileReader e FileWriter.
File arq = new File(C:\\texto2.txt);
FileWriter fw = new FileWriter( arq );
fw.write(Linha 1\nLinha 2\nLinha 3\nLinha 4);
fw.close();
FileReader fr = new FileReader( arq );
LineNumberReader lnr = new LineNumberReader( fr );
String s;
while( (s = lnr.readLine()) != null ) {
System.out.println(lnr.getLineNumber() + : + s);
}
lnr.close();
fr.close();
As classes high-level suportam os mtodos dos low-level, mais mtodos para manipular leitura em
buffer, leitura de linha e etc.
Todas essas classes estendem das classes Reader e Writer.
/O
Serializao de Objetos
Serializao o processo de destrinchar o objeto e persist-lo em qualquer lugar, ou seja, ele grava o
objeto com o dados do seu estado atual, bem como os objetos a ele relacionados.
Os objetos a serem serializados devem implementar a interface java.io.Serializable.
Esses objetos, utilizando os streams podem tambm trafegar pela rede.
Pessoa pess = new Pessoa();
pess.setNome(Joo);
pess.setIdade(30);
File arq = new File(C:\\pessoa.ser);
ObjectOutputStream oos = new ObjectOutputStream( fos );
oos.writeObject( pess );
oos.close();
fos.close();
Os atributos marcados com o modificador transient no sero serializados.
File arq = new File(C:\\pessoa.ser);
ObjectInputStream ois = new ObjectInputStream( fis );
Pessoa p = (Pessoa) ois.readObject();
ois.close();
fis.close();
/O
Sockets
Os Sockets servem para comunicao remota entre computadores, servindo como as pontas da
comunicao via o protocolo TCP/IP.
Os Sockets se comunicam entre s por meio de Streams, por onde os dados (bytes) so enviados, da
mesma maneira que tratamos os dados de arquivos com streams. Podemos, inclusive, enviar objetos
por meio de streams que trabalham com serializao de objetos.
Nesse modelo de comunicao, um SocketServer espera conexes de Sockets clientes.
Socket soc = new Socket("127.0.0.1",999);
OutputStream os = soc.getOutputStream();
DataOutputStream dos = new DataOutputStream( os );
dos.writeUTF( mensagem enviada );
dos.close();
os.close();
soc.close();
ServerSocket soc = new ServerSocket(999);
InputStream is = soc.accept().getInputStream();
DataInputStream dis = new DataInputStream( is );
System.out.println( dis.readUTF() );
dis.close();
is.close();
soc.close();
/O
Formatter
Foi introduzido no Java 5.
Simplifica a maneira de escrever os dados.
Inspirado no printf() do C/C++.
A classe Formatter faz parte do pacote java.util.
A classe String possui o mtodo format() e a classe PrintStream possui o mtodo printf().
StringBuilder sb = new StringBuilder();
Formatter f = new Formatter( sb, new Locale(pt_BR) );
f.format( %.2f %tF, 2.456f, new Date() );
System.out.println( sb.toString() );
// imprime: 2.45 2005-07-01
String s = String.format(
new Locale(pt_BR),
Hoje %1$te de %1$tB de %1$tY,
Calendar.getInstance()
);
// Hoje 1 de Julho de 2005
System.out.printf(%2$2s%1$2s-%3$s, a, b, c);
// imprime: b a-c
/O
Scanner
Foi introduzido no Java 5.
Simplifica a maneira de ler os dados.
Inspirado no scanf() do C/C++.
A classe Scanner faz parte do pacote java.util.
Scanner s = new Scanner(System.in);
int i = s.nextInt();
// l o prximo inteiro do teclado
Scanner s = new Scanner(new File(teste.csv));
s = s.useDelimiter(\\s*,\\s*);
while( sc.hasNextShort() ) {
short i = sc.nextShort();
}
// l um arquivo csv com valores short
// e pega os valores, delimitados por vrgula
Arquivos ]ar
Os arqivos jar so um forma de empacotar as classes de uma API ou aplicao. JAR a sigla para
Java ARchive.
Ao invs de termos vrias classes soltas e espalhadas, podemos agrup-las todas em um arquivo jar.
O arquivo jar no nada mais que um arquivo zip, com extenso .jar.
A ferramento jar que vem no JDK nos auxilia na gerao dos pacotes jar.
Para criar o jar, execute a seguinte linha de comando:
jar -cf nome-do-jar.jar *.class
Ele criar um novo arquivo chamado nome-do-arquivo.jar com todas as classes java dentro dele.
Outros arquivos podem ser adicionados ao jar, alm das classes do java.
Empacotando os arquivos em um jar podemos utiliz-lo incluindo o jar no classpath do programa:
java cp nome-do-jar.jar ClassePrincipal
Onde a ClassePrincipal a classe que contm o arquivo jar.
Como todos os arquivos de dentro do jar estaro no classpath, podemos acess-lo de dentro do java
da seguinte forma:
getClass().getResourceAsStream( nome-do-arquivo );
Threads
Threads so uma maneira de se programar aplicaes com processamento paralelo, ou seja, vrias
subprocessos executando ao mesmo tempo. Este um assunto bem extenso e requer muita ateno,
porm vamos apenas dar uma introduo sobre Threads em Java.
As Threads possui um ciclo de estados definido, como segue na figura:
Quando uma Thread entra no estado dead, ela no pode ser mais usada e deve ser descartada.
Para uma classe ser executada em paralelismo, ela deve estender a classe java.lang.Thread ou
implementar a classe java.lang.Runnable.
Toda Thread deve implementar o mtodo public void run( ), que o inicio da execuo dela.
public class MinhaThread extends Thread {
public void run() {
for( int i=0; i<100; i++ ) {
System.out.println("Thread : "+i);
try {
wait();
} catch(Exception e) {}
}
}
}
Threads
public class ExemploThreads {
ExemploThreads ex = new ExemploThreads();
ex.executar();
}
MinhaThread m = new MinhaThread();
m.start();
for( int i=0; i<100; i++ ) {
System.out.println("Normal-"+i);
try {
wait(1);
}
}
}
Perceba que, para iniciar a
Thread, na verdade foi
chamado o mtodo start( )
e no o mtodo run( ).
public class MinhaThread implements Runnable {
public void run() {
for( int i=0; i<100; i++ ) {
System.out.println("Thread : "+i);
try {
wait();
}
}
}
Threads
public class ExemploThreads {
ExemploThreads ex = new ExemploThreads();
ex.executar();
}
MinhaThread m = new MinhaThread();
Thread t = new Thread( m );
t.start();
for( int i=0; i<100; i++ ) {
System.out.println("Normal-"+i);
try {
wait(1);
}
}
}
Quando a classe
implementa a interface
Runnable, ao invs de
estender a classe Thread,
deve ser criada um
Thread, passando a classe
que implementa Runnable
como parmetro.
Referncias Bibliograficas
Core Java 2, Fundamentos Volume 1
Horstmann, Cay / Cornell, Gary
Editora: Makron Books
Complete Java 2 Certification Study Guide
Heller, Phillip / Roberts, Simon
Editora: Sybex
Desenvolvendo aplicaes com UML
Ana Cristina Mello
Editora: Brasport
Applying UML and Patterns
Larman, Craig
Websites Relacionados
Site Oficial do Java
http://java.sun.com
GUJ Grupo de Usurios Java
http://www.guj.com.br
SoU Java Sociedade dos Usurios Java
http://www.soujava.org.br
Java World
http://www.javaworld.com
Google
http://www.google.com

Curso Java

Încărcat de

Informații document

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Curso Java

Încărcat de

Drepturi de autor:

Formate disponibile

Curso de Introduo ao Java

S-ar putea să vă placă și