Curso Java - Daniel Destro

Curso de Introdução ao Java
Curso de
Introdução
ao Java
Daniel Destro do Carmo
Softech Network Informática
[email protected]
Curso de Introdução ao Java
Objetivo do curso
Conhecer a Plataforma Java
Conhecer a sintaxe e as características do Java
Conhecer as APIs do Java
Escrever aplicações simples em Java
Entender e aplicar conceitos da Programação Orientada a Objetos
Curso de Introdução ao Java
A Tecnologia Java
A tecnologia Java é composta por uma gama de produtos, baseados no poder da rede e na idéia
de que um software deveria ser capaz de rodar em diferentes máquinas, sistemas e dispositivos.
Por diferentes dispositivos entendemos: computadores, servidores, notebooks, handhelds, PDAs
(Palm), celulares, TV, geladeiras e tudo mais o que for possível.
Os programas feitos em Java rodam em diferentes ambientes graças a um componente da
plataforma chamado JVM (Java Virtual Machine) – que é um tipo de tradutor de código Java para
instruções específicas de cada sistema e dispositivo.
A tecnologia Java foi lançada em 1995, e desde então tem crescido em popularidade e se tornado
uma plataforma muito estável e madura. Atualmente a tecnologia Java está em sua segunda
versão, 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
Curso de Introdução ao Java
A Tecnologia Java – Java Standard Edition (JSE)
A JSE é uma rica plataforma que oferece um completo ambiente para o desenvolvimento de
aplicações para clientes e servidores. A J2SE é também a base das tecnologias J2EE e Java Web
Services, e é dividida em dois grupos conceituais: Core Java e Desktop Java.
A Sun distribui a JSE 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: compilação,
debugging, geração de documentação (javadoc), empacotador de componentes (jar) e a JRE, que
contém a JVM e outros componentes necessários para rodar aplicações Java.
Curso de Introdução ao Java
A Tecnologia Java – Java Enterprise Edition (JEE)
A tecnologia JEE não é um produto, mas sim de uma especificação definida pela Sun.
Simplifica as aplicações empresariais e multi-camadas
É baseando nos componentes padronizados, modulares e reusáveis, os (EJB)
Oferecendo um conjunto completo de serviços para estes componentes
Manipula muitos detalhes do comportamente da aplicação automaticamente
Não precisa reaprender a programa, pois se utiliza dos mesmo recursos do Java (JSE)
Roda em servidores de aplicações JEE diferentes e padronizados pela Sun
A tecnologia JEE não está no escopo deste curso
Curso de Introdução ao Java
A Tecnologia Java – Java Micro Edition (JME)
A tecnologia JME é voltada para aplicações que rodam em pequenos dispositivos como celulares,
PDAs, smart cards e etc. Ela possui uma API bastante completa para o desenvolvimento de
aplicações para pequenos dispositivos. A tecnologia JME não está no escopo deste curso.
A Tecnologia Java – Web Services
Baseada na tecnologia XML
Usado para troca de informações pela rede
Muito utilizado por sites de e-commerce
Utiliza padrões definidos (SOAP, ...)
A API JAXP (Java API for XML Processing) oferece facilidades para Web Services
Curso de Introdução ao Java
O que é Java, afinal???
Java é uma linguagem de programação
Java é um ambiente de desenvolvimento
Java é uma completa plataforma de soluções para tecnologia
Java
J2SE
CORBA
API
JINI
SDK
AWT
JAXP
J2EE
JSP
JRE
JNI
JDBC
J2ME
JVM
RMI
Servlet
XML
Swing
Curso de Introdução ao Java
Instalando o SDK do Java (JDK)
Faça o download do JDK para a sua plataforma (http://java.sun.com).
Execute o arquivo de instalação – é fácil instalar (Next, Next, Finish).
Crie uma variável de ambiente chamada JAVA_HOME, que deve guardar o
caminho do diretório 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
Curso de Introdução ao Java
Fundamentos da Linguagem Java
Java não necessita de um editor específico (Notepad é o suficiente)
Existem dezenas de editores completos (IDEs) para Java (livres ou não)
É portavel para qualquer ambiente/plataforma - “Write once, run everywhere!”
Java é orientado ao objeto
Os programas em Java, quando compilados, são convertidos para um código intermediário
(bytecode), que é verificado, carregado na memória e então interpretado pela JVM (Java Virtual
Machine). O Java NÃO gera executáveis, nem código nativo para o SO.
Curso de Introdução ao Java
Primeiro Programa em Java
Arquivo: PrimeiroPrograma.java
public class PrimeiroPrograma {
public static void main( String[] args ) {
System.out.println( "Meu primeiro programa em Java" );
}
}
Compilando o código-fonte:
javac PrimeiroPrograma.java
Executando o programa:
java PrimeiroPrograma
Saída gerada:
Meu primeiro programa em Java
Todo programa começa
pelo método main( ).
Que é o seu ponto de
partida.
Curso de Introdução ao Java
Método main( )
A assinatura do método main( ), que é o ponto de partida de um programa Java e
deve ser feito como abaixo:
public static void main( String[] args ) {
}
O parâmetro passado para o método main( ) é um array de Strings, que contém os
valores dos argumentos passados na linha de comando da execução do programa.
Exemplo:
java PrimeiroPrograma argumento1 argumento2 argumento3
Cada palavra passada como argumento é um ítem do array, parâmetro do main( ).
Curso de Introdução ao Java
Comentários
Os comentários em Java podem ser por linha ou em bloco:
Por linha:
// isto é um comentário e inicia com duas barras.
Em bloco:
/*
Comentário em bloco aceita múltiplas linhas
Não utilize comentários aninhados
*/
Curso de Introdução ao Java
Variáveis de Tipos Primitivos
Em Java, uma variável deve:
ser declarada antes de ser usada
ter um tipo definido (o tipo não muda)
iniciar o valor da variável antes de usá-la
ser usada dentro do escopo (método ou bloco)
Declaração: <tipo da variável> <nome da variável>;
Declaração e atribuição: <tipo> <nome> = <valor>;
Tipo
Tamanho
(bits)
Valor Mínimo
Valor Máximo
Sem Sinal
boolean
1
false
true
X
char
16
0
216 - 1
X
byte
8
-27
27 - 1
short
16
-215
215 - 1
int
32
-231
231 - 1
long
64
-263
263 - 1
float
32
double
64
Curso de Introdução ao Java
Variáveis de Tipos Primitivos
public class TiposPrimitivos {
public static void main( String[] args ) {
//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';
//valor ASCII para 'A'
letraA = 65;
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;
//declaração múltipla
int var1=0, var2=1, var3=2, var4;
}
}
Curso de Introdução ao Java
Exercícios
1) Declare uma variável que represente um número inteiro e inicie com o valor “10”.
2) Declare três variáveis com tipos diferentes, sem atribuir valor. Depois atribua um valor
qualquer a elas.
3) Crie uma variável do tipo int, atribuindo um valor a ela. Depois crie uma variável do tipo
double, atribuindo a ela o valor da primeira variável criada.
Curso de Introdução ao Java
String
String é uma classe que manipula cadeias de caracteres
A classe String possui métodos para essas manipulações
Trabalha com Pool de Strings para economizar memória
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 CONTEÚDO DAS STRINGS
}
System.out.println( “Tamanho da String: “ + str.length() );
System.out.println( “SubString: “ + str.substring(0, 10) );
System.out.println( “Caracter na posição 5: “ + str.charAt(5) );
Curso de Introdução ao Java
String
Outros métodos úteis da classe String:
String str = “Isto é uma String do Java”;
// O método split quebra a String e várias 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 começo e o fim da String – retorna boolean
}
str = str.trim();
// elimina os espaços em branco no início e fim
str = str.replace(‘a’,’@’);
// substitui os caracteres
// substitui uma palavra (usa expressões regulares)
str = str.replaceAll(“String”,”Cadeia de caracteres”);
Curso de Introdução ao Java
Exercícios
3) Declare uma variável do tipo String com a frase “Curso de Java”.
4) Concatene na variável criada acima a frase “ – Exemplo String”.
5) Imprima na tela (console) o número de caracteres da String.
6) Crie uma nova String, pegando o pedaço da primeira String que compreenda a frase
“Exemplo String”.
Desafio 1:
Faça o mesmo que o exercício 6, porém ser usar posição (índice) fixa.
Curso de Introdução ao Java
Literais
Um valor literal é aquele especificado no próprio código.
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 notação científica, respectiv.)
Caracteres de escape do tipo char:
'\n' – quebra de linha
'\r' – retorno de carro
'\t' – tabulação
'\\' – barra invertida
'\b' – backspace
'\f' – form feed
'\'' – aspa simples
'\”' – aspa dupla
char:
'A', '\u0041', 65 (caracter ascii, código Unicode e código ascci, respectivamente)
String:
String str = “Isto é uma literal String”;
Curso de Introdução ao Java
Palavras-Chaves do Java
O Java possui 53 palavras-chaves e palavras reservadas:
abstract
class
extends
implements
null
strictfp
true
assert
const
false
import
package
super
try
boolean
continue
final
instanceof
private
switch
void
break
default
finally
int
protected
synchronized
volatile
byte
do
float
interface
public
this
while
case
double
for
long
return
throw
catch
else
goto
native
short
throws
char
enum
if
new
static
transient
Nenhuma das palavras acima podem ser usadas como identificadores (nomes de variáveis,
atributos, classes), ou para outro propósito, a não ser o especificado para aquela determinada
palavra. As palavras goto e const, apesar de reservadas, não tem utilizadade algum no Java.
Curso de Introdução ao Java
Identificadores
As regras para nomeação de identificadores (variáveis, nomes de função, classes ou label)
seguem a seguinte regra:
nomes nomes devem começar com letra ou os caracteres _ ou $
os caracteres seguintes podem conter números, letras, _ ou $
Veja exemplos de nomes de identificadores:
valor
$preco
20itens
_teste
INT
// válido
// válido
// inválido
// válido
// válido
Observação: O Java considera diferença entre maiúsculas e minúscula.
Curso de Introdução ao Java
Operadores
Veremos agora os operadores da linguagem Java, que agregam
importantes funcionalidades aos programas.
Eles possuem uma ordem de precedência na execução da expressão.
Para garantir a ordem de precedência desejada, agrupe as expressões
com parênteses.
Curso de Introdução ao Java
Operadores Unários
Incremento e Decremento: ++ e -int a = 0;
int b = a++;
// incrementado
int c = ++a;
// incrementado
b = a--;
// decrementado
c = --a;
// decrementado
depois de atribuir
antes de atribuir
depois de atribuir
antes de atribuir
Mais e Menos Unário: + e int x = +3;
// x recebe o positivo 3
x = -x;
// x recebe -3, neste caso
Inversão de Bits: ~
int i = ~1;
// i = -2
(os bits foram invertidos)
Complementar booleano: !
boolean falsidade = ! (true);
// inverte o valor booleano
Conversão de Tipos: (tipo)
double d = 1.99;
int i = (int) d;
// converte de double p/ int (perda de precisão)
Curso de Introdução ao Java
Operadores Aritméticos
Multiplicação e Divisão: * e /
int um = 3 / 2;
float umEmeio = (float) 3 / 2;
double xyz = umEmeio * um;
// divisão de inteiros gera um inteiro
// ocorre promoção aritmética para float
// ocorre promoção aritmética para float
Módulo: %
int resto = 7 % 2;
// resto = 1
Adição e Subtração: + e long l = 1000 + 4000;
double d = 1.0 – 0.01;
Concatenação:
long var = 12345;
String str = “O valor de var é “ + var;
Na concatenação de Strings, as variáveis ou literais são promovidos a String antes:
String str = “O valor de var é “ + Long.toString( var );
Curso de Introdução ao Java
Operadores de Deslocamento
Deslocamento à direita: >>
Número: 192
Binário:
Right Shift de 1
Right Shift de 7
Número: -192
Binário:
Right Shift de 1
Right Shift de 7
bit:
bits:
|00000000|00000000|00000000|11000000|
|00000000|00000000|00000000|01100000|
|00000000|00000000|00000000|00000001|
int i = 192 >> 1
int i = 192 >> 7
bit:
bits:
|11111111|11111111|11111111|01000000|
|11111111|11111111|11111111|10100000|
|11111111|11111111|11111111|11111110|
int i = -192 >> 1
int i = -192 >> 7
|00000000|00000000|00000000|11000000|
|00000000|00000000|00000001|10000000|
|00000000|00000000|01100000|00000000|
int i = 192 << 1
int i = 192 << 7
|11111111|11111111|11111111|01000000|
|11111111|11111111|11111110|10000000|
|11111111|11111111|10100000|00000000|
int i = -192 << 1
int i = -192 << 7
Deslocamento à esquerda: <<
Número: 192
Binário:
Left Shift de 1 bit:
Left Shift de 7 bits:
Número: -192
Binário:
Left Shift de 1 bit:
Left Shift de 7 bits:
Deslocamento à direita, sem sinal: >>>
Número: 192
Binário:
|00000000|00000000|00000000|11000000|
Right Shift de 1 bit:
|00000000|00000000|00000000|01100000|
Right Shift de 7 bits:
|00000000|00000000|00000000|00000001|
Número: -192
Binário:
|11111111|11111111|11111111|01000000|
Right Shift de 1 bit:
|01111111|11111111|11111111|10100000|
Right Shift de 7 bits:
|00000001|11111111|11111111|11111110|
int i = 192 >>> 1
int i = 192 >>> 7
int i = -192 >>> 1
int i = -192 >>> 7
Curso de Introdução ao Java
Exercícios
7) Calcula a área de uma circunferência com raio 12, onde PI = 3.1415 e área = PI * r2.
8) Calcule o resto da divisão de 99 por 4.
9) Divida um número por 2 sem utilizar o operador /.
10) Multiplique um número por 8, sem utilizar o operador *.
Desafio 2:
Declare um inteiro de valor 10 e mostre na tela o valor do terceiro bit mais significativo (da
direita para a esquerda).
Curso de Introdução ao Java
Operadores de Comparação
Comparação ordinal: >, >=, < e <=
Compara tipos primitivos numéricos e o tipo char.
boolean b = ( 10 < 3 );
boolean w = (x <= y);
if( x >= y ) { }
Operador instanceof
Compara o tipo da classe de uma referência de um objeto.
String str = “Uma String”;
if( str instanceof String ) { }
if( srt instanceof Object ) { }
// true
// true
Comparação de Igualdade: == e !=
Comparam tipos primitivos, valores literais e referências de objetos.
if( abc == 10 ) { }
boolean b = ( xyz != 50 );
if( refObj1 == refObj2 ) { }
Curso de Introdução ao Java
Operadores de Bits: &, | e ^
Numéricos Inteiros:
Operando A: 1
Operando B: 3
Binário de A: 00000001
Binário 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
Curso de Introdução ao Java
Operadores Lógico de Curto-Circuíto: && e ||
Estes operadores não precisam testar toda a expressão.
Ele pára assim que uma das condições o satisfaça.
O retorno da expressão é um boolean
if( (a>10) && (b<5) ) {
// isso
}
if( (x==y) || (b<5) ) {
// aquilo
}
boolean b = x && y || z;
Curso de Introdução ao Java
Operador Condicional: ?
É também conhecido como operador ternário, pois trabalha com 3 operandos.
Ele avalia o primeiro operando.
Caso a avaliação retorne true, ele executa o segundo operando.
Senão, ele executa o terceiro operando.
O segundo e terceiro operandos DEVEM ser do mesmo tipo (senão, use cast).
O código do operador ternário abaixo:
int x = 10;
int y = (x > 10) ? x : x+1;
é semelhante ao código abaixo:
int x = 10;
int y;
if( x > 10 ) {
y = x;
} else {
y = x + 1;
}
Curso de Introdução ao Java
Operadores de Atribuição
Estes operadores atribuem um novo valor a uma variável ou expressão.
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;
Curso de Introdução ao Java
Conversão de Tipos Primitivos
Permite a conversão entre tipos diferentes
Deve ser explícito quando for de um tipo maior para um menor (narrowing)
Pode ser implícito (ou explícito) de um tipo menor para um maior (widening)
Conversão para tipos menores pode causar perda de precisão e truncamento.
double d = 1.99d;
int i = (int) d;
// i recebe o valor 1
short s = 15;
long x = s;
long y = (long) s;
// conversão widening
// não é necessário
O widening segue o sentido das flechas. Narrowing é no sentido contrário.
Curso de Introdução ao Java
Promoção Aritmética
Ocorre com as operações aritméticas entre tipos primitivos numéricos diferentes.
O menor tipo é automaticamente convertido para o maior tipo.
public class PromocaoMatematica {
public static void main( String[] args ) {
double d = 100.99;
int i = 100;
//aqui ocorre a promoção matemática
//i é convertido para double e então multiplicado
d = d * i;
//ao contrário é necessário informar o casting
long x = 12345;
float pi = 3.14f;
x = x * (long) pi;
//ou então, converte apenas o resultado
x = (long) (x * pi);
}
}
Curso de Introdução ao Java
Controles de Fluxo do Programa
Cláusula if( ) / else
public class ClausulaIf {
public static void main( String[] args ) {
int idade = 20;
if( idade <= 12 ) {
System.out.println( "Criança" );
}
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" );
}
}
}
Curso de Introdução ao Java
Controles de Fluxo do Programa
Cláusula if( ) / else
public class ClausulaIf {
public static void main( String[] args ) {
int idade = 20;
if( idade <= 12 ) {
System.out.println( "Criança" );
}
else if( idade <= 19 ) {
System.out.println( "Adolescente" );
}
else if( idade <= 60 ) {
System.out.println( "Adulto" );
}
else {
System.out.println( "Idoso" );
}
}
}
Curso de Introdução ao Java
Exercícios
11) Crie uma variável inteira com um valor qualquer e verifique se o valor desta variável é
menor que 15 ou maior que 100.
12) Crie uma variável com valor de ponto flutuante com um valor qualquer e verifique se o
valor desta variável está entre 1.99 e 5.99, inclusive.
13) Agora compare se o valor das duas variáveis acima são iguais.
14) Calcule o valor da multiplicação de um int por um double, atribuindo o valor a um int.
Curso de Introdução ao Java
Exercícios
15) Crie um programa que receba dois argumentos (nomes) e os exiba na ordem alfabética
correta.
16) Crie um programa que receba dois argumentos e calcule a área de um quadrilátero e
exiba na tela com a seguinte mensagem:
“Lado a = <a>”
“Lado b = <b>”
“A área é = <valor>“.
17) Incremente o programa de cálculo de área (16) para exibir ao final a mensagem:
“A figura é um quadrado” caso seja um quadrado,
ou, “A figura é um retângulo”, caso seja um retângulo.
Curso de Introdução ao Java
Controles de Fluxo do Programa
Cláusula switch( )
public class ClausulaSwitch {
public static void main( String[] args ) {
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.
Curso de Introdução ao Java
Controles de Fluxo do Programa
Laço while( )
public class LacoWhile {
public static void main( String[] args ) {
int i = 0;
//laço while() com bloco de código definido
while( i < 10 ) {
System.out.println( "Linha: " + i );
i++;
}
}
}
A expressão é avaliada antes de executar o bloco de código
Ele repete enquanto a expressão for verdadeira (true)
Curso de Introdução ao Java
Controles de Fluxo do Programa
Laço do / while( )
public class LacoWhile {
public static void main( String[] args ) {
int i = 0;
//laço do / while() com bloco de código definido
do {
System.out.println( "Linha: " + i );
i++;
} while( i < 10 );
}
}
O bloco é executado ao menos um vez
Após a primeira repetição é que a expressão é avaliada
Curso de Introdução ao Java
Controles de Fluxo do Programa
Laço for( )
A sua estrutura é definida como a seguir:
for( iniciação; condição; incremento ) {
bloco_de_código_a_executar
}
public class LacoFor {
public static void main( String[] args ) {
for( int i=0; i < 10; i++ ) {
System.out.println( "Linha: " + i );
}
}
}
Curso de Introdução ao Java
Controles de Fluxo do Programa
Laço for( ) avançado (Enhanced for loop)
Foi definido a partir do Java 5, com o intuito de facilitar a vida do desenvolvedor,
economizando código e evitando erros ao percorrer arrays e coleções
(implementações de java.util.Collection).
É similar ao for each de outras tecnologias.
Não é possível controlar o índice utilizado pelo for, mas pode-se contonar este
problema.
public class LacoForAvancado {
public static void main( String[] args ) {
for( String s : args ) {
System.out.println("Argumento: " + s );
}
List lista = new ArrayList();
}
// adiciona itens à lista
}
for( String s : lista ) {
System.out.println( s );
}
Curso de Introdução ao Java
Controles de Fluxo do Programa
Cláusula break
Aborta a execução de um laço, quando executado.
public class ClausulaBreak {
public static void main( String[] args ) {
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 );
}
}
Curso de Introdução ao Java
Controles de Fluxo do Programa
Cláusula break rotulada
Aborta a execução de um laço 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++;
}
Curso de Introdução ao Java
Controles de Fluxo do Programa
Cláusula continue
Ignora a execução dos comandos seguintes do bloco, no laço, quando executado.
public class ClausulaContinue {
public static void main( String[] args ) {
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] );
}
}
}
Curso de Introdução ao Java
Controles de Fluxo do Programa
Cláusula continue rotulada
Ignora a execução dos comandos seguintes do bloco, do laço 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++;
}
Curso de Introdução ao Java
Exercícios
18) Faça o cálculo do valor da variável x mais y, inteiros, sem utilizar o operador +.
19) Verifique o valor de x, imprimindo uma mensagem correspondente quando for maior,
menor ou igual a 10, sem usar a cláusula if( ).
20) Faça a soma de todos os valores (inteiros) entrados como argumento do programa e
exiba na tela a mensagem: “A soma dos valores é = <valor>”.
Curso de Introdução ao Java
Programação Orientada ao Objeto
O paradígma da Orientação ao Objeto é um mecanismo que ajuda a definir a
estrutura de programas, baseado nos conceitos do mundo real, sejam eles reais ou
abstratos.
A Orientação 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, Herança e
Polimorfismo.
Dentre as vantagens que a OO proporciona, podemos destacar o aumento de
produtividade, reuso de código, redução das linhas de código programadas,
separação de responsabilidades, encapsulamento, polimorfismo, componentização,
maior flexibilidade do sistema, dentre outras vantagens.
Curso de Introdução ao Java
Modelagem Orientada ao Objeto
Os sistemas OO podem ser modelados com auxílio da UML (Unified Modeling
Language).
UML é uma linguagem de modelagem para especificar, modelar, visualizar e
documentar sistemas OO e não-OO, baseando-se em diagramas.
A UML é composta por:
Diagrama de Classes
Diagrama de Seqüência
Diagrama de Objetos
Diagrama de Casos de Uso
outros....
Curso de Introdução ao Java
Classes
Uma classe, nada mais é, do que a descrição de um conjunto de entidades (reais ou
abstratas) do mesmo tipo e com as mesmas características e comportamento. As
classes definem a estrutura e o comportamento dos objetos daquele determinado tipo.
Podemos dizer que as classes são, na verdade, modelos de objetos do mesmo tipo.
Propriedades:
modelo
cor
motor
Comportamento:
Entidade do mundo real
liga
desliga
muda marcha
acelera
breca
Modelo UML da classe
Curso de Introdução ao Java
Classes
public 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" );
}
}
Ao lado temos o código Java
da classe Carro, definida pelo
modelo UML, com base no
levantamento da entidade
carro do mundo real.
No código definimos:
declaração da classe
declaração dos atributos
declaração dos métodos
Arquivo: Carro.java
O arquivo do código-fonte sempre
leva o nome da classe, seguido
da extensão .java.
Curso de Introdução ao Java
Objetos
Um objeto, nada mais é do que uma instância particular de um tipo de dado
específico (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 memória chamada heap.
Os Objetos possuem:
Estado (atributos/propriedades)
Comportamento (métodos/ações)
Identidade (cada objeto é único)
Os Objetos se comunicam entre sim por
meio de mensagens (chamadas aos
métodos)
e
devem
ter
sua
responsabilidade bem definida no sistema.
Criando uma instância (objeto) de uma classe:
Carro meuCarro = new Carro( );
Declaração da variável que
vai guardar uma referência
para um objeto do tipo Carro.
Operador new
instancía o
objeto.
Construtor da classe
Carro
Curso de Introdução ao Java
Objetos
As variáveis não guardam os objetos, mas sim uma referência para a área de memória
onde os objetos estão alocados.
Se criarmos duas instâncias da classe Carro e atribuírmos
cada instância para cada uma das duas variáveis
diferentes, c1 e c2, temos a situação ao lado.
Carro c1 = new Carro( );
Carro c2 = new Carro( );
Imagine, agora, duas variáveis diferentes, c1 e c2, ambas
referenciando o mesmo objeto. Teríamos, agora, um
cenário assim:
Carro c1 = new Carro( );
Carro c2 = c1;
Curso de Introdução ao Java
Objetos
Utilizando a classe Carro:
class ExemploCarro {
public static void main( String[] args ) {
//criando uma instância da classe Carro
Carro umCarro = new Carro();
//atribuindo os valores dos atributos
umCarro.modelo = "Gol";
umCarro.cor = "preto";
umCarro.motor = "1.0";
//executando os métodos do objeto
umCarro.ligar();
umCarro.mudarMarcha();
umCarro.acelerar();
umCarro.brecar();
umCarro.desligar();
//atribuindo null para a variável diz que
//agora ela não aponta para lugar nenhum
umCarro = null;
}
}
Curso de Introdução ao Java
Garbage Collection
Os objetos que não são mais referenciados, são coletados pelo Garbage Collector.
O Garbage Collector libera a memória que não está mais em uso.
Um objeto que perdeu sua referência é eleito a ser coletado, porém não é coletado
automaticamente naquele instante.
Quando um objeto se torna eletivo a Garbage Collection:
// objeto criado em memória
MeuObjeto obj = new MeuObjeto( );
// referência perdida – eleito a ser recolhido pelo GC
obj = null;
Para forçar a execução do Garbage Collector:
System.gc( );
Porém, nada garante que o G.C. será executado naquele instante, nem que as
instâncias sem refências serão recolhidas.
Curso de Introdução ao Java
Package e Import
Package
Os pacotes (packages) servem para organizar e agrupar classes por funcionalidade.
Os pacotes são divididos por uma estrutura de diretórios.
package meuprograma.uteis;
public class ValidacaoCPF {
//...
}
package meuprograma.cadastro;
public class CadastroUsuario {
//...
}
Curso de Introdução ao Java
Package e Import
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;
package meuprograma.uteis;
import meuprograma.uteis.ValidacaoCPF;
import java.sql.*; //importa classes JDBC
public class ValidacaoCPF {
public static boolean
validar (String cpf) {
//fazer a validação
}
}
public class CadastroUsuario {
//...
public void cadastrar( Usuario u ) {
//...
if( ValidacaoCPF.validar( u.cpf ) ) {
cadastrar( u );
} else {
throw new Exception(“CPF Inválido”);
}
//...
}
}
Curso de Introdução ao Java
Package e Import
Import estático
A partir do Java 5 é possível fazer o import estático, ou seja, dar import apenas nos
métodos ou atributos estáticos oferecidos por uma classe, e usá-los como se fossem
métodos ou atributos locais à sua classe.
import static java.lang.Math.*;
public class TesteImportEstatico {
public static void main(String[] args) {
double d = sin(1);
// O método sin() pertence
// à classe Math
}
}
import static java.lang.Math.PI;
public class Calculos {
public double areaCircunferencia(double r) {
return PI * r * r;
}
}
Curso de Introdução ao Java
Package e Import
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 definição 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.
Curso de Introdução ao Java
Atributos
Os atributos de uma classe são variáveis com o escopo do objeto.
São acessíveis e estão disponíveis enquanto o objeto estiver disponível.
Os atributos são iniciados durante a criação do seu objeto.
Durante a criação do objeto, os atributos de:
tipos primitivos numéricos recebem 0 (zero) na iniciação;
tipo char recebe o valor '\u0000';
tipo boolean recebe false;
referência a objetos recebem null na iniciação.
Porém, os atributos podem receber um valor padrão, definido na sua declaração,
como no código abaixo:
class UmaClasse {
String valorInicial = "um valor qualquer";
int i = 1000;
}
Curso de Introdução ao Java
Atributos Estáticos
Atributos estáticos não precisam de uma instância da classe para serem usados
Eles são compartilhados por todas as instâncias da classe
Não são thread-safe (cuidado ao usá-los)
class Contador {
static int count = 0;
void incrementar() {
count++;
}
}
public static void main( String[] args ) {
Contador c = new Contador();
c.incrementar();
System.out.println( Contador.count );
Contador.count++;
System.out.println( c.count );
}
Curso de Introdução ao Java
Constantes
Constantes são atributos de uma classe que não mudam de valor
O modificador final indica que o atributo é imutável
public class Matematica {
static final double PI = 3.14159265;
static double areaCircunferencia( double r ) {
return PI * r * r;
}
static double perimetroCircunferencia( double r ) {
return PI * r;
}
}
Curso de Introdução ao Java
Métodos
A utilidade dos métodos é a de separar, em pedaços de códigos menores, uma
determinada função.
É aconselhável criar e manter métodos pequenos, seguindo uma regrinha básica: Se
o método tem scroll na tela, quebre-o em métodos menores. Isso facilita a leitura e o
entendimento do código e a manutenção.
Regras para se criar métodos:
Serem bem claros e ter uma função bem definida
Serem pequenos e fáceis de entender
Serem reaproveitáveis ao máximo
Curso de Introdução ao Java
Métodos
A sintaxe para a declaração dos método é a seguinte:
<tipo de retorno> <nome do método>( [lista dos atributos] ) {
// implementação do método
}
O tipo de retorno informa qual o tipo de dados o método retorna. Pode ser um tipo
primitivo ou um tipo de um classe. Caso o método não retorne nada, ele deve ser
void.
O nome do método pode ser qualquer. Prefira seguir os padrões de nomenclatura e
dar nomes significativos, de preferência verbos no infinitivo.
A lista de atributos não precisa ser informada se não há passagem de argumentos.
Caso haja, os argumentos devem ser informados com seu tipo e nome, separados
por vírgula se houver mais de um.
Curso de Introdução ao Java
Retorno dos Métodos
A palavra reservada return causa o retorno do método.
Quando os métodos são declarados com o tipo de retorno void, então o método não
pode e nem deve retornar nada.
Os métodos que retornam algum valor, devem retornar dados do tipo de retorno
declarado, ou de tipos compatíveis.
Veja o exemplo:
public class TesteRetorno {
public void naoRetornaNada() {
int i = (int)(Math.random() * 100);
if( i > 50 ) {
return; //aborta o método
}
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;
}
}
Curso de Introdução ao Java
Métodos
public class DeclaracaoDeMetodo {
public static void main( String[] args ) {
DeclaracaoDeMetodo dm = new DeclaracaoDeMetodo();
dm.fazerAlgo();
dm.imprimirNaTela( "Daniel" );
int soma = dm.somar( 2, 3 );
Carro meuCarro = dm.criarUmCarro();
}
void fazerAlgo() {
//este método não 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;
}
}
Curso de Introdução ao Java
Métodos Estáticos
Métodos estáticos não precisam de uma instância da classe para serem usados
Métodos estático NÃO podem chamar métodos não-estáticos sem uma instância
Não são thread-safe (cuidado ao usá-los)
class MetodoEstatico {
public static void main( String[] args ) {
MetodoEstatico me = new MetodoEstatico();
me.metodoNaoEstatico();
me.metodoEstatico();
MetodoEstatico.metodoEstatico();
metodoEstatico();
}
static void metodoEstatico() {
//metodoNaoEstatico(); //ERRADO
// (new MetodoEstatico()).metodoNaoEstatico();
}
void metodoNaoEstatico() {
metodoEstatico(); //OK
}
}
//OK
Curso de Introdução ao Java
Construtores
Construtores não são métodos, são construtores.
Eles fazem a função de iniciação (start up) do objeto criado.
Se nenhum construtor for declarado, um construtor default será criado.
Múltiplos construtores podem ser declarados (overloading).
public class MinhaClasse {
public class NotaFiscal {
private int numero;
//sem construtor default
public NotaFiscal() {
//Construtor Default
this( novoNumero() );
}
}
public NotaFiscal( int numero ) {
this.numero = numero;
}
public class MinhaClasse {
public MinhaClasse() {
//Construtor Default
}
}
public int novoNumero() {
int i;
//gera novo numero em i
return i;
}
}
Curso de Introdução ao Java
Construtores
Usando os diferentes construtores:
public class Venda {
public Venda() {
//Construtor Default
}
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 );
}
}
Curso de Introdução ao Java
Exercícios
21) Crie classes que descrevam objetos que representem diferentes figuras geográficas, por
exemplo: círculo, quadrado e retângulo.
22) Adicione métodos nas classes para calcular e retornar a área da própria figura.
Curso de Introdução ao Java
Passagem de Parâmetros
Passagem de parâmetros, em Java, é por valor (não tem por referência)
Parametros alterados dentro de um método, não serão alterados fora dele
Objeto passado como parâmetro apenas passa uma cópia da referência ao objeto
Referência alteradas dentro do método, não refletem fora dele.
Alteração no estado de um objeto, como um parâmetro, alteram o estado dele fora
//...
int i = 10;
System.out.println( "i=" + i );
alterar( i );
System.out.println( "i=" + i );
//...
void alterar( int i ) {
i = i * 999;
System.out.println( "i=" + i );
}
Curso de Introdução ao Java
Passagem de Parâmetros
Carro meuCarro = new Carro( );
meuCarro.modelo = "Gol";
meuCarro.cor = "preto";
meuCarro.motor = "1.0 16v";
System.out.println( meuCarro.modelo );
realidade( meuCarro );
System.out.println( meuCarro.modelo );
sonho( meuCarro );
System.out.println( meuCarro.modelo );
void realidade( Carro c ) {
// eu quero que ele mude, mas não muda!
// c nunca será alterado fora do método
Carro c2 = new Carro( );
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 método, mas é só um sonho
c.modelo = "Porsche";
c.cor = "prata";
c.motor = "4.0";
}
Curso de Introdução ao Java
Passagem de Parâmetros
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;
}
Curso de Introdução ao Java
Varargs
No Java 5 foi introduzido o Vargars, que permite a passagem de um número variável
de argumentos a um método.
Dentro do método os argumentos variáveis são 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 métodos.
void metodo( int... args ) {
for( int i : args ) {
System.out.println( i );
}
}
// chamadas
metodo( 1 );
metodo( 1, 2, 3 );
novoMetodo( 1L, “a” );
novoMetodo( 9L, “a”, “b”, “c” );
void novoMetodo( long i, String... args ) {
for( int s : args ) {
System.out.println( s );
}
}
Curso de Introdução ao Java
Modificadores de Acesso
Determinam a visibilidade dos membros (atributos e métodos) da classe e da própria classe
Devem ser usados na declaração dos membros e da classe
Ao todo são 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
própria classe
Curso de Introdução ao Java
JavaBeans
Os JavaBeans são componentes Java (classes) bem encapsulados e com um
propósito específico. Seus atributos não podem ser acessados diretamente, mas
apenas por meio de métodos set e get. Segundo o encapsulamento, os atributos
não podem ser alterados diretamente.
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;
}
}
Curso de Introdução ao Java
Exercícios
23) Complemente as classes do exercício 22, mudando os modificados de acesso dos
atributos e métodos da classe, encapsulando-as como JavaBeans, de forma com que os
seus atributos possam ser acessados apenas por meio de métodos getter e setter.
Curso de Introdução ao Java
Arrays
Array é uma coleção ordenada de primitivos, referências para objetos e outras
arrays. Os arrays em Java são homogêneos, ou seja, eles só podem conter dados
do mesmo tipo. Os arrays são objetos, e devem ser construídos antes de serem
usados. Os array são iniciados automaticamente quando criados.
Passos para utilizar arrays:
Declaração
Criação
Iniciação
= new Carro[10];
Carro( );
Carro( );
int[ ] umArray;
umArray = new int[ 10 ];
umArray[ 0 ] = 0;
umArray[ 1 ] = 999;
Carro[ ] estoque
estoque[0] = new
estoque[1] = new
//...
estoque[9] = new
short[][] jogoDaVelha = new short[3][3];
estoque[1].modelo = “Gol”;
estoque[1].cor = “preto”;
estoque[1].motor = “1.0”;
double[] d = { 1.0d, 0.99, 3.14 };
Carro( );
Curso de Introdução ao Java
Arrays
Podemos percorrer os array de forma automática, usando o laço for( )
O índice dos arrays vai de 0 (zero) até N-1 (onde N é o tamanho do array)
Outra forma de se percorrer os itens do array é através do enhanced for
public class PercorrendoArray {
public static void main( String[] args ) {
double[] precos = new double[100];
//aqui sabemos o tamanho do array (fixo)
for(int i=0; i<100; i++) {
precos[i] = Math.round(Math.random() *
10000) / 100.0;
}
//aqui não importa o tamanho (variável)
for(int i=0; i<precos.length; i++) {
precos[i] = i * 0.9;
}
//enhanced for loop
for(double p: precos)
System.out.println(p);
}
}
Arrays não mudam de tamanho.
Acessar um índice inexistente do
array causa uma exceção do tipo:
ArrayIndexOutOfBoundsException
Curso de Introdução ao Java
Exercícios
24) Crie um programa que armazene as notas de provas de 50 estudantes e crie um método
que calcule e retorne a somatória das notas de todos os estudantes. Imprima o valor no
console.
25) Crie um outro método no programa que liste as notas de todos os estudantes.
26) Crie um outro método no programa que calcule e retorne a média ponderada das notas
de todos os estudantes. Imprima o valor no console. Dica: reutilize o método de calcular a
somatória das notas.
Nota: O programa deverá chamar uma outra classe que faça todos estes cálculos e
listagens.
Curso de Introdução ao Java
Herança (extends)
Herança é uma característica da POO que permite que classes (filhas) herdem e estendam as
funcionalidades e as características de outras classes (mãe).
Uma subclasse (classe filha) é uma especialização da sua superclasse (classe mãe).
Este é um relacionamento do tipo “é um”. A subclasse “é uma” superclasse.
Em Java, a herança é conseguida através da palavra extends
Toda classe, por padrão, estende a classe java.lang.Object
Todos os métodos e atributos (public e protected) são herdados pela subclasse (filha)
Os construtores não são herdados
class MyClass {
}
class MyClass
extends Object {
}
class ClasseA {
}
class ClasseB
extends ClasseA {
}
Diagrama UML
Curso de Introdução ao Java
Herança (extends)
Java não permite herança múltipla, ou seja, uma classe herda de apenas uma única classe.
A palavra super referencia a superclasse.
O construtor da superclasse é chamado automaticamente, se outra chamada não for feita.
public class Pessoa {
protected String nome;
protected String cpf;
public Pessoa() {}
}
public class Empregado extends Pessoa {
public Empregado() {
super(); //ocorre automaticamente
}
}
Diagrama UML
public class Gerente extends Pessoa {
}
Curso de Introdução ao Java
Herança (extends)
Tirando vantagem da herança:
Todas as classes são subtipos da classe Pessoa.
Podemos dizer que Empregado e Gerente são Pessoas.
public class TesteHeranca {
public static void main( String[] args ) {
Pessoa p = new Pessoa();
Pessoa e = new Empregado();
Pessoa g = new Gerente();
}
}
Curso de Introdução ao Java
Herança (extends)
Melhorando o modelo: Gerente, ao invés de Pessoa, pode ser definido como um Empregado.
public class Gerente extends Empregado {
}
public class RH {
public static void main(String[] args) {
Gerente chefe = new Gerente();
Empregado emp = new Empregado();
pagarSalario( chefe );
pagarSalario( emp );
promoverEmp( chefe, emp );
}
public static void pagarSalario( Empregado e ) {
//faz lançamento do pagamento de salário
}
public static void promoverEmp( Gerente g, Empregado e ) {
//Apenas um gerente pode promover um empregado
}
}
Curso de Introdução ao Java
Herança (extends)
Overriding (sobrescrita) de métodos herdados
public class ClasseA {
public void metodo1() {
System.out.println(“ClasseA.metodo1()”);
}
}
public class TesteAB {
public static
void main(String[] args) {
ClasseA a = new ClasseA();
a.metodo1();
public class ClasseB extends ClasseA {
public void metodo1() {
System.out.println(“ClasseB.metodo1()”);
}
public void metodo2() {
System.out.println(“ClasseB.metodo2()”);
}
}
a = new ClasseB();
a.metodo1();
ClasseB b = new ClasseB();
b.metodo1();
b.metodo2();
}
}
Curso de Introdução ao Java
Conversão de Objetos
Assim como a conversão de tipos primitivos, também podemos fazer a conversão de objetos.
Podemos converter os tipos, baseando-se na topologia da hierarquia de classes e subclasses.
Subtipos podem ser fácilmente convetidos para seus supertipos, sem explicitar o casting.
Na conversão 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
Curso de Introdução ao Java
Overriding
O overriding (sobrescrita) ocorre quando um método de uma superclasse é
sobrescrito por um método de mesmo nome de uma subclasse.
Os métodos sobrescritos da subclasse não podem ter um modificador mais
restritivo que o modificador do método de sua superclasse.
public class ClasseA {
public void metodo1() {
System.out.println(“ClasseA.metodo1()”);
}
}
public class ClasseB extends ClasseA {
public void metodo1() {
System.out.println(“ClasseB.metodo1()”);
}
}
Curso de Introdução ao Java
Overloading
O overloading (sobrecarregamento) ocorre quando mais de um método com o
mesmo nome é implementado.
Overloading pode se dar apenas pela diferenciação dos argumentos do método.
public class ValidacaoCPF {
public boolean validar(String cpf) {
return validar( Integer.parseInt( cpf ) );
}
public boolean validar(int cpf) {
//faz as verificações do CPF
return false;
}
public boolean validar(int cpf, int digito) {
return validar( (cpf*100) + digito );
}
}
Curso de Introdução ao Java
this e super
As palavras reservadas this e super são muito importantes e úteis.
this referencía a própria instância de dentro de sua classe. Ela não pode ser
usada em métodos estáticos.
super referencía a superclasse de uma classe.
public class SuperClasse {
public void executar() {
}
}
public class ThisESuper extends SuperClasse {
private int var1;
public static void main(String[] args) {
ThisESuper ts = new ThisESuper();
ts.metodo1();
}
public ThisESuper() {
super(); //chama o construtor da superclasse
}
public void metodo1(int i) {
this.var1 = i;
//executa o método executar da superclasse
super.executar();
}
}
Curso de Introdução ao Java
Classes Internas
As classes internas (Inner classes) também são chamadas de classes aninhadas.
As classes internas são classes normais, porém são definidas dentro de uma
classe ou método.
As classes internas que não são declaradas dentro de métodos são chamadas de
classes membro.
Neste caso, os nomes
completo das classes
são:
public class OuterClass {
private int x;
public class InnerClass {
private int y;
private void innerMethod() {
System.out.println( “y = ” + y );
OuterClass e
OuterClass.InnerClass.
}
}
public void outerMethod() {
System.out.println( “x = ” + x );
}
}
Curso de Introdução ao Java
Classes Internas
As classes internas precisam de uma instância 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 instância.
public class OuterClass {
private int x;
public class InnerClass {
private int y;
private void innerMethod() {
System.out.println( “x (externo) = “ + x );
System.out.println( “y = ” + y );
outerMethod( );
}
}
public void outerMethod() {
System.out.println( “x = ” + x );
}
}
Curso de Introdução ao Java
Classes Internas
Para instanciar uma classe interna, de um método estático 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();
Curso de Introdução ao Java
Classes Internas Estáticas
As classes internas estáticas pertencem à classe externa, ao invés de uma
instância de objeto da classe externa, em particular.
Ou seja, elas não precisam de uma instância da sua classe externa.
public class OuterClass {
public static class StaticInnerClass {
}
public static void main( String[] args ) {
StaticInnerClass sic = new OuterClass.StaticInnerClass();
}
}
Curso de Introdução ao Java
Classes Internas a Métodos
As classes internas aos métodos não são consideradas membros da classe, mas
apenas local ao método.
Essas classe têm acesso aos membros da sua classe externa, bem como às
variáveis locais e parâmetros do método, desde que marcadas como final.
public class OuterClass {
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 );
System.out.println( “y = “ + y );
}
}
MethodInnerClass mic = new MethodInnerClass();
mic.metodo();
}
}
Curso de Introdução ao Java
Classes Anônimas
Classes Anônimas são classes que não possuem um nome.
Ela estendem uma classe ou implementam uma interface. Não é permitido
estender uma classe e implementar uma ou mais interfaces ao mesmo tempo.
A definição, criação e o primeiro uso ocorrem, de fato, no mesmo lugar.
São, geralmente, muito utilizadas com o Listeners e Action handlers do pacote
gráfico swing e awt.
public void umMetodo( ) {
jButton1.addActionListener(
new ActionListener() {
public void actionPerformed( ActionEvent e ) {
System.out.println( “Uma ação ocorreu” );
}
}
}
Object o = new JButton() {
// estensão da classe JButton
};
Curso de Introdução ao Java
Classes Anônimas
Exemplo de classe anônima.
public class MinhaClasse( ) {
public MinhaClasse() {
//Construtor default
}
public MinhaClasse( String s ) {
//Construtor com parâmetros
}
}
MinhaClasse m = new MinhaClasse() {
};
MinhaClasse m2 = new MinhaClasse( “teste” ) {
};
Ambas são subclasses de MinhaClasse, mas cada uma é iniciada de modo
diferente (construtores diferentes).
Curso de Introdução ao Java
Classe Abstrata
Quanto mais genéricas, as classes podem ser tornar muito abstratas, na hierarqia de classes.
A classe chega a ser tão genérica que não precisa de uma instância dela na aplicação.
Essa classe acaba servindo de modelo para suas subclasses. Essas são as classes abstratas.
A classe abstrata pode ter métodos implementados, porém deve ter ao menos um método
abstrato, ou seja, um método que uma subclasse concreta deve implementar.
Classes abstratas não podem ser instanciadas.
Imagine um sistema de envio de
mensagens do tipo texto e fax.
Não faria sentido ter uma instância
de Mensagem, mas sim uma de
MensagemTexto ou MensagemFax.
Curso de Introdução ao Java
Classe Abstrata
public abstract class Mensagem {
private String from;
private String msg;
public class MensagemTexto extends Mensagem {
public MensagemTexto( String remetente ) {
super( remetente );
}
public Mensagem( String remetente ) {
from = remetente;
}
public void corpoMensagem(String msg) {
this.msg = msg;
}
public abstract void enviar();
}
public class MensagemFax extends Mensagem {
public void enviar() {
//envia uma mensagem de texto
}
}
public class ServicoMensagens {
public static void main(String[] args) {
Mensagem m = new MensagemTexto(“Daniel”);
m.corpoMensagem(“Mensagem de teste TXT”);
m.enviar();
public MensagemFax( String remetente ) {
super( remetente );
}
m = new MensagemFax(“Daniel”);
m.corpoMensagem(“Mensagem de teste FAX”);
m.enviar();
}
public void enviar() {
//envia uma mensagem de fax
}
}
}
Curso de Introdução ao Java
Interface
As interfaces atuam como um contrato para as classes que a implementam.
Nas interfaces você define os métodos que deverão ser providos pela classes.
As classes que implementam esta interfaces, deve oferecer uma implementação para
cada método definido na sua interface.
As classes podem implementar mais de uma interface.
Pode-se usar interfaces para uso de funções de callback.
public interface Figura {
public double calcularArea();
}
public class Circulo implements Figura {
public double calcularArea() {
//faz o cáculo da área do círculo
}
}
public class Quadrado implements Figura {
public double calcularArea() {
//faz cálculo da área do quadrado
}
}
Cada classe implementam o
método à sua maneira. Mas o
mais importante é que eles
ofereçam uma implementação
para aquele método da interface.
Interfaces são adequadas para
se definir formas (interfaces) de
acesso a sub-sistemas,
escondendo detalhes da sua
implementação.
Curso de Introdução ao Java
Interface
Vejamos como utilizar uma interface:
Figura fig = new Circulo(10);
double area = fig.calcularArea();
fig = new Quadrado(8);
area = fig.calcularArea();
*** Interface Java não tem nada a ver com interfaces gráficas.
Curso de Introdução ao Java
Interface
Agora, vamos ver um exemplo mais prático de uso de interfaces em Java.
public interface CadastroUsuario {
public void inserir( Usuario usr ) throws Exception;
}
public class CadastroUsuarioBanco implements CadastroUsuario {
public void inserir( Usuario usr ) throws Exception {
//insere os dados no banco
}
}
public class CadastroUsuarioArquivo implements CadastroUsuario {
public void inserir( Usuario usr ) throws Exception {
//insere os dados no arquivo
}
}
//...
CadastroUsuario cad = new CadastroUsuarioBanco();
cad.inserir( usuario );
cad = new CadastroUsuarioArquivo();
cad.inserir( usuario );
//...
Curso de Introdução ao Java
Type Safe Enums
Outra funcionalidade adicionada ao Java 5 foi o Type Safe Enums, que permite se criar
enumerações em Java, assim como existem em outras tecnologias.
É definido pela palavra reservada enum, e cada item da enumeração é representado por um
objeto do mesmo tipo do Enum.
A definição de um Enum é nada mais do que a definição de um tipo especial de classe. Se
estiverem em outro pacote, precisam ser importadas, como classes normais.
public enum Cargo {
PROGRAMADOR, ANALISTA, ARQUITETO, COORDENADOR
}
Cargo c = Cargo.PROGRAMADOR;
Cargo x = Enum.valueOf( Cargo.class, “ANALISTA” );
for( Cargo y : Cargo.values() ) {
System.out.println( y );
}
Curso de Introdução ao Java
Type Safe Enums
As enumerações ainda podem conter informações e métodos adicionais.
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;
}
}
Cargo c = Cargo.PROGRAMADOR;
System.out.println( c + “: ” + c.getSalario() );
Curso de Introdução ao Java
Controle de Erros (Exceções)
A linguagem Java oferece um precioso mecanismo de controle e tratamento de erros
dos programa, chamado de tratamento de exceções. Em Java, todo e qualquer erro é
chamado de exceção.
Este mecanismo de tratamento de erros em Java é feito pelas diretivas try, catch e
finally. A sintaxe dessas diretivas é a seguinte:
try {
código_a_ser_executado
}
catch( Exceção ) {
código_de_tratamento_de_erro
}
finally {
código_sempre_executado
}
Podem existir múltiplos blocos catch no tratamento de erros. Cada um para um tipo
específico de Exception.
Curso de Introdução ao Java
Controle de Erros (Exceções)
public class TratamentoDeErro {
public static void main( String[] args ) {
// array de 6 posições
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 exceção ocorreu");
}
finally {
System.out.println("Isto SEMPRE executa!");
}
}
}
Curso de Introdução ao Java
Controle de Erros (Exceções)
Todo erro, ou condição especial, em Java é uma subclasse da classe Throwable. Porém 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 são causados
por bugs do programa, que
desconhecemos, ou seja, uma
condição especial que sequer
havíamos imaginado. Os erros de
Runtime são subclasses da classe
Runtime, que é subclasse de
Exception.
Os erros de sistema são erros
imprevisíveis, causados por falha do
sistema, como acesso a disco, erro do
banco de dados e etc. Estes erros são
subclasses da classe Error.
E os erros Customizados são erros ou
condições especiais previstas no
programa. Essos erros são subclasse
da classe Exception.
Curso de Introdução ao Java
Gerando Erros (Exceções)
Podemos querer tratar erros de lógica da nossa aplicação. Imagine um aplicativo de controle
bancário, onde ele controla os débitos em uma conta corrente. Um cenário possível é o cliente
tentar fazer um saque no caixa, acima do valor do seu saldo. Poderíamos tratar este caso
como uma exceção. Para isso, podemos criar nossa própria classe de exceção, chamada
SaldoInsuficienteException, que deve ser uma subclasse de Exception. Quando nossa
aplicação identificar o cenário acima, podemos então lançar a nossa exceção 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 lança um erro, para que um bloco catch o capture e faça o tratamento
necessário.
Curso de Introdução ao Java
Gerando Erros (Exceções)
Imagine que nossa classe possua um método atômico, ou seja, uma função específica que deve ser
executada com sucesso ou abortada por interior. Ao invés de fazer o tratamento de erro dentro dela,
podemos fazer com que o próprio método delegue o erro para o método que o chamou. O exemplo
anterior é um bom exemplo para isso. Imagine o seguinte método:
public boolean fazerRetidada( double valorRetirada )
throws SaldoInsuficienteException {
if( saldo < valorRetirada ) {
throw new SaldoInsuficienteException();
}
debitarValorNaConta( valorRetirada );
return true;
}
Ele agora está mais simples, sem as diretivas try / catch / finally. Agora, então podemos tratar o erro
num nível mais alto, ou seja, onde o método de fazerRetidada( ) foi chamado. Exemplo:
try {
fazerRetidada( 10000.0 );
}
catch( SaldoInsuficienteException e ) {
System.out.println( “Saldo Insuficiente para a retirada” );
}
A diretiva throws repassa um método lançado dentro do método e que não foi tratado por nenhum
bloco catch dentro dele.
Curso de Introdução ao Java
Gerando Erros (Exceções)
Criando nossa Exceção customizada:
public class SaldoInsuficienteException extends Exception {
public SaldoInsuficienteException() {
super();
}
public SaldoInsuficienteException(String msg) {
super( msg );
}
}
Curso de Introdução ao Java
Pacote java.lang
Este é o pacote essencial do Java, e contém as classes centrais para operações 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 métodos da classe Object.
Possui os métodos wait( ), notify( ) e notifyAll( ), que suportam controle de threads, além dos métodos
equals() e toString().
Classe: Math
A classe Math possui um conjunto de métodos e 2 constantes para suportar computação matemática.
A classe é final e não pode ser estendida. O construtor é private, portanto não pode ser instanciado.
Constantes: Math.PI e Math.E
Possui método para cálculo de: valor absoluto, arredondamento para cima e para baixo, comparação
do maior e menor valor, número aleatório, arredondamento, seno, coseno, tangente e raiz quadrada.
Curso de Introdução ao Java
Pacote java.lang
Estas classes encapsulam cadeias de caracteres Unicode (16 bits) e suportam alfabetos
internacionais.
Classe: String
A classe String guarda uma String imutável.
Uma variável da classe String aponta para uma área de memória que contém a String.
Esta classe possui muitos métodos para manipular a String.
String str = “String 1”;
String texto = str;
str = “Nova String”;
if( str.equals( texto ) ) {
//Não é 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();
Curso de Introdução ao Java
Pacote java.lang
Classes Wrapper (Envoltórias)
Todo tipo primitivo em Java tem uma classe Wrapper correspondente. Esta classe encapsula um
valor de tipo primitivo e é imutável.
Tipo Primitivo
Wrapper Class
boolean b = false;
Boolean wB = new Boolean( b );
wB = new Boolean( “true” );
boolean
Boolean
byte
Byte
char
Character
short
Short
int
Integer
int i = wInt.intValue();
long
Long
if( Character.isDigit( ‘1’ ) ) {}
float
Float
double
Double
Integer wInt = new Integer( 12345 );
wInt = new Integer( “123” );
Long wLong = Long.valueOf( “23L” );
Long xLong = new Long( “33” );
//comparação
if( wLong.equals( xLong ) ) {}
Curso de Introdução ao Java
Auto Boxing / Unboxing
Antes do Java 5, a manipulação 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
conversão do tipos primitivos em wrappers e vice-versa, de uma maneira muito mais intuitiva e
produtiva. Este conceito também se aplica a passagem de parâmetros a métodos.
Antigamente fazíamos assim:
int x = 10;
Integer i = new Integer(x);
Integer y = x + i.intValue();
x = i.intValue();
i = new Integer(y);
Hoje o uso foi facilitado para:
int x = 10;
Integer i = x;
Integer y = x + i;
x = i;
i = y;
Curso de Introdução ao Java
Pacote java.util
O pacote java.util contém classes do framework de collections, modelo de eventos, data, hora,
internacionalização e classes de outras utilidades (StringTokenizer, etc).
Collections (Coleções)
A interface Collection é a interface base de todas as classes que implementam uma coleção. Ela
define métodos para adicionar itens, limpar a coleção, remover itens, transformar para array, iterar
pelos itens, ver o tamanho e etc.
Vector
A classe Vector representa um array dimensionável. 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
vec.add( “String
vec.add( “String
vec.add( “String
Vector( );
1” );
2” );
3” );
Iterator it = vec.iterator( );
while( it.hasNext( ) ) {
String str = (String) it.next( );
}
Curso de Introdução ao Java
Pacote java.util
ArrayList
Esta classe é muito similar à classe Vector, porém ela não é sincronizada, portanto, mais rápida.
ArrayList
list.add(
list.add(
list.add(
list = new
“String 1”
“String 2”
“String 3”
ArrayList( );
);
);
);
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 coleções, então, poderão ser acessadas pelo métodos comuns da interface List.
List lst = new Vector( );
List lst2 = new ArrayList( );
//...
Curso de Introdução ao Java
Pacote java.util
Hashtable
O Hashtable guarda valores com chave e valor, não permitindo valores null. Para recuperar um valor,
pede-se pelo seu nome (chave). Pode-se pegar um Enumeration com todas as chaves da coleção.
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));
}
Curso de Introdução ao Java
Pacote java.util
Properties
Esta classe é uma coleção 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 {
public static void main( String[] args ) {
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) {}
}
}
}
Curso de Introdução ao Java
Pacote java.util
Properties
Gravando os dados de um Properties:
import java.io.*;
import java.util.*;
public class Propriedades2 {
public static void main( String[] args ) {
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) {}
}
}
}
Curso de Introdução ao Java
Pacote java.util
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() );
}
Curso de Introdução ao Java
Pacote java.util
Date
A classe Date representa um instante de tempo específico, 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 implementação concreta da classe java.util.Calendar, e ofere métodos e
funcionalidades para manipular datas no formato do calendário 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));
//…
Curso de Introdução ao Java
Generics
Generics foi introduzido no Java 5, para ajudar o desenvolvedor a escrever código mais claros,
conciso e diminuir a ocorrência de erros de tempo de execução, principalmente durante a
manipulação de coleções de objetos (ClassCastException).
Com Generics podemos definir qual o tipo de dados vamos trabalhar com uma determinada
coleção 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 verificação de tipos é feita em tempo de
compilação, não mais em tempo de execução, 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);
Curso de Introdução ao Java
Generics
Podemos, inclusive, definir classes (tipos) que também aceitam o uso de Generics, para definir
o tipo de objeto que eles trabalharão.
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
}
}
Curso de Introdução ao Java
Arquivos jar
Os arquivos jar são um forma de empacotar as classes de uma API ou aplicação. JAR é a sigla para
Java ARchive.
Ao invés de termos várias classes soltas e espalhadas, podemos agrupá-las todas em um arquivo jar.
O arquivo jar não é nada mais que um arquivo zip, com extensão .jar.
A ferramento jar que vem no JDK nos auxilia na geração 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, além 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 contém o arquivo jar.
Como todos os arquivos de dentro do jar estarão no classpath, podemos acessá-lo de dentro do java
da seguinte forma:
getClass().getResourceAsStream( “nome-do-arquivo” );
Curso de Introdução ao Java
Javadoc
O processo de documentação deveria ser intrínseco ao processo de criação do código-fonte.
Este deveria documentar todo o código escrito, sua funcionalidade, as entradas e saídas, possíveis
erros e efeitos colaterais.
O Java possui uma ferramenta, parte da JSE, que facilita a criação de documentos a partir da
documentação feita no próprio código-fonte, o Javadoc.
O Javadoc, em geral, pode ser criado pela própria IDE de desenvolvimento, ou por linha de comando.
Para criar o Javadoc em linha de comando, execute o comando javadoc que vem com o JDK.
Curso de Introdução ao Java
I/O
A I/O (entrada e saída) do Java pode ser facilmente manipulada utilizando as classes do pacote
java.io, que trabalham com fluxos de dados (data streams), serialização e sistemas de arquivos.
Atualmente existe um novo pacote, chamado de java.nio (new I/O), que é uma estensão do pacote
padrão de I/O, porém não vamos estudá-lo neste curso.
File
Esta classe é uma representação abstrata de um arquivo ou diretório 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 diretório c:\tmp
if( dir.exists() && dir.isDirectory() ) {
String[] arqs = dir.list(); //lista os arquivos
}
A classe File oferece métodos comuns para verificar se o caminho existe na máquina local, criar ou
remover o arquivo/diretório com o nome especificado, pegar o caminho completo do arquivo/diretório,
lista todos os arquivos do caminho do diretório, verificar as propriedades do arquivo (data, readonly,
etc) e outras funcionalidades.
O Java usa duas representações para textos: Unicode internamente e UTF para I/O.
Não acessaremos os dados destes arquivos diretamente. Para isso faremos uso dos Streams (fluxos)
de entrada e saída de dados, da classe RandomAccessFile ou dos Reader e Writer.
Curso de Introdução ao Java
I/O
RandomAccessFile
A classe RandomAccessFile oferece recursos para acessar arquivos não-seqüencialmente, acessar
uma posição do arquivo, gravar ou ler os dados nele.
O construtor da classe recebe dois argumentos: uma instância 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 invés do File, recebe uma String com o caminho do arquivo e uma String com o modo de acesso.
Se o arquivo não existe, um novo arquivo vazio será criado.
Em caso de erros, uma exceção do tipo java.io.IOException ou java.io.FileNotFoundException será
lançada.
Esta classe oferece métodos para verificar o tamanho (em bytes) do arquivo, pegar a posição corrente
no arquivo e posicionar em numa nova posição, a partir da posição inicial.
A classe oferece métodos para ler byte a byte do arquivo ou método para ler grupos de bytes, em um
nivel mais alto de tipos de dados, como int, long, char, double, etc.
File arq = new File(“C:\\texto.txt”);
RandomAccessFile raf = new RandomAccessFile( arq, “rw” );
//gravando dados no arquivo
raf.writeUTF( “Saldo=“ );
raf.writeDouble( 100.0 );
//lendo a partir da posição inicial
raf.seek( 0 );
String txt = raf.readUTF();
double saldo = raf.readDouble();
raf.close(); //sempre feche o recurso
Curso de Introdução ao Java
I/O
Streams
Os stream são 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 saída, o
que facilita e torna padronizado o acesso a esses dados lidos e
gravados.
Existem duas classes abstratas, que são a base dos streams em Java,
que são: InputStream (para entrada de dados) e OutputStream (para
saída 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 nível.
Os streams de baixo nível trabalham com bytes, ou seja, lêem e
escrevem bytes. Os streams de alto nível, lêem e escrevem dados num
formato geral (primitivos e Strings), utilizando-se dos streams de baixo
nível.
Curso de Introdução ao Java
I/O
Low-Level Streams
As classes FileInputStream e FileOutputStream são duas classes de baixo nível para leitura e
gravação 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 métodos read( ) e write( ), respectivamente. Ambas possuem o método close( ).
A classe FileInputStream possui outros métodos como: available( ) e skip( ).
File arq = new File(“C:\\texto.txt”);
FileOutputStream fos = new FileOutputStream( arq );
fos.write( “String a ser gravada”.getBytes() );
fos.close();
File arq = new File(“C:\\texto.txt”);
FileInputStream fis = new FileInputStream( arq );
byte byteLido = (byte) fis.read();
byte[] bytes = new byte[10];
fis.read( bytes );
System.out.println( bytes );
fis.close();
Existem ainda outras classes de low-level. São elas: InputStream, OutputStream, que são as classes
pai das classes de stream de baixo nível. Além das classes: ByteArrayInputStream,
ByteArrayOutputStream, PipedInputStream e PipedOutputStream.
Curso de Introdução ao Java
I/O
High-Level Streams
Os filtros de stream de alto-nível permitem a leitura e a escrita de dados de outros tipos além dos
bytes dos dados. Essas classes estendem as classes FilterInputStream e FilterOutputStream para
entrada e saída. Na verdade as classes não lêem diretamente de um arquivo, mas sim de um outro
stream.
File arq = new File(“C:\\texto.txt”);
FileOutputStream fos = new FileOutputStream( arq );
DataOutputStream dos = new DataOutputStream( fos );
dos.writeDouble( 100.99 );
dos.writeUTF(“Texto String UTF”);
dos.close();
fos.close(); //feche todos os streams
File arq = new File(“C:\\texto.txt”);
FileInputStream fis = new FileInputStream( arq );
DataInputStream dis = new DataInputStream( fis );
double d = dis.readDouble();
String s = dis.readUTF();
dis.close();
fis.close(); //feche todos os streams
Existem ainda outras classes de high-level. São elas: BufferedInputStream, BufferedOutputStream,
que são as classes que utilizam buffer de memória. Além das classes: PrintStream, para gravar tipos
primitivos como representações de caracter e a classe PushbackInputStream.
Curso de Introdução ao Java
I/O
Reader e Writer
Os reader e writer são 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 são 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 métodos dos low-level, mais métodos para manipular leitura em
buffer, leitura de linha e etc.
Todas essas classes estendem das classes Reader e Writer.
Curso de Introdução ao Java
I/O
Serialização de Objetos
Serialização é 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 também trafegar pela rede.
Pessoa pess = new Pessoa();
pess.setNome(“João”);
pess.setIdade(30);
File arq = new File(“C:\\pessoa.ser”);
FileOutputStream fos = new FileOutputStream( arq );
ObjectOutputStream oos = new ObjectOutputStream( fos );
oos.writeObject( pess );
oos.close();
fos.close();
File arq = new File(“C:\\pessoa.ser”);
FileInputStream fis = new FileInputStream( arq );
ObjectInputStream ois = new ObjectInputStream( fis );
Pessoa p = (Pessoa) ois.readObject();
ois.close();
fis.close();
Os atributos marcados com o modificador transient não serão serializados.
Curso de Introdução ao Java
I/O
Sockets
Os Sockets servem para comunicação remota entre computadores, servindo como as pontas da
comunicação via o protocolo TCP/IP.
Os Sockets se comunicam entre sí por meio de Streams, por onde os dados (bytes) são enviados, da
mesma maneira que tratamos os dados de arquivos com streams. Podemos, inclusive, enviar objetos
por meio de streams que trabalham com serialização de objetos.
Nesse modelo de comunicação, um SocketServer espera conexões de Sockets clientes.
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();
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();
Curso de Introdução ao Java
I/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 método format() e a classe PrintStream possui o método 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()
);
System.out.println( s );
// Hoje é 1 de Julho de 2005
System.out.printf(“%2$2s%1$2s-%3$s”, “a”, “b”, “c”);
// imprime: “ b a-c”
Curso de Introdução ao Java
I/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 próximo 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 vírgula
Curso de Introdução ao Java
Threads
Threads são uma maneira de se programar aplicações com processamento paralelo, ou seja, várias
subprocessos executando ao mesmo tempo. Este é um assunto bem extenso e requer muita atenção,
porém vamos apenas dar uma introdução sobre Threads em Java.
As Threads possui um ciclo de estados definido, como segue na figura:
Quando uma Thread entra no estado dead, ela não 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 método public void run( ), que é o inicio da execução dela.
Curso de Introdução ao Java
Threads
public class MinhaThread extends Thread {
public void run() {
for( int i=0; i<100; i++ ) {
System.out.println("Thread : "+i);
try {
wait();
public class ExemploThreads {
} catch(Exception e) {}
public static void main(String[] args) {
}
ExemploThreads ex = new ExemploThreads();
}
ex.executar();
}
}
Perceba que, para iniciar a
Thread, na verdade foi
chamado o método start( )
e não o método run( ).
public void executar() {
MinhaThread m = new MinhaThread();
m.start();
for( int i=0; i<100; i++ ) {
System.out.println("Normal-"+i);
try {
wait(1);
} catch(Exception e) {}
}
}
}
Curso de Introdução ao Java
Threads
public class MinhaThread implements Runnable {
public void run() {
for( int i=0; i<100; i++ ) {
System.out.println("Thread : "+i);
try {
wait();
public class ExemploThreads {
} catch(Exception e) {}
public static void main(String[] args) {
}
ExemploThreads ex = new ExemploThreads();
}
ex.executar();
}
}
Quando a classe
implementa a interface
Runnable, ao invés de
estender a classe Thread,
deve ser criada um
Thread, passando a classe
que implementa Runnable
como parâmetro.
public void 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);
} catch(Exception e) {}
}
}
}
Curso de Introdução ao Java
Referências Bibliográficas
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 aplicações com UML
Ana Cristina Mello
Editora: Brasport
Applying UML and Patterns
Larman, Craig
Curso de Introdução ao Java
Websites Relacionados
Site Oficial do Java
http://java.sun.com
GUJ – Grupo de Usuários Java
http://www.guj.com.br
SoU Java – Sociedade dos Usuários Java
http://www.soujava.org.br
Java World
http://www.javaworld.com
Google
http://www.google.com