Introdução à Linguagem de
Programação
JAVA
Aula 03
Conceitos Básicos
da Linguagem Java
Tópicos da Aula
•
•
•
•
•
•
•
•
•
Comentários
Variáveis e Tipos de Dados
Operadores
Expressões, Statements e Blocos
Controle de Fluxo
Objetos
Caracteres e Strings
Números
Arrays
Comentários
• Três tipos de comentários:
– Comentários de uma linha, o compilador ignora o que estiver
a direita de // até o fim da linha
// text
– Comentários entre /* e */, seu conteúdo é ignorado pelo
compilador
/* text */
– Comentários de documentação entre /** e */, ignorado pelo
compilador mas relevante para o javadoc
/** text */
Variáveis e Tipos de Dados
Variável
• Def.: Uma variável é um dado
identificado por um nome.
– Cada variável possui um nome e um tipo
– Uma variável possui um escopo
– O nome da variável é utilizado para referir
ao dado que a variável contém
Nome de Variáveis
• O nome da variável deve respeitar as
seguintes regras:
– Ser uma série de caracteres Unicode iniciando por
letra
– Não pode ser uma palavra reservada
– Deve ser única no escopo
Convenção: nome começa com letra minúscula. Se for composto
por múltiplas palavras: concatenadas com iniciais subseqüentes
em maiúscula.
Ex.: isVisible
Palavras Reservadas (1)
abstract
byte
class
do
final
goto*
boolean
case
const*
double
finally
if
break
catch
continue
else
float
implements
char
default
extends
for
import
instanceof
int
interface
long
Palavras Reservadas (2)
native
private
return
switch
throws
volatile
new
null
protected public
short
static
synchronized this
transient
try
while
package
super
throw
void
Tipo de Dados
• Cada variável possui um tipo de dado,
que determina:
– tipo de valor que a variável pode conter
– conjunto de operações que podem ser
efetuadas com o conteúdo da variável
Tipos Primitivos: Inteiros
• São tipos primitivos inteiros:
– byte (8 bits)
• Variação: -128...+127
– short (16 bits)
• Variação: -32.768...+32.767
– int (32 bits)
• Variação: -2.147.483.648...+2.147.483.647
– long (64 bits)
• Variação: -9.223.372.036.854.775.808...
+9.223.372.036.854.775.807
Tipos Primitivos: Ponto
Flutuante
• São tipos primitivos de ponto flutuante:
– float (32 bits - Precisão simples)
• Variação:-3,4E-38... +3,4E+38
– double (64 bits - Precisão dupla)
• Variação:-1,7E-308... +1,7E+308
Observação: Ao contrário de outras linguagens, em Java os
tamanhos e tipos de dados não variam entre plataformas.
Tipos Primitivos: Outros
• Outros tipos primitivos:
– char (16 bits sem sinal)
• Variação: 0... 65.535
• Inclui UNICODE (alfabetos latino, grego, cirílico,
ideogramas japoneses, etc)
– boolean (1 bit - tipo lógico)
• Variação: true ou false
Escopo (1)
• Região do programa em que a variável
pode ser referenciada. Uma variável
pode ser:
– Variável membro
– Variável local
– Parâmetro de método
– Parâmetro de tratamento de exceção
Escopo (2)
Acesso a Variáveis
• Para variáveis membro, além do escopo é
possível determinar sua visibilidade:
– public
– protected
– private
Acesso Público
• A variável é acessível/visível por/em
qualquer parte do programa.
public int visivelEmTodoLugar;
Acesso Protegido
• A variável é acessível/visível somente
na classe em que foi definida, nas
subclasses ou no pacote ao qual
pertence.
protected int souProtegida;
Acesso Privado
• A variável é acessível/visível somente
na classe em que foi definida.
private int souInvisívelFora;
Variável de Classe
• A variável é compartilhada entre todos objetos da
classe.
public static int valorCompartilhado;
Observação: Nesse caso, se um objeto mudar o valor da
variável, os outros objetos verão o valor atualizado.
Variáveis Transientes
• Quando uma variável é declarada como transiente, o
valor contido nela não tem significado persistente.
Isto significa que o processo de serialização não
considera seu estado.
public transiente int souTemporária;
Variáveis Voláteis
• Uma variável é volátil, quando ela não deve ser
otimizada pelo compilador. Isto é útil quando se
deseja suprimir a otimização do compilador, por
exemplo em interfaces diretas com o dispositivo de
memória.
volatile double bitsDeFlagDoSistema;
Variáveis Finais
• Quando uma variável for definida como
final, seu conteúdo não pode ser
alterado após a inicialização
(constante):
protected static final int MAX_FILES = 20;
Operadores
Operadores
Em Java, trabalha-se com quatro conjuntos de
operadores:
–
–
–
–
–
–
aritméticos
relacionais
condicionais
lógicos e binários
atribuição
outros
Operadores Aritméticos
+
/
%
++
adição
subtração
divisão
resto da divisão
incremento de 1
--
decremento de 1
op1 + op2
op1 – op2
op1 / op2
op1 % op2
op1++
++op1
op1---op1
Operadores Relacionais
==
!=
>
<
>=
<=
igual
diferente
maior
menor
maior ou igual
menor ou igual
op1
op1
op1
op1
op1
op1
== op2
!= op2
> op2
< op2
>= op2
<= op2
Operadores Condicionais
&&
||
!
&
|
^
“E” curto-circuitado
“OU” curto-circuitado
“NÃO” lógico
“E” avalia ambos
“OU” avalia ambos
“OU” exclusivo avalia ambos
op1 && op2
op1 || op2
! op
op1 & op2
op1 | op2
op1 ^ op2
Operadores Lógicos e de
Deslocamento de bits
&
|
^
~
>>
<<
>>>
“E” bit-a-bit
“OU” bit-a-bit
“OU” exclusivo bit-a-bit
complemento bit-a-bit
desloca para direita
desloca para a esquerda
desloca para direita sem sinal
op1 & op2
op1 | op2
op1 ^ op2
~ op
op1 >> op2
op1 << op2
op1 >>> op2
Operadores de Atribuição
Aritméticos
+=
-=
*=
/=
%=
atribuição aditiva
equivale a
atribuição subtrativa
equivale a
atribuição multiplicativa
equivale a
atribuição divisiva
equivale a
atribuição de resto
equivale a
op1
op1
op1
op1
op1
op1
op1
op1
op1
op1
+= op2
= op1 + op2
-= op2
= op1 – op2
*= op2
= op1 * op2
/= op2
= op1 / op2
%= op2
= op1 % op2
Operadores de Atribuição
&=
|=
^=
<<=
>>=
>>>=
op1
op1
op1
op1
op1
op1
&= op2
|= op2
^= op2
<<= op2
>>= op2
>>>= op2
op1
op1
op1
op1
op1
op1
=
=
=
=
=
=
op1
op1
op1
op1
op1
op1
& op2
| op2
^ op2
<< op2
>> op2
>>> op2
Outros Operadores
?:
[]
if-then-else lógico
op1 ? op2 : op3
declaração de arrays
tipo[]
criação de arrays
tipo[op1]
acesso a posições de arrays
op1[op2]
.
nomes qualificados
op1.op2
()
delimitador de parâmetros
op1(params)
conversor de tipos de dados
(tipo) op1
new
criação de objeto ou array
new op1
Instanceof
verificação se o primeiro operador é uma instância
do segundo
op1 instanceof op2
Expressões, Statements e
Blocos
Expressões
• Série de variáveis, operadores e chamadas a
métodos, construídas de acordo com a
sintaxe, que resulta em um valor simples.
Ex:
x * (y + z) / 100
s = “Meu nome é “ + nome
Ordem de Precedência (1)
operadores pós fixados
operadores unitários
criação ou conversão
multiplicação
adição
deslocamento
relacional
igualdade
[] . (params) expr++ expr-++expr --expr +expr -expr ~ !
new (type)expr
* / %
+>> << >>>
< > <= >= instanceof
== !=
Ordem de Precedência (2)
E bit-a-bit
OU exclusivo bit-a-bit
OU inclusivo bit-a-bit
E lógico
OU lógico
Condicional
Atribuição
&
^
|
&&
||
:?
= += -= *= /= %= &=
^= |= <<= >>= >>>=
Statements
• Statement corresponde a uma unidade de execução:
–
–
–
–
Expressões de atribuição
Qualquer uso de ++ e –
Chamada a métodos
Expressões de criação de objetos
• Statements sempre terminam com ;
Ex:
value = 1234;
System.out.println(value);
Integer value2 = new Integer(4);
Blocos
• Blocos são grupos de nenhum, um ou mais
statements delimitados por chaves {}
Ex:
{
int i = 0;
while (i<1000) {
System.out.println(i);
i++;
}
}
Controle de fluxo
Laço: while
• Repete processamento do bloco, enquanto a
expressão for verdadeira. A expressão é
avaliada antes do processamento do bloco:
while (expressão booleana) {
bloco(s)
}
Laço: do-while
• Repete processamento do bloco enquanto a
expressão for verdadeira. A expressão é
avaliada após o processamento do bloco:
do {
bloco(s)
} while (expressão booleana);
Laço: for
• Laço de interação que inclui expressão de
inicialização, condição de término e expressão
de incremento:
for (inicialização; término; incremento) {
bloco(s)
}
Decisão: if-then
• Executa o bloco caso a expressão seja
verdadeira:
if (expressão booleana) {
bloco(s)
}
Decisão: if-then-else
• Executa o primeiro bloco caso a expressão
seja verdadeira, do contrário executa o
segundo bloco:
if (expressão booleana) {
bloco(s)
} else {
bloco(s)
}
Decisão: Aninhamento
if (expressão booleana) {
bloco(s)
} else if (expressão booleana) {
bloco(s)
} else if (expressão booleana) {
bloco(s)
} else {
bloco(s)
}
Decisão: Múltipla Escolha (1)
• Avalia uma expressão inteira e, de acordo
com o valor, processa o bloco
correspondente. Caso o valor não coincida
com nenhum dos valores previstos, executa o
bloco default:
Decisão: Múltipla Escolha (2)
switch (expressão inteira) {
case expressão inteira:
bloco(s)
break;
...
default:
bloco(s)
break;
}
Tratamento de Exceção
• Utilizado no tratamento de exceções:
try {
bloco(s)
} catch (exceção nome) {
bloco(s)
} finally {
bloco(s)
}
Desvios (1)
• Para nomear um bloco:
label: bloco
• Forma anônima de interromper um fluxo switch, for, while ou
do-while:
break;
• Forma nominal de interromper um fluxo switch, for, while ou
do-while:
break label;
Desvios (2)
• Forma anônima de interromper uma iteração de um
laço e avaliar a expressão novamente:
continue;
• Forma nominal de interromper uma iteração de um
laço e avaliar a expressão do dado nome:
continue label;
Desvios (3)
• Terminar a execução de um método:
return
• Terminar a execução de um método retornando um
valor:
return value;
Objetos
Criação de Objetos
• O operador new é utilizado para criar
novas instâncias de objetos.
Ex.:
Point origin = new Point(23, 94);
Rectangle rectOne = new Rectangle(origin, 100, 200);
Rectangle rectTwo = new Rectangle(50, 100);
Utilizando um Objeto
• Há duas formas de se utilizar um
objeto:
1. Manipulando ou consultando suas
variáveis
2. Chamando seus métodos
Acessando uma Variável de
Objeto
• O acesso a uma variável de objeto se
dá através de seu nome qualificado na
forma:
referenciaDoObjeto.NomeDaVariável
Ex.:
rectOne.width
rectOne.height
Chamando um Método de
Objeto
• De maneira análoga, a chamada a um
métodos de objeto se dá através da
forma qualificada:
referenciaDoObjeto.nomeDoMétodo(ListaDeArqumentos)
ou
referenciaDoObjeto.nomeDoMétodo()
Ex.:
rectOne.move(40,200);
rectOne.draw();
Eliminando Objetos não
Utilizados
• Objetos são elegíveis ao garbage collector
(gc) quando não possuírem mais referências
para eles.
– Uma referência deixa de ser válida
automaticamente quando seu escopo termina.
– Atribuindo null à referência é uma forma explícita
de liberar um objeto.
– Caso o objeto possua múltiplas referências, todas
devem ser anuladas antes que o objeto seja
elegível ao gc.
Finalização de Objetos
• Imediatamente antes de um objeto ser
coletado pelo gc, o método finalize do objeto
é executado.
– Útil para liberação de recursos que necessitem de
liberação explícita
Atenção: Como este método está presente na classe
Object, deve ser sobrescrito, e deve sempre chamar
o método finalize da super classe através da
chamada:
super.finalize();
Caracteres e Strings
Classes de Manipulação de
Caracteres
• Existem três classes de manipulação de
caracteres:
– Character – representa um caracter
simples
– String – representa uma seqüência
imutável de caracteres
– StringBuffer – representa uma seqüência
mutável de caracteres
Classe Character
• Construtores e métodos principais da classe
Character:
– Character(char) – construtor da classe. Uma vez criado,
um objeto não pode ter seu valor alterado.
– compareTo(Character): int – retorna se o valor do objeto
passado é maior, igual ou menor que o do objeto.
– equals(Object): boolean – retorna se o valor do objeto
passado é igual ou não.
– toString(): String – converte para String.
– charValue(): char – converte para tipo primitivo char.
– isUpperCase(char): boolean – retorna se é maiúscula ou
minúscula.
Classe String
• Um objeto String pode ser criado de um literal String:
String msg = “Hello World!”;
• O objeto String possui um tamanho, que representa
a quantidade de caracteres que compõem a string, e
cada caracter possui um índice que varia entre 0 e o
tamanho – 1.
Operador +
• O operador + pode ser utilizado para
concatenar dois objetos ou literais
String.
String world = “world”;
String msg = “Hello “ + world +”!”;
Classe String
• Principais métodos da classe:
–
–
–
–
–
–
–
–
length(): int – retorna o tamanho da String.
charAt(int): char – retorna o caracter da posição.
substring(int): String – retorna a sub string da posição até o final.
substring(int,int): String – retorna a sub string da prineira posição até
a segunda.
indexOf(char): int – retorna a posição do caracter na string ou –1
caso não seja encontrado.
lastIndexOf(char): int – retorna a última posição do caracter na
string ou –1 caso não seja encontrado.
startsWith(String): boolean – retorna true caso a String comece com
a string passada.
endsWith(String): boolean – retorna true caso a String termine com a
string passada.
Classe String
• Outros métodos da classe:
– concat(String): void – concatena a string à passada.
– equals(String): boolean – retorna true caso a string seja
igual a passada, é sensível a maiúscula/minúscula.
– equalsIgnoreCase(String): boolean – retorna true caso a
string seja igual a passada, independente de
maiúscula/minúscula.
– compareTo(String): int – retorna 0 caso as strings sejam
iguais, <0 caso seja menor e >0 caso seja maior.
Classe StringBuffer
• Armazena séries de caracteres, é possível
alocar uma área maior que a utilizada pela
String.
StringBuffer msg = new StringBuffer(20);
• Melhor aproveitamento e performance para
manipulação de cadeias de caracteres variáveis.
– Após completar a área estipulada, aloca outra área de
mesmo tamanho e assim por diante.
Classe StringBuffer
• Principais métodos da classe:
– append(String): void – concatena a string passada à string.
– toString(): String – converte para um objeto String.
Números
Números
• Os números podem ser representados
através de classes.
– constantes
– métodos
– serialização
Hierarquia de Classes
Formatação de Números
• A classe NumberFormat pode ser utilizada para
formatar números representados através de tipos
primitivos como Objetos:
Formatação Numérica
Double amount = new Double(345987.246);
NumberFormat numberFormatter =
NumberFormat.getNumberInstance(currentLocale);
String amountOut = numberFormatter.format(amount);
System.out.println(amountOut + " " +
currentLocale.toString());
345 987,246 fr_FR
345.987,246 de_DE
345,987.246 en_US
Formatação Monetária
Double currency = new Double(345987.246);
NumberFormat currencyFormatter = NumberFormat.
getCurrencyInstance (currentLocale);
String currencyOut = currencyFormatter .format(currency);
System.out.println(currencyOut + " " +
currentLocale.toString());
9 876 543,21 F fr_FR
9.876.543,21 DM de_DE
$9,876,543.21 en_US
Formatação Percentual
Double percent = new Double(0.75);
NumberFormat percentFormatter =
NumberFormat.getPercentInstance(currentLocale);
String percentOut = percentFormatter.format(percent);
System.out.println(percentOut + “ ” +
currentLocale.toString());
75% fr_FR
75% de_DE
75% en_US
Formatação Própria
• Também é possível definir uma formatação própria
para os valores numéricos segundo um padrão:
DecimalFormat myFormatter = new DecimalFormat(pattern);
String output = myFormatter.format(value);
System.out.println(pattern + " " + value + " " + output);
###,###.###
###.##
000000.000
$###,###.###
\u00A5###,###.###
123456.789
123456.789
123.78
12345.67
12345.67
123,456.789
123456.79
000123.780
$12,345.67
¥12,345.67
Arrays
Arrays
• Def.: São estruturas que armazenam
múltiplos valores do mesmo tipo.
– O tamanho é estabelecido no momento de
criação
– Após a criação o tamanho do array é fixo
Estrutura de um Array
Utilizando Arrays (1)
• Declaração de um array:
type[] name
Ex:
int[] anArray; // Uma array de inteiros
• Criação de um array:
new type[tamanho]
Ex:
int[] anArray = new int[20];
Utilizando Arrays (2)
• Obtendo o tamanho de um array:
name.length
• Acessando um elemento:
name[posição]
Ex:
for (int i=0; i<anArray.length; i++) {
System.out.println(anArray[i]);
}
Utilizando Arrays (3)
• Inicializando um array:
type[] name = { elemento1, elemento2, ..., elementoN};
Ex:
int[] anArray = { 2, 4, 8, 16, 32, 64 };
Array de Objetos
• É possível criar arrays tanto para tipos
primitivos como para objetos:
String[] anArray = {“Domingo”,”Segunda”, ...,”Sábado”};
Object[] anotherArray = { new Integer(10), “Dez”, new
Integer(20), “Vinte”};
Array de Arrays
• Também é possível definir array de
arrays, que recebem o nome de
matrizes:
double[] aMatrix = { { 1, 2, 3},
{ 4, 5, 6},
{ 7, 8, 9}};