Sintaxe I

Programação
Na Web
Linguagem Java
Parte I
Sintaxe
António Gonçalves
Algumas características
• Estruturas de controlo, operadores, expressões
e tipos básicos são semelhantes ao C++/C.
• Não há apontadores; Arrays e Strings são
objectos.
• Memória recuperada por garbage collector.
• Herança simples com raiz em Object.
• “Mistura de herança” através de interfaces.
• Strongly type checked estático e dinâmico.
• Suporte de threads; Object tem métodos para
concorrência.
• Suporte de excepções; O run-time gera
excepções.
JAVA - Aspectos básicos
http://ltodi.est.ips.pt/leonardo/ci/MaterialApoio.htm
Fontes em Unicode versão 2.0
• O Unicode 2.0 tem 38.885 caracteres.
• Os primeiros 128 são iguais ao ASCII.
• As fontes em ASCII são transformadas em Unicode.
• Para além das sequências de escape convencionais do C
podemos usar \uhhhh para um caracter em Unicode. Mas,
esta translação é feita antes da compilação.
• Identificadores e os conteúdos de char ou String podem
ter qualquer caracter Unicode.
static final double π = 3.1416
• No Unicode 2.1 \u20AC é o simbolo
€
JAVA - Aspectos básicos
do Euro.
http://ltodi.est.ips.pt/leonardo/ci/MaterialApoio.htm
Comentários
• Para além dos comentários /*...*/ e //... do C++ existe os
comentários de documentação /**...*/
• Os comentários de documentação devem prefixar a classe,
atributo ou método a documentar.
• O comando javadoc gera um documento HTML a partir do
código comentado.
• Estes comentários conter tags HTML.
• Uma linha começada por @ dentro destes comentários
serve para dar comandos adicionais ao javadoc.
– @see , @version , @author , @param , @return , @exception ,
– @deprecated , @since , @throws
JAVA - Aspectos básicos
http://ltodi.est.ips.pt/leonardo/ci/MaterialApoio.htm
Exemplo de geração de
documentação
/**
* Reassigns the "standard" error output stream.
*
* <p>First, if there is a security manager,
* its <code>checkPermission</code> method is
* called with a <code>RuntimePermission("setIO")</code>
* permission to see if it's ok to reassign the
* "standard" error output stream.
*
* @param out the new standard error output stream.
*
* @throws SecurityException
* if a security manager exists and its
* <code>checkPermission</code> method doesn't allow
* reassigning of the standard error output stream.
*
* @see SecurityManager#checkPermission
* @see java.lang.RuntimePermission
* @since JDK1.1
*/
public static void setErr(PrintStream err) {
checkIO();
setErr0(err);
}
JAVA - Aspectos básicos
http://ltodi.est.ips.pt/leonardo/ci/MaterialApoio.htm
Exemplo de geração de
documentação
JAVA - Aspectos básicos
http://ltodi.est.ips.pt/leonardo/ci/MaterialApoio.htm
Em Java não há um
preprocessador
• Não necessita #include
– Em java não é necessário. (import)
• Não existe #define
– Um método static final assume o papel de macro
(quase)
– Um atributo static final ou uma variável final é para todos os efeitos uma
constante.
– Algumas optimizações do compilador estão predefinidas na linguagem.
...
...
final
final int
int DEBUG_LEVEL
DEBUG_LEVEL == 10;
10;
if
if (( DEBUG_LEVEL
DEBUG_LEVEL >> 55 ))
A;
A;
else
else
B;
B;
...
...
JAVA - Aspectos básicos
A;
A;
http://ltodi.est.ips.pt/leonardo/ci/MaterialApoio.htm
Tipos primitivos
*
*
*
*
Os tipos primitivos têm dimensão fixa.
Todos os valores são com sinal.
Não existem modificadores.
Tipo
Conteúdo
Não há conversões
boolean
true, false
implícitas.
char
unicode
* Tipos primitivos
byte
inteiro com sinal
são sempre tratados
short
inteiro com sinal
por valor.
int
inteiro com sinal
long
inteiro com sinal
* Os arrays e as
float
vírgula flutuante
strings não são
double
vírgula flutuante
tipos primitivos.
JAVA - Aspectos básicos
Dimensão
1 bit
16 bit
8 bit
16 bit
32 bit
64 bit
32 bit
64 bit
http://ltodi.est.ips.pt/leonardo/ci/MaterialApoio.htm
boolean versus int
• Estão predefinidas as constantes true e false.
• Conversão de int para boolean tem que ser explicita
int i = ...;
boolean b = ( i !=0 );
• As condições são expressões do tipo boolean
int i = ...;
if ( i != 0 )
... // O operador != retorna um boolean
• Conversão de boolean para int recorrem normalmente a
expressões ternárias
boolean b = ...;
int i = ( b ? 1 : 0 );
JAVA - Aspectos básicos
http://ltodi.est.ips.pt/leonardo/ci/MaterialApoio.htm
Limites das operações aritméticas
• A divisão inteira por zero gera uma excepção que
pode ser ou não capturada.
int j=..., i=...;
try { i / j; }
catch(ArthmeticException e){
System.out.println(e);}
• As operações entre valores reais (float ou
double) não geram excepções.
• Estão definidas as constantes +0, -0, -∞,+∞ e
NaN.
float a = ..., b = ...;
if ( a / b == Float.POSITIVE_INFINITY ) {
System.out.println("b == 0");
}
JAVA - Aspectos básicos
http://ltodi.est.ips.pt/leonardo/ci/MaterialApoio.htm
Operadores são semelhantes ao C++
• Aritméticos
– binários: +, -, *, /, %
(+ entre strings)
– unários: +, - e ainda os prefixos e sufixos ++, -• Relacionais:
>, <, ==, <=, >=, !=,instanceof
• Condicionais:
&&, ||, !, ?:
• Bit a bit:
>>, <<, &, |, ^, ~, >>>
• Afectação:
=, +=, -=, *=, etc.
• Especiais: [], (param), ., new, (type)
- Aspectos
básicospermite a sobrecarga de operadores
http://ltodi.est.ips.pt/leonardo/ci/MaterialApoio.htm
• JAVAMas
não
Prioridade e associatividade dos
operadores
• As regras de prioridade e de associatividade dos
operadores são
sufixos
[] . (arg) ++ -semelhantes ao C++.
•
•
prefixos
tipo
Todos os operadores
aritméticos
binários, excepto os
shift
de afectação, são
associativos à esquerda. relacionais
igualdade
bit a bit
A prioridade é a
lógicos
indicada na tabela.
ternários
afectação
JAVA - Aspectos básicos
++ -- - + ~ !
new (type)
{* / %} {+ -}
>> << >>>
> < >= <= instanceof
== !=
{&} {^} {|}
{&&} {||}
?:
= += *= >>= etc.
http://ltodi.est.ips.pt/leonardo/ci/MaterialApoio.htm
Precedência de operadores
Aumenta
prioridade de
resolução
( ) [] . ; ,
++ -- !
*/%
+>> << >>>
> < >= <=
== !=
&
^
|
&&
||
?:
=
Diminui prioridade
de resolução
JAVA - Aspectos básicos
http://ltodi.est.ips.pt/leonardo/ci/MaterialApoio.htm
Classes Wrapper
• Cada tipo primitivo possui uma classe
correspondente (wrapper class)
Primitive
Data Type
byte
short
int
long
float
double
char
boolean
Corresponding
Object Class
Byte
Short
Integer
Long
Float
Double
Character
Boolean
– O valor é armazenado num campo do objecto
JAVA - Aspectos básicos
http://ltodi.est.ips.pt/leonardo/ci/MaterialApoio.htm
Uso de Wrapper
• Define constantes uteis para cada tipo
– Exemplo,
Integer.MAX_VALUE
Float.NEGATIVE_INFINITY
• Converte tipos
– Usar o método parseXxx para converter String para o
tipo primitivo correspondente
try {
String value = "3.14e6";
double d = Double.parseDouble(value);
} catch (NumberFormatException nfe) {
System.out.println("Can't convert: " + value);
}
JAVA - Aspectos básicos
http://ltodi.est.ips.pt/leonardo/ci/MaterialApoio.htm
Wrappers: Conversão de Strings
Data Type
byte
new
short
new
int
new
long
new
float
new
double
new
JAVA - Aspectos básicos
Convert String using either …
Byte.parseByte(string )
Byte(string ).byteValue()
Short.parseShort(string )
Short(string ).shortValue()
Integer.parseInteger(string )
Integer(string ).intValue()
Long.parseLong(string )
Long(string ).longValue()
Float.parseFloat(string )
Float(string ).floatValue()
Double.parseDouble(string )
Double(string ).doubleValue()
http://ltodi.est.ips.pt/leonardo/ci/MaterialApoio.htm
Instruções de controlo
• Decisão:
if-else,
• Repetição:
for, while, do-while
• Quebra:
break, continue, return
• Excepção:
try-catch-finally, throw
switch-case
• Desta vez é que foi, não existe goto
– mas o break e o continue podem ter o nome do bloco de
instruções a quem vão quebrar o fluxo.
JAVA - Aspectos básicos
http://ltodi.est.ips.pt/leonardo/ci/MaterialApoio.htm
Comandos de controle (cont.)
Exemplo de selecção
clicado%=4;
switch(clicado){
case 0: saida=3;
break;
case 1: saida=2;
break;
default: saida=0;
}
System.out.println(saida);
JAVA - Aspectos básicos
http://ltodi.est.ips.pt/leonardo/ci/MaterialApoio.htm
Comandos de controle (cont. )
Exemplo de repetição com while
while(x>6){
while(y>9){
while((z>=6) && (m!=10)){
z++;
m%=10;
}
y=z+m;
}
x+=y;
}
JAVA - Aspectos básicos
http://ltodi.est.ips.pt/leonardo/ci/MaterialApoio.htm
Comandos de controle (cont.)
Exemplo de repetição com do-while
do{
do{
do{
z++;
m%=10;
} while((z>=6) && (m!=10));
y=z+m;
} while(y>9);
x+=y;
} while(x>6);
JAVA - Aspectos básicos
http://ltodi.est.ips.pt/leonardo/ci/MaterialApoio.htm
Comandos de controle (cont.)
Exemplo de repetição com for
for(x=0,y=0;((x<100) && (y<=20));x++,y++){
for (int z=-5;z<10;z+=3)
System.out.println(z);
System.out.println(y);
}
JAVA - Aspectos básicos
http://ltodi.est.ips.pt/leonardo/ci/MaterialApoio.htm