Apàndice F

APÊNDICE F
Manual de Sintaxe
da Linguagem Java 2
CONTEÚDO
F.1 O que é um programa Java? F.11 Sentenças

F.2 Comentários F.12 Classes
F.3 Palavras reservadas F.13 Estrutura de programas Java
F.4 Identificadores F.14 Sobrecarga de métodos
F.5 Tipos de dados F.15 Herança
F.6 Variáveis F.16 Pacotes
F.7 Arrays F.17 Interfaces
F.8 Expressões F.18 Exceções
F.9 Operadores F.19 Miscelânea
F.10 Impressão básica
A linguagem Java é descrita por sua sintaxe e sua semântica. A sintaxe define a estrutura e a aparência da
escrita do código Java. A semântica define o que significa cada parte do código e como irá comportar-se quan-
do for executado.
Os componentes básicos da sintaxe são palavras reservadas (keywords) e componentes do léxico (tokens).
Uma palavra reservada é uma palavra ou identificador que tem um significado específico na linguagem. As pa-
lavras reservadas só podem ser utilizadas no mundo onde está definida a linguagem. Os componentes do léxico
(token) incluem cada palavra, símbolo ou grupo de símbolos que aparecem no código-fonte do programa.
Uma gramática é utilizada para agregar todos os componentes da sintaxe e definir a estrutura de unidades
sintaticamente correta do código Java. A gramática Java especifica a ordem precisa onde podem ser escritos
as palavras reservadas e os símbolos, e é utilizada pelo compilador Java para assegurar que o programador faz as
coisas corretas. Qualquer código que não esteja escrito de forma correta emitirá mensagens de erro e não irá
construir um programa executável.
Este apêndice descreve as regras básicas de sintaxe de Java que cumprem as diferentes versões existentes:
JDK1.1, 1.2, 1.3 e 1.4, com o compilador Java 2.0. Grande parte da sintaxe de Java é baseada em C e/ou C++.

Fundamentos de programação – Algoritmos, estruturas de dados e objetos
F.1 O QUE É UM PROGRAMA JAVA?

Um programa Java é uma coleção de classes. Algumas classes são escritas e algumas fazem parte da lingua-
gem Java. Um programa Java deve conter um método estático denominado main( ). O programa começa
especificando o nome dessa classe no sistema Java no tempo de execução que ativa o método main( ).
De forma alternativa, podemos escrever um applet. Os apletts são executados dentro de um programa
navegador Web.
O SDK (Java Software Development) pode ser obtido do site de Java (http://java.sun_com). Também
conhecemos como JDK (Java Developmente Kit). A versão atual de Java é 1.4.
Tabela F.1 Ferramentas de JDK
Ferramentas Uso
Javac Compilador Java.

Java Intérprete Java, utilizado para executar programas compilados.
Aplletviewer Utilizado para visualizar o applet tal como pode ser visto pelo navegador.
JDb Depurador.
Javadoc Gerador de documentação.
F.2 COMENTÁRIOS
Os comentários permitem acrescentar ao código-fonte notas ou comentários de texto que são ignorados pelo
compilador. Os comentários vêm em três formatos:
1. // Comentários de uma linha só

2. /* Comentário
multilinha */
3. /** Comentário de
4. documentação */
1. Os comentários de uma linha só começam com // e continuam até o final da linha.

2. Os comentários multilinha começam com /* e terminam com */.
3. Os comentários de documentação são um tipo especial de comentários multilinha que começa com /**.
Utiliza-se para embutir na documentação do código-fonte de uma chave e pode ser lido com o próprio
código-fonte com a ferramenta Javadoc para gerar documentação HTML para suas classes.
F.3 PALAVRAS RESERVADAS
Certas palavras estão reservadas para uso interno por Java e não podem ser utilizadas como nomes de variáveis:
abstract throw if new import

conft break scictpf private
finally default try switch
int long catch volatile
public goto elye class
this throw implemets final
boolean byte do package instance of
continue native super protected
float static void synchronized
interface tranfient care char while
return double extendy
Manual de sintaxe da linguagem Java 2mm
As palavras reservadas const e goto são reservadas mas não são utilizadas.
Nota
Além dessas palavras reservadas, Java reserva false, null e true como valores definidos na
linguagem.
F.4 IDENTIFICADORES
Um identificador é o nome de variáveis, métodos, classes e interfaces. Um identificador é uma seqüência
ilimitada de caracteres alfabéticos ou dígitos (unicode) que começam com um caractere alfabético. Os nomes
podem incluir o caractere sublinhado (_) e o cifrão ($).
Nomes válidos
Uma prática freqüente é criar um identificador pela concatenação de duas ou mais palavras ligadas pelo
caractere sublinhado ou utilizando letras maiúsculas nas primeiras letras das palavras.
Salário_mensal posição_Relativa elemento_Tabela
Regra
Os identificadores que começam com uma letra maiúscula são reservados somente para nomes de
classe ou interfaces.
Os identificadores que estejam todos em maiúsculas representam constantes.
Os nomes das variáveis e dos métodos começam com letras minúsculas.
F.5 TIPOS DE DADOS

Os tipos de dados mais simples em Java são: inteiros, ponto flutuante, boolean, lógicos e caractere.
Tabela F.2 Tipos de dados
Tipo de dado Se utiliza para armazenar Requisitos de armazenamento
boolean Este tipo de dado pode receber dois valores

(true, verdadeiro; false, falso) 1 bit
byte Um byte de dados (Intervalo –128 .. 127) 1 Byte
char Um caractere UNICODE 2 Bytes
double Números de ponto flutuante de dupla precisão
Intervalo 1.7e–30 .. 1.7e + 308 8 Bytes
int Número inteiro entre
Intervalo –2.147.483.648 .. –2.147.483.647 4 Bytes
float Número de ponto flutuante de simples precisão
Intervalo 3.4 e–38..3.4e + 38 4 Bytes
long Número inteiro entre
Intervalo –9..223.372.036.854.775.808 ..
9.223.372.036.854.775.807 8 Bytes
short Número inteiro entre
Intervalo 32.768 .. 32.767 2 Bytes
F.5.1 Literais
Os literais permitem valores de tipos primitivos, os tipos string ou null são escritos diretamente como um
texto de programa.
Literais inteiros
Valores decimais de tipo int (32 bits).
0,124, -525, 55661, 2354657, -321124
Valores hexadecimais de tipo int ( ) precedidos por um 0 ou DX (os dígitos hexadecimais podem ser
representados por a-f ou A-F).
DXD DX12F OXFFED DXFFFF 0X12DEFF
Valores octais de tipo int estão precedidos por um 0 à esquerda seguido por dígitos no intervalo 0-7.
00, 0123, 0777, –045321, –05
Literais de ponto flutuante

Os números básicos de um ponto flutuante incluem um ponto decimal.
1.2345 1234.5678 0.1 305 –24.123
Se o número da ponto flutuante termina com um sufixo f ou F será de tipo Float.
1.23f 3.456F of .5Ff –45673F
O sufixo d ou D pode ser utilizado para representar tipos double.
Regra
Os literais em ponto flutuante em Java são por default double precisão. Para especificar um li-
teral float, deve ser acrescentada uma consoante F ou f. Podemos especificar explicitamente
um literal de tipo double acrescentando D ou d.
Literais boolean
Existem dois valores lógicos que podem ter um valor lógico ou boolean: true (verdadeiro) e false (falso).
Literais caractere
Um literal caractere representa somente um caractere entre aspas simples.
‘a’, ‘A’, ‘i’, ‘4’

Tabela F.3 Seqüência de escape
Seqüência de escape Descrição
\ddd Caractere octal (ddd)

\uxxx Caractere hexadecimal UNICODE (xxx)
\’ Aspa simples
\“ Aspas duplas
\\ Diagonal
\r Retorno de carro
\n Nova linha
\f Avanço de página
\t Tabulação
\b Retrocesso
Literais de cadeia
Os literais de cadeia são especificados fechando-se uma seqüência de caracteres entre aspas.
“Olá Carchelejo”
“cinco/nlinhas”
“Isto é uma cadeia”,“Olá mundo/n”
F.6 VARIÁVEIS
As variáveis são unidades básicas de armazenamento em Java. Uma variável é definida pela combinação de
um identificador, um tipo e um inicializador opcional. Além disso, as variáveis têm um escopo que define sua
visibilidade e uma duração.
F.6.1 Declaração de variáveis
Uma variável deve ser declarada antes de poder ser utilizada.
Sintaxe nometipo identificador

nometipo identificador = expressão
É possível declarar duas ou mais variáveis por vez.
Nometipo id1, id2...;
Existem duas categorias de variáveis:
1. Variáveis de tipo primitivo que contêm diretamente uma representação de um valor de um tipo primitivo.
2. Variáveis de tipo referência que contêm uma referência a um objeto, quando um tipo de referência
recebe o valor null, significa que não se refere a um objeto real (referência nula).
F.6.2 Modificação de variáveis

As variáveis podem ser modificadas mediante indicadores.
public A classe ou variável de instância é acessível de todos os escopos.

protected A classe ou variável de instância é acessível somente no escopo atual da classe, no escopo do pacote
atual e de todas as subclasses da classe atual.
private A classe ou variável de instância é acessível somente no escopo atual da classe.
final A variável é uma constante, de forma que seu valor não pode ser modificado.
static A variável é uma variável classe, compartilhada entre todos os objetos instância de uma classe.
transient Declara-se que não é parte de um estado persistente do objeto.
volatile É necessária às vezes quando se utiliza uma variável instância por fios para prevenir o compilador
de sua otimização.
F.6.3 Inicialização de variáveis

Utilizam-se os seguintes valores por default:
byte (byte) 0
short (short) 0
int 0
long 01
float 0.0f
double 0.0d
char ‘/ u000’(caractere nulo)
boolean false
tipos referência null
A inicialização é realizada em três formatos:
1. int i=100;
char c=‘d’;
float f=45.325F
2. int i;
{i=100;}
3. Atribuição dentro do corpo de um construtor
int a=10,b,c=5;
F.6.4 Variáveis parâmetro

Essas variáveis sempre se inicializam com uma cópia do valor utilizado na ativação do método ou construtor.
Não há um controle do programador nesse mecanismo.
F.6.5 Variáveis locais

Todas as variáveis locais devem ser inicializadas explícita, direta ou indiretamente, antes de seu uso.
{
int i=10;
...
}
Ou por uma atribuição feita na variável antes de ser utilizada em qualquer outra expressão.
{
int i;
... // nenhuma sentença pode utilizar aqui i
i=10; // não se atribui 10 a i
... // i pode ser utilizado aqui
}
F.6.6 Variáveis finais

As variáveis que são declaradas final devem ser inicializadas quando são declaradas e não podem ser
modificadas.
static final int MAX_CONTA=100,
F.6.7 Conversão de tipos

Quando um tipo de dado é atribuído a outro tipo de variável, tem lugar uma conversão automática de tipos
caso se cumpram as duas condições seguintes:
• Os dois tipos são compatíveis.
• O tipo destino é maior que o tipo forte.
double a = 6.0
float b;
b= (float) a;
a variável double se converte em float e é atribuída à variável b
• As variáveis primitivas nunca podem ser moldadas a um objeto classe.

String objstr=(string)0, //erro
• Para converter um inteiro em uma cadeia, acrescentar um literal de cadeia vazia.

String obj_str = 0 + “”; // o operador + significa
Caracteres especiais
Caracteres especiais de difícil representação.
Tabela F.4 Caracteres especiais
Sintaxes Significado
\‘ Aspa simples
\“ Aspas duplas
\\ Diagonal
\b Retrocesso
\f Avanço de página
\n Nova linha
\r Retorno de carro
\t Tabulação
\dee Representação octal
\xdd Representação hexadecimal
\udddd Caractere unicode
F.7 ARRAYS
Um array é um grupo de variáveis de tipos similares que são conhecidas com um nome comum. Os diferen-
tes elementos contidos em um array são definidos por um índice e são acessados utilizando seu índice; os
índices partem de 0. Os arrays podem ser multidimensionais e, como os objetos da classe, são criados utili-
zando-se a palavra reservada new.
F.7.1 Arrays de uma dimensão

Para criar um array, devemos criar primeiro uma variável array de tipo desejado. A declaração é:
Tipo nome_van[ ];
int dia_mês [ ];0
O operador new serve para alocar memória e criar um array de uma dimensão.
Var_array=new tipo[comprimento];
Dia_mês=new int[12]; //array de 12 inteiros
Dia_mês[1]=28, // array 28 a dia_mês
Sintaxe
Tipo variável nomeArray[ ]=new tipo Variável[logArray];
Tipo Variável[ ] nomeArray=new tipovariável[longArray];
1. int [ ] dados =new int [15]; int dados [ ];

dados=new int[15];
F.7.2 Arrays multidimensionais

Em Java, os arrays multidimensionais são realmente arrays de arrays.
Tipovariável [ ] nomearray=[val1,val2...valn];
Esta sentença cria um array de n elementos e o inicializa com os valores contidos entre chaves. A sintaxe
completa é:
Tipovariável[ ] nomearray=new tipovariável[ ]{val1,val2...vanln}
Exemplo
Int dosD[ ] [ ]new int[4] [5];
Essa sentença atribui um array de inteiros, 4 por 5, e o atribui a dosD
Sintaxe alternativa da declaração de arrays

tipo[ ] nome-var
As seguintes declarações são equivalentes:
int a1[ ]=new int[3];

int [ ]a2 = new int[3];
As duas seguintes declarações são também equivalentes:
char mod1[ ][ ]=new char[3][4],

char [ ][ ]mod2=new char[3][4]
Acesso e atribuição de valores a elementos de um array

A sintaxe para acessar um elemento é:
NomeArray[índice]
E para atribuir o valor ao membro do array, é especificado ao índice. Por exemplo:
NomeArray[índice]=valor;
por exemplo:
Dados[0]=45;
F.7.3 Arrays de duas dimensões

TipoVariável [ ][ ] nomeArray=new tipoVariável[filas][colunas].
Cria um objeto array de duas dimensões. Se o número de colunas é deixado em branco, o array pode ter
um número de colunas diferentes no final.
Exemplo
Criar um array bidimensional com 8 filas e um número variável de colunas por fila. A primeira fila é
criada com 20 colunas, e a terceira, com 100 colunas.
class TestArraybidimensional {
public static void main (String arrays[ ]){
int[ ][ ]multD=new int[8];
multD[0]=new int 20];
multD[1]=new int[1000];
}
}
Inicialização de um array de duas dimensões

TipoVariável[ ][ ]nomeArray={{val1,val2...},{val1,val2...}}
Cria um array bidimensional e inicializa as colunas com os valores contidos entre chaves. Cada conjunto
de chaves representa uma fila de array bidimensional.
Exemplo
Inicializar um array bidimensional de valores inteiros de modo que se visualize o elemento [0][2].
public class tesArray2D

public static void main(String arrays[ ]){int[ ][ ]multiD=}{1,2,3,4,5}
{6,7,8,}
};
system.out.print1/“O elemento[0][2] é + multiD[0][2];
10 Fundamentos de programação – Algoritmos, estruturas de dados e objetos
F.7.4 A variável lenght

Todos os arrays unidimensionais têm uma variável de instância denominada lenght associada a eles.
Essa variável contém o comprimento do array. No caso de arrays bidimensionais, a variável lenght é
utilizada para acessar o comprimento da primeira fila.
public class teslongitudinal
public static void main(string arrays[ ]){int[ ][ ]multiD={1,2,3,4,}
{5,6,7}
};
system.out.print1 (“o comprimento da 1ª fase é +multiD[0].lenght”);}
}
Saída
O comprimento da 1ª fase é 4
F.8 EXPRESSÕES
As expressões são utilizadas para buscar, calcular e atribuir valores. Exceto para a ativação de um método com
um tipo de retorno void, todas as expressões devolvem um valor, permitindo que as expressões se combinem
em mais expressões complexas. As expressões principais trazem ou criam valores e são:
As palavras reservadas this, super e null.

Um valor literal.
Uma expressão com parênteses.
Uma expressão de campo, utilizando «.».
Uma expressão de índices de array, utilizando «[ ]».
Uma expressão de ativação de métodos.
Uma expressão de atribuição.
Expressão com parênteses

(expressão)
Expressão de campo
Identificador
Expressão principal. Identificador
Pacote. Identificador
Expressão de índices de arrays

Termo[expressãoValorinteiro]
Expressão de atribuição
new numbertipo (listaArgumentos)
new numbertipo [expressãoInteira]
F.9 OPERADORES
Os operadores permitem que as expressões se combinem em expressões mais complexas. Java proporciona
uma coleção grande de operadores que podem ser utilizados para manipular dados, incluindo operadores
aritméticos, atribuição, lógicos e moldados. As regras de associação e de prioridade são utilizadas para
determinar como avaliar expressões utilizando operadores.
Manual de sintaxe da linguagem Java 2mm11
F.9.1 Operadores aritméticos

Os operadores aritméticos são utilizados em expressões matemáticas como são utilizados em álgebra.
Tabela F.5 Operadores aritméticos
Operador Significado
+ Adição
– Subtração
* Multiplicação
/ Divisão
% Módulo
++ Incremento em 1
—— Decremento em 1
Os operadores incremento e decremento podem aparecer em formato prefixado (++variável) ou

pós-fixado (variável--). No formato prefixado, a variável é incrementada ou decrementada antes que
seja executada qualquer operação. Nesse formato pós-fixado, a variável é incrementada ou decrementada
depois que outras operações foram executadas.
F.9.2 Operadores de atribuição

O operador de atribuição simples é utilizado para atribuir um valor a uma variável, var = expressão. Outros
operadores de atribuição combinam a atribuição com uma operação aritmética.
var=var op expressão, equivale a var op =expressão;

x += y equivale a x=x+y
Exemplo
int x,y,z;
x=y=z=100;//x,y,z, colocando a 100
Tabela F.6 Operadores de assinatura
= Atribuição simples
+= Atribuição e adição
-= Atribuição e subtração
*= Atribuição e multiplicação
/= Atribuição e divisão
%= Atribuição e módulo, devolve o resto do valor da expressão da esquerda dividido pelo valor da
expressão da direita
F.9.3 Operadores lógicos (booleanos)

Os operadores lógicos (boolean) são utilizados para manipular valores boolean.
Tabela F.7 Operadores lógicos
&
& AND lógico
| OR lógico
^ XOR lógico (OR exclusive)
|| OR curto circuito (condicional)
&& AND curto circuito (condicional)
! NOT unitário lógico
&= Atribuição AND
|= Atribuição OR
^= Atribuição XOR
Tabela F.8 Tabela verdade
A B AIB A&B A^B !A
Falso falso falso falso falso verdadeiro

Verdadeiro falso verdadeiro falso verdadeiro falso
Falso verdadeiro verdadeiro falso verdadeiro verdadeiro
Verdadeiro verdadeiro verdadeiro verdadeiro falso falso
F.9.4 Operador ternário (condicional)

Java inclui um operador especial ternário que pode substituir certos tipos de sentenças if-then-else.
Seu formato é:
expressão1 ?expressão2= expressão3
expressão1 é qualquer expressão que é avaliada em um valor lógico (booleano). Se expressão1 for
verdadeira, então se avalia a expressão2. O resultado da operação ? é o da expressão avaliada. Tanto a ex-
pressão2 como a expressão3 têm de devolver o mesmo tipo de retorno que não pode ser void.
1. k=i<0 ? –i=i; obtém-se o valor absoluto de i

2. int i=j<0?5:10, atribui a i se j for menor que 0, e a 10, caso contrário
F.9.5 Operadores relacionais

Os operadores relacionais determinam a relação que um operador tem com outro. Especificamente, determi-
nam igualdade e desigualdade.
Tabela F.9 Operadores relacionais
= = Igual a
! => Não igual a
> Maior que
< Menor que
>= Maior que ou igual a
<= Menor que ou igual a
F.9.6 Regras de precedência

A Tabela F.10 mostra a ordem de precedência (prioridade) de maior ou menor. Os parênteses são usados para
alterar a procedência da operação.
Tabela F.10 Precedência dos operadores Java
Mais alta
( ) [ ]
++ --
+ - ! (tipo) new
* / %
+ -
< <= > >= instância de
= !=
&&
||
?:
= += -= *= /= %=
Mais baixa
Os parênteses elevam a precedência das operações que estão em seu interior. Essa técnica é utilizada para
obter o resultado desejado.
F.10 IMPRESSÃO BÁSICA
O fluxo de saída padrão permite acessar os métodos básicos de impressão; print ( ) e println ( ), da classe
PrintStream. Ele proporciona uma referência a um objeto de printStream que pode ser acessado por
esses métodos. A variável out é um membro da classe System.
Sintaxe System.out // uso da variável out
F.10.1 Método print ( )

print( ) imprime o argumento parado na saída padrão; sem um caractere fim de linha.
Sintaxe
public void print(Sring s)

public void print(boolean b)
public void print(char c)
public void print(double d)
public void print(float f)
public void print(int i)
public void print(long l)
public void print(Object ob)
F.10.2 Método println ( )

Println ( ) é semelhante ao método print ( ), exceto um caractere fim de linha ou seqüência que se acres-
centa ao final.
public void print(String s)

public void print(boolean b)
public void print(char c)
public void print(double d)
public void print(float f)
public void print(int i)
public void print(long l)
public void print(Object ob)
Exemplo
public class testeImpressão1{
public static void main(String args[ ])}
for (int i=1;i<5,++i){
System.out.print(“ linha número”+i);
}
}
}
public class testeImpressão2{

public static void main(String args[ ])}
for (int i=1;i<5,++i){
System.out.println(“linha número”+i);
}
}
}
F.11 SENTENÇAS
Sentenças de declaração
tipo nomeVariável;
Exemplos
int comprimento;
double e;
Círculo círculo;
Sentenças de atribuição
Uma sentença de atribuição atribui o valor da expressão no lado direito à variável do lado esquerdo.
nome = expressãoLegal;
Exemplo
comprimento= 5 + 7;
i += 5;
Sentenças return
As sentenças return proporcionam uma saída de um método com um valor de retorno não void. As sentenças
de retorno podem não aparecer em um método com um tipo de retorno void. As sentenças return podem
aparecer em qualquer parte de uma estrutura de controle; produzem um retorno imediato do método. O valor
da expressão a seguir do retorno deve coincidir com o tipo de retorno do método.
Exemplo
public int calcularSubtrair (int x, int y) {
return x–y;
}
Sentenças compostas
As sentenças compostas estão entre chaves { } e são executadas seqüencialmente dentro do bloco.
Exemplo
{
int m = 25; // atribui o valor 25 a m
int n = 30; // atribui o valor 30 a n
int p = m + n; // atribui o valor 55 (m + n) a p
}
Sentença if
As sentenças de seleção proporcionam controle sobre duas alternativas com base no valor lógico de uma
expressão.
if (expressãoLógica)
blocoSentenças1 //se são várias sentenças elas estão entre { }
[else if (expressãLógica)
blocoSentença2]
...
[else
blocoSentençasN]
Exemplo
if (i < 0)
System.out.println(“Número negativo”);
else
{
System.out.print(“Número válido, ”);
System.out.println(“é positivo”);
}
Sentenças switch
A sentença switch é a múltipla bifurcação:
switch (expressão_int)
{
case constante_exp1:
sentenças1;
/*tratando-se de múltiplas ações não é necessário estar entre chaves */
[break;]
[case constante_exp2:
sentenças2;
[break;]]
...
[case constante_expN:
sentençasN;
[break;]]
[default
sentençasX;
[break;]]
}
Exemplos
1. switch (y / 50)
{
case 2: elemento = new Demo2(0, 0); break;
case 3: elemento = new Demo3(0, 0, 100); break;
case 4: elemento = new Demo4(0, 0, 200); break;
case 5: elemento = new Demo5(0, 0); break;
}
2. switch (n)
{
case 1:
case 2:
visualizarResultado(“1, 2, Serra de Cazorla”);
break;
case 3:
case 4:
visualizarResultado(“3, 4, Serra Magna”);
case 5:
case 6:
visualizarResultado(“3, 6, Serra de Jaen”);
break;
default:
visualizarResultado(n + “ fora do intervalo”);
} //fim de switch
Etiquetas
nomeEtiqueta:
break [nomeEtiqueta];
continue [nomeEtiqueta];
Exemplo
sair:
{
for (i = 0; i < 10; i++)
{
for (j = 0; j < 20; j++)
{
if (i == 1) break sair;
System.out.print(j + “ ”);
}
System.out.println ( ) ;
}
} //fim do bloco com a etiqueta
Sentença while
A sentença while é utilizada para criar repetições de sentenças no fluxo do programa.
while (expressãoLógica)
blocoSentenças // o blocoSentenças pode ser executado de 0 a n vezes
Exemplo
while (conta <= número)
{
System.out.print(conta + “, ”);
conta++;
}
Sentença do-while
A sentença do-while é utilizada para repetir a execução de sentenças e é executada pelo menos uma vez.
do
blocoSentenças // o blocoSentenças é executado pelo menos uma vez
while (expressãoLógica);
Exemplo
do
{
System.out.print(conta + “, ”);
conta++;
}
while (conta <= número)
Sentença for
A sentença for é usada para repetir um número fixo de vezes a execução de uma série de sentenças.
for ([início]; [condiçãoDeTeste]; [atualização]);

sentenças
Exemplo
for (int i = 0; i < 10; i++)
a[i] = 5 * i;
Método exit e sentença break

A sentença break pode ser utilizada em uma sentença switch ou em qualquer tipo de sentença de laços.
Quando é executado break, o laço que o contém ou a sentença switch terminam e o resto do corpo do laço
não é executado. Uma invocação ao método exit termina uma aplicação. O formato normal de uma invocação
ao método exit é:
System.exit(0);
As estruturas de controle proporcionam um meio para controlar o fluxo da execução de um programa.

As sentenças de controle de um programa em Java se dividem em três categorias: seleção, iteração e salto.
As sentenças de seleção permitem a um programa escolher caminhos diferentes de execução baseados no
valor de uma expressão ou no estado de uma variável. As sentenças de iteração permitem a repetição de
uma ou mais sentenças (essas repetições ou iterações são conhecidas como laços).
As sentenças de salto ou bifurcação permitem a um programa executar-se de uma forma não-linear.
Sentenças de seleção: if,switch

Sentenças de repetição (laços): while,do,for
Sentenças de transferência: break,continue,return
F.11.1 Sentenças seletivas

A sentença if é uma sentença de bifurcação condicional dependendo do valor de uma expressão lógica.
Sintaxe
1. if(expressão lógica) 2. if (expressão lógica)

sentença sentença
else
sentença
3. if (condição1){
sentença;
}else if (condição2){
sentença;
{else{
sentença;
{
Exemplo
1. if(a== b) { 2. if(a==b)
c=10; c=10;
d=25; else
} d=25;
h=1.5; h=1.5;
3. if (a= =b)
if(c= =d){
system.out.print1(“c= =d”);
}
else{
System.out.print1(“c!=d”);
}
4. public class teste If{

public static void main(String args[ ]){
int m=2 ;
if(m= =2);
system.out.println(“m é 2”);
else {
system.out.println(“m não é 2”);
}
}
}
Sentenças if-else (if em escada)

if (condição)
sentença
else if (condição)
sentença
else if (condição)
sentença
-
-
–
else
sentença
Sentença switch
A sentença switch é uma sentença de múltipla bifurcação. Proporciona um meio de selecionar a execução
de diferentes partes do código dependendo do valor de uma expressão.
switch (expressão){
case valor 1
//seqüência de sentenças
break
case valor 2
break;
-
-
-
case valor
break
default;
}
F.11.2 Operador +
O operador + é um operador de concatenação de cadeia String quando um dos operadores for uma cadeia
(String), caso contrário será representada a soma aritmética.
Exemplo
public class TesteCadeia {
public Static void main(String args[ ]){
system .out println(5+6+7+“teste”);
system. Out. Println(“teste ”+5+6+7);
}
}
Saída
18 teste
Teste 567
Expressão deve ser de tipo byte, short, int ou char.

Valor deve ser um colateral único (uma constante, uma variável), não podem ser duplicados
os valores de case.
Exemplo
public class TesteCase {
char letra =‘b’;
int pontos;
switch(letra){
case‘A’:
Pontos=100;
break;
case‘B’:
Pontos=70;
break;
default:
Pontos=0;
}
System.out.println (“pontos=” + pontos);
}
}
Sentenças switch aninhadas

Pode ser utilizada uma sentença switch como parte da seqüência de sentenças de uma sentença switch
externa.
switch(contador){
case 1;
switch (total){
case 0:
System.out.println(“total é zero”);
break;
case 1:
System.out.println(“total é zero”);
break
}
break;
case2:...
F.11.3 Sentenças iterativas (repetitivas)

As sentenças de iteração ou repetição criam laços. Um laço executa repetidamente o conjunto de instruções
que contém até que se cumpra uma condição de terminação.
while
O laço while permite que uma sentença ou bloco de sentenças seja executado repetidamente enquanto for
verdadeira uma condição ou expressão lógica.
Sintaxe
while(condição){
// corpo do laço ... sentença /sentenças
}
A condição do laço é avaliada antes de ser executado o laço, de modo que a condição é avaliada
inicialmente.
Exemplo
1. // conta de 0 a 9
int x=0;
while(x<10){
System.out.println(x);
x++;
}
//x=10 depois de terminar o laço
2. // teste do laço while

class while{
int n=10;
while(n>0){
system.out.println(“conta”++n);
n--;
}
}
}
do-while
O laço do permite que uma seqüência de sentenças seja executada repetidamente enquanto uma condição
lógica é avaliada como verdadeira, e termina caso contrário. Em uma seqüência do-while, o corpo do laço
é executado pelo menos uma vez.
Sintaxe
do
//sentenças, corpo do laço
while (condição);
Exemplo
1. int x = 0;
do
System.out.println(x);
x++
}while(x<10);
//x=10 depois que termina o laço
2. // teste do laço do-while

class DoWhile{
public static void main(String args [ ]){
int n=10;
do {
System.out.println(“conta”++n);
n--;
}while (n>0);
}
}
for
O laço for executa as sentenças do corpo um número fixo de repetições (iterações) que depende de uma
variável de controle.
Sintaxe
for (inicialização, condição, iteração){

//corpo do laço
}
inicialização é utilizada para inicializar e também no caso de travar a variável do laço.

for(int n=1;...)
condição expressão lógica, é avaliada, se for verdadeira é executado o corpo do laço, se for falsa,
termina o laço.
for (...;x<10;...)
Iteração normalmente é uma expressão que é avaliada depois de cada execução do corpo do
laço. Em geral, atualiza (incrementa/decrementa) a variável de controle do laço.
for(...;...;n++)
Exemplo
1. for (int x=1; x<=10;x++)
// corpo do laço
}
2. //teste laço for

class TesteFor {
public static void main(string args[ ]){
int n;
for (n=10;n>0;n-)
system.out.println(“conta”+n);
}
}
Declaração da variável de controle dentro do laço

Se a variável de controle do laço for utilizada somente para a execução do laço, costuma ser declarada na
sessão de inicialização do laço for.
3. //declaração da variável de controle no laço

class Teste For {
for(int n=10; n>0;n-)
System.out.println(“conta”+n);
}
}
Uso de separador de vírgula

Às vezes desejamos incluir mais de uma sentença nas partes de inicialização e iteração do laço for. Neste caso,
são separadas pela vírgula.
4. //uso da vírgula
class vírgula{
int a,b;
for(a=1,b=5; a<b; a++,b--){
System.out.println(“a= ”+a);
System.out.println(“b= ”+b);
}
}
}
Sintaxe Break
break;
break etiqueta;
1. // break para sair de um laço

class LaçoBreak {
for (int i=0; 1<100;1++)
if(i==10)break;// termina o laço se i for 10
System. Oout.println(“1:”+i);
}
System.out.println(“i:”+i);
}
}
2. break como uma sentença goto (transferência incondicional)
Sintaxe break etiqueta;

// break atuando como goto
class Break{
boolean t=true;
primeiro:{
segundo:{
terceiro:{
System.out.println(“Antes de break”);
if(t)break segundo;
System.out.println(“não é executado”);
}
System.out.println (“não é executado”);
}
}
}
}
Laços aninhados
Java permite aninhar laços:
//Laços aninhados
classes Aninhadas {
public static void main (String args []) {

int i; j:
for (i = 0, i<10; 1++) {
for (j=i; j<10; j++)
System.out.print (“.”);
System.out.println ( );
}
}
}
F.11.4 Sentenças de transferência

Java suporta três sentenças de salto ou transferência: break, continue e return. Essas sentenças transferem
o controle para outras partes de seu programa.
break
Em Java, a sentença break tem três usos:
Primeiro, termina uma seqüência de sentenças em switch.

Segundo, pode ser utilizada para sair de um laço.
Terceiro, pode ser utilizada como uma forma algo mais disciplinada que “goto”.
continue
continue volta o controle ao princípio do laço.
Sintaxe
continue;
continue etiqueta;
// demonstração de continue
class Continue{
for(i=0,i<10;1++){
system.out.println(i+“ ”),
if(i%20 ==0)continue;
system.out.println(“ ”),
}
}
}
return
A sentença return é utilizada explicitamente para voltar de um método, já que, quando é executada, termina
imediatamente o método em que se insere.
Sintaxe
return;
return expressão;
1. //demonstração de return
class Return{

boolean t=true;
System.out.println(“antes de return”);
if(t)return;
System. Out.println(“não se executa”);
}
}
2. int dosPor (int n){

return n*2;
}
3. public class Return{

private static int main(final int a, final int b){
if (a<b)
return a;
else
return b;
}
...
}
F.12 CLASSES
Uma classe é uma coleção de membros dado e métodos que define um objeto específico. É a construção
fundamental da linguagem Java. Uma classe pode ser definida pelo usuário ou por um dos pacotes incorpo-
rados a Java e é declarada com a palavra reservada class. A convenção utilizada para nomear as classes
utiliza uma letra maiúscula para a primeira letra do nome da classe.
Sintaxe
class nomeClasse
{
declaração de variáveis estáticas
declaração de variáveis de instância
declaração de construtores
declaração de métodos
declaração de métodos estáticos

declaração de métodos
tipos nomeMétodo (lista de parâmetros){
corpo do método
}
Os dados ou variáveis, definidos dentro de uma classe, denominam-se variáveis de instância. O código
está contido dentro de métodos. De maneira coletiva, os métodos e as variáveis definidas dentro de uma classe
são denominados membros da classe. As variáveis definidas dentro de uma classe são chamadas variáveis de
instância, já que cada instância da classe (ou seja, cada objeto da classe) contém sua própria cópia dessas
variáveis. Cada classe define um novo tipo de dados.
Exemplo
class caixa{ // caixa é um novo tipo de dado
double largura;
double altura;
double profundidade;
}
class Caixa{
double largura, altura. Profundidade
public Caixa (double a, double h, double p){
largura = a;
altura =h;
profundidade =p;
}
public double obterVolume ( ){
return largura*altura*profundidade;
}
}
F.13 ESTRUTURA DE PROGRAMAS JAVA
Um programa Java consta de uma coleção de arquivos ou unidades de compilação. Cada arquivo pode conter
um nome opcional de pacote, uma série de declarações import e, por último, uma seqüência de declarações
de interfaces ou classes. Uma unidade de compilação pode identificar seus pacotes, importar qualquer número
de outros pacotes, classes ou interfaces e declarar qualquer número de classes e interfaces.
Declaração de importações
Uma declaração de importação (import) nomeia um elemento de outro pacote que será utilizado nas decla-
rações posteriores de interfaces ou classes. Pode ser utilizado um asterisco para incluir todos os elementos de
um pacote.
import nomePacote.*;
import nomePacote.NomeClasse;
import nomePacote.NomeInterface;
Assim import java.io*; indica ao compilador que importe qualquer classe do pacote java.io
proporcionado por Java à medida que necessite. Uma boa idéia é incluir essa linha no princípio de qualquer
arquivo .java que realize operações de entrada/saída. Outros exemplos:
import java.útil.Date;
import.java.net.*;
Definição de classes
Uma definição de uma classe consta de uma declaração e um corpo. O corpo contém campos de dados e
declarações de métodos. A declaração de uma classe consta de palavras reservadas e identificadores: uma
seqüência opcional (no modelo sintático, para indicar que é opcional, coloca-se entre [ ]) de modificadores,
a palavra reservada class, o nome da classe, um nome opcional da classe pai, uma seqüência opcional de
interfaces e o corpo da classe com seus membros.
[modificadoresDeClasse] class Nome [extends Pai]

[implements Interface1 [, Interface2
[, ...]]]
{
//corpo da classe (membros)
}
Os modificadoresDeClasse podem ser: abstract, final, public.

Uma classe abstrata é aquela que tem um ou mais métodos abstratos e da qual o programador não pensa
instanciar objetos. Seu fim é servir como superclasse da qual outras possam herdar. As classes que herdam de
uma classe abstrata devem implementar os métodos abstratos de sua superclasse ou seguirão sendo abstratas.
Uma classe final não pode ser superclasse e todos os seus métodos são implicitamente final. Uma classe
pública deve estar em seu próprio arquivo denominado Nome.java. Os membros de uma classe podem ser
métodos e variáveis de instância (pertencentes a um tipo base ou uma classe).
// Formato mais simples de uma definição de classe

class ClasseUm
{
// campos de dados e declarações de métodos
} // ClasseUm
// Uma classe que estende outra classe

public class ClasseDois extends OutraClasse
{
} // ClasseDois
// Classe complexa
public abstract class MeuObjeto extends OutraClasse implements InterfaceUm,
InterfaceDois
{
} // MeuObjeto
Exemplos
1. public class PrimeiroPrograma
{
public static void main(String[ ] args)
{
System.out.println(“Serra Magna-Carchelejo”);
}
}
2. public abstract class Número

{
...
}
Declaração de variáveis
Em Java, as variáveis podem ser declaradas: (1) como campos de dados de uma classe, (2) como argumentos
de um método ou (3) como variáveis locais dentro de um bloco.
Declarações de campos de dados e variáveis de métodos

Uma variável é declarada proporcionando seu tipo e seu identificador. O tipo pode ser um dos tipos primitivos
ou pode ser uma classe. As declarações das variáveis locais e dos campos de dados podem incluir a atribuição
de um valor inicial. Os argumentos obtêm seu valor inicial quando é ativado o método.
// Exemplos de declarações de variáveis de método ou campos de dados

int z; // identificador z é de tipo int
char inicialNome = ‘M’; // inicialNome é de tipo char
// e de valor inicial ‘M’
String saudação = “Olá Mackoy”; // saudação é do tipo String
// e de valor incial “Olá Mackoy”
boolean interruptor = false; // interruptor é do tipo boolean
// e valor inicial false
Uma declaração de variáveis de instância ou campos de dados tem uma parte de modificador opcional, um
tipo, um nome de variável e uma inicialização opcional.
[modificadoresDeVariável] tipo nome [= valor];
Os modificadoresDeVariável podem ser: public, protected, static, final.
Exemplos
1. public class Figura
{
protected Retângulo posição.
protected double dx, dy;
protected Cor cor;
//...
}
2. classe Empregado extends Pessoal

{
protected String nome = “ ” ;
protected int idade;
protected Empregado umEmpregado;
//...
}
Visibilidade de campos de dados

Os campos de dados são acessíveis de qualquer método dentro da classe. Dependendo da visibilidade declarada,
outros objetos podem acessar também os campos de dados. Aos campos de dados que não é proporcionado um
valor inicial explícito, é atribuído um valor por default.
Declaração de constantes de classe

As constantes de uma classe são declaradas como variáveis, sendo necessário começar sua declaração com as palavras
reservadas final e static, e se atribui a elas um valor na declaração. Esse valor não poderá ser modificado.
Exemplo
class Empregado extends Pessoa
{
public static final quantidade = 50;
//declaração de variáveis
//declaração de métodos
}
Conversão explícita de tipos

(nome_tipo) expressão
Criação de objetos
Uma instanciação (criação) de objetos cria uma instância de uma classe e declara uma variável desse tipo.
Os objetos são criados de uma classe utilizando o operador new. A sintaxe adequada é:
[tipo] nomeVariável = new tipo ([parâmetro1[, parâmetro2[, ...]]]);
Recolocada umaPeça = new Recolocada( );

Automóvel meuCarro = new Automóvel(5, “Golf”);
A criação de uma instância (um objeto)
• Cria-se um objeto com o nome nomeVariável.

• Aloca-se a ele memória dinamicamente.
• Inicializam-se suas variáveis de instância aos valores por default: null para os objetos, false para
variáveis booleanas, 0 para os outros tipos de base.
• Chama-se o construtor com os parâmetros especificados.
• Por último, devolve-se uma referência ao objeto criado, ou seja, o endereço da memória onde é encon-
trado este objeto.
Declaração de métodos
As declarações de métodos simples, denominadas também de assuntos, constam de um tipo de retorno, um
identificador e uma lista de argumentos (parâmetros). O tipo de retorno pode ser qualquer tipo válido (incluin-
do uma classe) ou o tipo void se nada for devolvido. A lista de argumentos consta de declarações de tipo (sem
valores iniciais) separadas por vírgulas. A lista de argumentos pode estar vazia. Os métodos podem também
ter uma visibilidade explícita.
[modificadoresDeMétodos] tipoDeResultado nomeMétodo

([tipoParâmetro1 parâmetro1
[,tipoParâmetro2 parâmetro2[,...]]])
[throws Exceção1[, Exceção2[,... ]]]
{
//corpo do método
}
Os modificadoresDeMétodos podem ser: public, protected, private, abstract, final, static,

synchronized. Como tipoDeResultado, será especificado void quando o método não devolver resulta-
dos. Na implementação do método, quando este não tenha sido declarado void, será utilizada a instrução
return para devolver um valor ao ponto de ativação do método; ou seja, quando for executado return, o
método termina devolvendo um único valor como resultado. Para devolver múltiplos valores mediante uma
função em Java, devem ser combinados todos eles em um objeto e devolver a referência ao objeto. A seguir
do nome do método e entre parênteses será especificada a lista de parâmetros, que constará de zero ou mais
parâmetros formais, cada um deles precedido por seu tipo e separado por vírgulas.
Quando ativamos um método, os parâmetros atuais são atribuídos aos parâmetros formais correspondentes.
Entre os parâmetros atuais, que foram ativados, e os formais, de declaração, deve existir concordância quanto a
número, tipo e ordem.
A palavra reservada throws permite listar tipos de exceções lançadas pelo método cujo tratamento é
retardado para que seja efetuado pelo método ativador.
Os métodos de uma classe estão associados a uma instância específica da classe, exceto se forem estáticos.
public class Exemplo1 {

// campo de dados declarados, nenhum
// Declaração simples: não é devolvido nada, não é passado nenhum argumento
private void calcularImpostos( ){
// corpo do método
}
// Um método com um argumento de tipo double que devolve um inteiro
public int calcularTotal (double x){
// corpo do método
}
/* Um método que devolve um objeto de tipo MeuObjeto com um inteiro e
uma cadeia de entrada */
protected MeuObjeto converter (int z, String s) {
// corpo do método
}
} // classe Exemplo1
Ativação de métodos
Quando ativamos um método, devemos proporcionar os argumentos do tipo adequado.
// interior de um método
{
calcularZ( );
int z = calcularZ(16,25);
MeuObjeto obj = converter(25, “Olá Mackoy” );
...
}
O método main
Cada aplicação Java (não as applets) deve ter um método main que é onde começa a execução da aplicação,
ou seja, para executar um programa, o interpretador de Java começa ativando o método main( ). Este método
é ativado antes da criação de um objeto e deve ser declarado como static para que se possa ativar sem ter
de se referir a uma instância particular da classe. Além de ser ativado pelo código fora de sua classe, também
tem de ser declarado como public, que é a forma de permitir que um membro de uma classe possa ser uti-
lizado pelo código que esteja fora dela. A palavra reservada void indica que main não devolve nada.
public static void main(String[ ] args)

{
}
String[ ]args é a declaração de um array de String, mediante o qual a classe poderia receber um

número variável de parâmetros na linha de ordens; ainda que não seja usado, é necessário incluir esse parâ-
metro quando é definido o método main( ).
Extensão de classes
[acesso] [final] class NomeClasse extends Superclasse
{
// corpo da classe ampliada
}
Construtor da subclasse
public NomeClasse(arg11, ...)
{
super(...);
...
}
Construtores
A sintaxe de um construtor é semelhante à de um método, sem tipoDeResultado e cujo nome deve coincidir
com o da classe. O construtor é invocado automaticamente quando criamos uma instância da classe.
[modificadoresDeConstrutor] nomeConstrutor
[,tipoParâmetro2 parâmetro2[, ...]]])
{
// corpo do construtor
}
Os modificadoresDeConstrutor seguem as mesmas regras que nos métodos normais, mas um cons-
trutor abstrato estático final não é permitido.
Um construtor deve ser invocado com o operador new.
Uma classe pode ter múltiplos métodos construtores, sempre que eles se diferenciem uns dos outros no
número e/ou tipo de parâmetros.
class Pessoa
{
protected String nome = “ ”;
protected int idade = 0;
public Pessoa(String nom, int anos)
{
nome = nom;
idade = anos;
}
public static void main(String args[ ])
{
Pessoa p = new Pessoa(“Luizinho Mackoy”, 13);
System.out.println(“Nome: “+ p.nome + “ ” + “Idade: “ ” + p.idade);
}
}
Os construtores na extensão de classes

O corpo de um construtor começa com uma ativação que o construtor herdou da superclasse da classe.
Esta ativação deve ser a primeira sentença do corpo de um construtor e não pode aparecer em nenhum
outro lugar. Em Java, super(...) é usado em vez do nome do construtor da superclasse. Se não for usa-
do super, então supomos implicitamente que o corpo do construtor começa com a ativação super( ) sem
parâmetros. O resto do corpo é como um método normal.
class Empregado extends Pessoa

{
protected String categoria = “ ”;
protected int salário = 0;

public Empregado(String nom, int anos, String nível, int salário)
{
super(nom, anos);
categoria = nível;
salário = pagamento,
}
public static void main(String args[ ])
{
Empregado = new Empregado(“Artur Mackoy”, 13, “médio”, 200000);
System.out.println(“Nome: “ + e.nome + “ ” + “Idade: ” + e.idade);
System.out.println(“Nível : + e.categoria + “ ”
+ “Salário : ” + e.salário);
}
}
Definição e implementação de interfaces
Definição de uma interface

public interface NomeInterface
{
public abstract tipoDeResultado nomeMétodo( );
//outras declarações de métodos vazios.
}
Devemos ter em conta que:

• Todos os membros de uma interface são públicos automaticamente.
• Todos os métodos são abstratos automaticamente.
• Todos os campos devem ser declarados static e final.
A classe que implementa a interface deve implementar todos os métodos declarados nela.
public class Implementa [extends Pai] implements NomeInterface
{
public tipoDeResultado nomeMétodo( )
{
//...
}
//se implementam todos os métodos da interface NomeInterface
}
É possível que uma classe implemente mais de uma interface:
[modificadoresDeClasse] class Nome [extends Pai]

[implements Interface1
[, Interface2 [, ...]]]
{
//Implementação de todos os métodos das diferentes interfaces
}
É possível definir classes que tenham objetos do tipo NomeInterface, como se a interface fosse uma
classe, podendo assim ser usada nelas as diversas implementações desta. A classe Exemplo pode usar, entre
outras que forem definidas, a que oferece a classe Implementa.
public class Exemplo
{
public Exemplo( )
{
//...
}
public tipoDeResultado umMétodo(NomeInterface elemento)
{
//...
}
}
Classes anônimas
Uma classe anônima é aquela que não tem nome, e quando se cria um objeto dessa mesma classe, no lugar
do nome colocamos diretamente a definição.
new SuperNome( ) { corpo classe }
Por exemplo, considerando declarada uma classe Implementa que implementa NomeInterface, a seguinte
instrução
e.umMétodo(new Implementa( ));
passa a e.umMétodo uma nova instância desta classe Implementa como parâmetro. Ao se empregar uma
classe anônima, não seria efetuada a declaração de Implementa e a instrução anterior seria substituída por
e.umMétodo(new NomeInterface( )
{
public tipoDeResultado nomeMétodo( )
{
//...
}
// são implementados todos os métodos da interface
NomeInterface
}
);
F.13.1 Privilégios de acesso

O uso das palavras reservadas public, private e protected com uma declaração permite ao programador
controlar explicitamente o acesso a uma variável, a um método, classe aninhada ou interface aninhada de fora
do escopo de uma classe.
Modificações de acesso
As modificações de acesso são colocadas diante da declaração das classes:
public, protected, private
O uso de um modificador de acesso é opcional e pode ser omitido.
public uma declaração é acessível por qualquer classe.

protected uma declaração é acessível a qualquer subclasse da declaração da classe ou a qualquer
classe do mesmo pacote.
private uma declaração somente é acessível de dentro da classe onde está declarada.
F.13.2 Criação de um objeto

Um objeto de uma classe é criado mediante a sentença new:
Exemplo
Criar um objeto minhacaixa
1. Caixa minhacaixa= new caixa(1;

2. Caixa minhacaixa;minhacaixa= new caixa( );
3. Caixa c,
c=new Caixa (2.0,3.0,4.5);
4. Alternativamente
Caixa c=new caixa (2.0,3.0,4.5);
F.13.3 Métodos
Um método proporciona a implementação do comportamento dinâmico dos objetos e pode mudar o estado
dos objetos que são ativados.
Sintaxe
Modificações tipo nomeMétodo (lista de parâmetros){
Seqüência de sentença
}
Os métodos que têm um tipo de retorno diferente de void devolvem um valor utilizando a sentença
return:
return valor;
Valor é o valor devolvido
Exemplo
class Caixa{
double largura;
double altura;
// cálculo e devolve o volume
double volume ( ) {
return largura *altura *profundidade;
}
}
Sintaxe
NomeConstrutor (lista parâmetros){
Corpo do construtor
Exemplo
1. class Caixa {
double largura;
double altura;
double profundidade;
// construtor
caixa ( ){
system.out.println (“ construção da caixa”);

largura = 10;
altura = 20;
profundidade = 5;
//cálculo e devolve ao volume
double volume ( ) {
return largura *altura *profundidade;
}
}
Construtores com parâmetros

Ainda que o sistema anterior seja prático, todas as caixas têm as mesmas dimensões. Necessita-se um meio para
construir objetos caixa de dimensões diferentes. O método mais fácil é acrescentar parâmetros ao construtor.
Métodos com parâmetros
1. int quadrado ( ) 2. int quadrado (int 1)

{ {
return 12*12; return 1*1;
} }
3. void fixarDim(double a,double h,double p){

largura = a,
altura = h;
profundidade = p;
}
F.13.4 Construtores
Todos os objetos devem ser inicializados quando são criados, de modo que “nasçam” com um estado bem
definido. Um construtor é um tipo especial de método que inicializa um objeto imediatamente para sua cria-
ção. Tem o mesmo nome da classe e sintaticamente é semelhante a um método. Os construtores não devolvem
nenhum tipo e são ativados automaticamente quando é criado um objeto da classe.
O construtor pode ser sobrecarregado para dar múltiplos construtores com diferentes tipos de argumento
parado. Os construtores são definidos geralmente como public.
Os valores separam o construtor situando-os dentro dos parênteses das sentenças de criação de objetos
da classe.
F.13.5 A palavra reservada this

A palavra reservada this representa uma referência que passa implicitamente a cada método não-estático.
A referência é o objeto invocador.
1. Caixa (double a,double h,double p){

this.largura=a;
this.altura=h;
this.profundidade=p;
}
2. class ponto
int x,y;
Ponto (int x,int y){
this.x=x;
this.y=y;
}
int ler x( ){

return x;
}
int ler y( ){

return y;
}
}
F.13.6 O método finalize( )

Às vezes um objeto necessita realizar alguma ação quando é destruído. Para manusear tais situações, Java
proporciona um mecanismo chamado finalização. Para acrescentar um finalizador a uma classe, definimos
simplesmente o método finalize( ).
Sintaxe
protect void finalize( )
}
//código de finalização
}
F.14 SOBRECARGA DE MÉTODOS
Em Java é possível definir dois ou mais métodos na mesma classe, que compartilhem o mesmo nome, enquanto
as declarações de seus parâmetros é diferente. Nesse caso, dizemos que os métodos estão sobrecarregados e o
processo é conhecido como sobrecarga de métodos. A sobrecarga de métodos é uma das formas em que Java
implementa o polimorfismo.
Um método de uma subclasse que tem o mesmo nome mas diferentes argumentos de um método de uma
superclasse é considerado uma função sobrecarregada. O compilador decide qual é o método mais adequado
baseando-se na lista de argumentos e no tipo do objeto que tem a ativação.
Exemplo
//sobrecarga de método
class Demosobrecarga {
void teste ( ){
System.out.println(“nenhum parâmetro”)
}
//sobrecarga de teste com parâmetro inteiro

void teste (int a){
System.out.println(“a:”+a);
}
//sobrecarga com dois parâmetros inteiros

void teste (int a,int b)
{
System.out.println(“a e b”+a+“ ”+b);
}
class Sobrecarga {
DemoSobrecarga ob=new DemoSobrecarga ( );
int resultado;
//ativação métodos sobrecarregados

ob.teste( );
ob.teste(15);
ob.teste(5,25);
}
}
Exemplo2
public class Teste1{
public static void main(string args[ ]{
Subclasse s=new Subclasse( );
System.out.println(“a mensagem é” + s.lerMensagem( ));
}
}
classe Superclasse{
public String lerMensagem( ){
return “Supermensagem”;
}
}
class Subclasse extends Superclasse{

public String lerMensagem( ){
return “Supermensagem”;
}
}
Saída
A mensagem é submensagem
Tipos especiais de classes

Existem três tipos especiais de classes: abstratas (abstract), finais (final), internas (inner).
F.14.1 Classes abstratas

As classes abstratas são utilizadas para definir a estrutura geral de uma família de classes derivadas. São utili-
zadas como as interfaces, para impor uma funcionalidade comum a um número de classes diferentes que são
conhecidas como classes concretas. Uma classe concreta é uma classe que não é abstrata. Não podemos criar
objetos de uma classe abstrata, podemos criar somente de uma classe concreta.
As classes abstratas não podem instanciar-se, mas fazem referências de um tipo abstrato que pode ser
utilizado para apontar uma instância de um objeto de uma subclasse concreta.
As classes abstratas podem definir métodos abstratos e concretos. Qualquer subclasse concreta de uma
classe abstrata deve implementar os métodos abstratos da classe abstrata. As classes abstratas são designadas
utilizando as palavras-chave abstract à frente da palavra-chave class na sentença de declaração da classe.
Os métodos abstratos são declarados com o formato seguinte:
abstract tipo nome (lista de parâmetros)
Exemplo
A classe abstrata Figura define o método calcularárea( ). Duas subclasses de Figura, Retângulo e
Triângulo proporcionam duas implementações diferentes de calcularárea( ).
abstract class Figura{

double dimi dmj;
figura(double a,double b){
dimi=a;
dimi=b;
}
abstract double calcularÁrea( ); // método abstrato
}
class Retângulo extends Figura{
Retângulo (double a; double b) {
Super (a,b);
}
double calcularÁrea( ){
return dimi*dmj;
}
}
class Triângulo extends Figura{

Triângulo (double a, double b){
Super(a,b);
{
double calcularÁrea( ){
return 0.5*dimi*dmj;
{
{
F.14.2 Classes internas

As classes internas permitem que uma classe esteja contida em outra classe. Existem quatro tipos de classes
internas:
• Classes membro estáticas.

• Classes membro.
• Classes locais.
• Classes anônimas.
// Mostra de uma classe interna

class Externa {
int externa_x=50;
void teste( ){
Interna interna =new Interna( );
Interna. apresentam ( );
}
//classe interna.
classe Interna{
void apresentam( ){
System.out.println(“apresentam:externa_x=”+externa_x);
}
}
}
class DemoClasseInterna {
public Static void main(String args[ ]){
Externa externa = new Externa( ):
Externa.teste( );
}
}
F.14.3 Classes finais

Uma classe final é aquela que não pode ser herdada. Conseguimos essa ação precedendo a declaração da
classe com final. Não é legal declarar uma classe como abstrata (abstrat) e final (final).
Exemplo
final class A{
//...
}
// A seguinte classe não é legal
classe B extends A { //erro, não é possível subclasse A
//...
}
// A se declara final e portanto B não pode herdar de A
F.15 HERANÇA
A herança permite criar uma classe conhecida como subclase ou classe filha de outra classe conhecida como
superclasse ou classe pai. Conseqüentemente, uma subclasse é uma versão especializada (uma extensão)
de uma superclasse. Herdam-se todas as variáveis de instância e os métodos definidos na superclasse e
acrescentam-se elementos próprios.
Sintaxe
class nomesubclasse extends nomeSuperClasse {
Declarações de variáveis e métodos
Somente pode ser especificada uma superclasse para qualquer subclasse que é criada. Esse tipo de heran-
ça é denominado herança simples. Java não suporta a herança de múltiplas superclasses, ou seja, não suporta
herança múltipla. Pode existir somente uma superclasse depois da palavra chave extends.
Regra
Um objeto da subclasse tem acesso aos métodos públicos e membros dado e protegidos e definidos
na superclasse; não podem ser acessados os membros da superclasse que tenham sido declarados
privados.
class A{
int i;
private int j; //j, é privado, só se acessa em A
void lerij(int x, int j){
i=x;
j=y;
}
}
class B extends A {
int total,
void soman ( ){
total =i+j; // erro,j não é acessível aqui.
}
}
F.16 PACOTES
Um pacote é um continente de classe que é utilizado para dividir ou compartimentar o espaço do nome da
classe. Os pacotes são armazenados de forma hierárquica e são importados explicitamente em novas definições
de classe.
F.16.1 Definir um pacote

Criar um pacote é muito fácil; basta incluir uma ordem package como primeira sentença no arquivo fonte de
Java. Qualquer classe declarada dentro de um arquivo pertence ao pacote especificado. A sentença package
define um espaço de nomes no qual são armazenadas as classes. Se omitirmos a sentença package, os nomes
da classe são postos no pacote por default que não tem nome.
Sintaxe
package nomepacote;
package MeuPacote ;// cria um pacote Meupacote
Pode ser criada uma hierarquia de pacotes.

Sintaxe
package pac1[.pac2][.pac3];
package java.awt.image;
Java utiliza os diretórios dos sistemas de arquivo para armazenar pacotes, por exemplo, os arquivos
Class que são criados como parte de um pacote devem ser armazenados em um diretório que tenha o nome
do pacote.
Exemplo
Os arquivos .class das classes do pacote demo.upsa devem ser armazenados em um diretório denominado
upsa dentro de um diretório denominado demo.
F.16.2 Acesso a pacotes (importação)

Os pacotes e a classe das bibliotecas são acessados utilizando-se a palavra reservada import.
Sintaxe
import nomePacote.nome. Classe;
import nomePacote.*;
Exemplo
import java.útil.Dado; //acesso à classeDado do
//pacote java.útil
import jav.io.*; //importa-se tudo para o pacote.
Todas as classes-padrão Java incluídas no compilador são armazenadas em um pacote denominado Java.
As funções básicas da linguagem são armazenadas em um pacote dentro do pacote Java chamado java.lang.
import java.lang.*;
F.17 INTERFACES
As interfaces são utilizadas para impor certa funcionalidade nas classes que as implementam, ou seja, são
utilizadas para abstrair a interface de uma classe de sua implementação. Utilizando interface, podemos
especificar o que faz uma classe mas não como ela faz. As interfaces são muito semelhantes sintaticamente
às classes, mas não têm implementação de métodos.
Sintaxe
TipoAZero interface nome {
Tipo_retorno nomeMétodo 1 (lista de parâmetros);
Tipo_retorno nomeMétodo 2 (lista de parâmetros);
// outros métodos.
Tipo nomeVar 1= valor;
Tipo nomeVar 2= valor;
// outras variáveis
}
Exemplo
1. interface reativada {
void reativada (int param);
}
2. interface Área {
double lerÁrea( );
}
F.17.1 Implementação de interfaces

Uma vez definida uma interface (interface), podemos implementar uma ou mais classes de uma interface.
Para implementar uma interface, incluímos uma cláusula implements na definição da classe e a seguir são
criados métodos definidos pela interface.
Sintaxe
Acesso class nomeclasse [extends superclasse]
[implements interface [, interface...]]}
// corpo da classe
}
Exemplo
// A classe Cliente implementa a interface reativada
class Cliente implements Reativada
// implemento a interface de reativada
public void reativada (int p) {
System.out.println(“a reativada com ”+p);
}
}
F.18 EXCEÇÕES
Sentença try-catch
A captura de exceções é realizada mediante blocos try-catch. A(s) sentença(s) de um bloco será(ão)
colocada(s) sempre entre chaves:
try
blocoATentar // ainda que seja uma única sentença ela irá entre { }
catch (tipoExceção1 identificador1)
blocoSentenças1
[catch (tipoExceção2 identificador2)
blocoSentenças2]
...
[finally
blocoSentençasN]
ou
try
blocoATentar
finally
blocoSentençasN
já que o bloco try não pode aparecer sozinho.

Exemplo
import java.io.*;
public class ReturnTryEj
{
public static int ler( )
{
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader br = new BufferedReader(isr);
String cadeia = “ ”;
try
{
cadeia = br.readLine( );
return Integer.parseInt(cadeia);
}
catch (Exception e)
{
if (e instanceof IOException)
System.out.println(“Erro de entrada/saída”);
else if (e instanceof NumberFormatException)
System.out.println(“Não teclou um número inteiro”);
}
// Instrução seguinte a catch
System.out.println(“Devolve-se 0”);
return 0;
}
public static void main (String args[ ])

{
int n;
do
{
System.out.print(“Dê-me um número inteiro entre 1 e 20 ”);

n = ler( );
}
while ((n <= 0) || (n > 20));
System.out.println(“2^” + n + “ = ” + Math.pow(2,n));
}
}
Sentença throw
Uma sentença throw lança uma exceção, que pode ser uma exceção recebida ou uma nova exceção. Uma cláusula
catch pode receber uma exceção e, em lugar de tratá-la ou depois de fazê-lo, voltar a lançá-la mediante uma
instrução throw.
try
blocoATentar
catch(NumberFormatException identificador)
{
//...
throw (identificador);
}
Para lançar uma nova exceção, criamos um objeto de uma subclasse de Exception que implemente um
construtor e seja lançado com throw quando ocorra o fato que deve provocar a exceção.
if (expressãoLógica)
throw new ConstrutorSubclasseException([parâmetro1[, parâmetro2
[,...]]]);
Exemplo
if (idade < 18 || idade > 65)
throw new ForaDoIntervalo(“Exceção: valor fora do intervalo”);
class ForaDoIntervalo extends Exception
{
String mensagem;
public ForaDoIntervalo (String causa)
{
mensagem = causa;
}
public String getMessage( )
{
return mensagem;
}
}
Sentença throws
Lista as exceções não tratadas e que pertencem a classes diferentes de RuntimeException. Assim, seu
tratamento será adiado e deverá ser efetuado pelo método ativador, ou terão de voltar a ser listadas no
cabeçalho deste com outra cláusula throws:
[modificadoresDeMétodos] tipoDeResultado nomeMétodo

[,tipoParâmetro2 parâmetro2 [,...]]])
[throws Exceção1[, Exceção2 [,...]]]
{
// corpo do método que não trata a exceção
}
Sentença package
Cada classe pública definida em Java deve ser armazenada em um arquivo separado; se existem várias
relacionadas, todas elas são armazenadas no mesmo subdiretório. Um conjunto de classes relacionadas
definidas em um subdiretório comum pode constituir um pacote Java. Os arquivos do pacote devem
começar com a seguinte sentença:
package nomePacote;
onde o nome do pacote reflete o subdiretório que contém essas classes. Utilizamos o caractere ponto (.) como
separador entre nomes de diretórios quando for necessário especificar vários para referenciar o que contém as
classes.
Exemplo
package livro.Tema03;
Podemos utilizar uma classe definida em outro pacote especificando, para se referir a ela, a estrutura de
diretórios do outro pacote seguida pelo nome da classe que desejamos usar e empregando o caractere ponto
como separador. Referenciar classes dessa forma pode ser desagradável e a solução consiste em utilizar
import, que permite incluir classes externas ou pacotes inteiros no arquivo atual.
F.19 Miscelânea
Referência a membros de uma classe

nomeObjeto.nomeComponente
Se for static não é necessário se referir a uma instância em particular da classe e pode referenciar-se
como
nomeClasse.nomeComponente
Os membros de uma classe estão associados a uma instância específica dela, exceto se são estáticos.
Conversão explícita de tipos

Existem dois tipos fundamentais de conversões de tipos que podem ser realizados em Java, com respeito a
tipos numéricos e com respeito a objetos. O formato a ser aplicado para efetuar uma conversão explícita de
tipo é:
(tipoNome) expressão;
Exemplo
double resultado = (double) (4/8); //atribui 0.0 ao resultado
double resultado = (double)4/(double)8; //atribui 0.5 ao resultado
double resultado= (double)4/8; //atribui 0.5 ao resultado
double resultado= 4/8; //conversão implícita,
//atribui 0.0 ao resultado
Aluno umAluno = (Aluno)umaPessoa;
Uma exceção é uma condição anormal que é produzida em uma sentença de código em tempo de execução.
Em outras palavras, uma exceção é um erro em tempo de execução. Uma exceção Java é um objeto que
descreve uma condição excepcional (este é erro) que ocorreu em um segmento de código. Quando surge uma
condição excepcional, cria-se um objeto que representa uma exceção e é lançado (throw) no método que
produz o erro.
O uso de exceções é administrado mediante cinco palavras reservadas: try, catch, throw, throws e
finally.
Sintaxe de bloco de uso de exceções

try {
// bloco de código para monitorar erros
}
catch (tipo Exceção 1 exob){

// uso de exceções para tipoExceção 1
}
catch (tipo Exceção 2 exob){

// uso de exceções para tipoExceção 2
}
//...
finally {
// bloco de código que se executa antes de terminar o bloco try
}
tipoExceção tipo de exceção que ocorreu
Sintaxe bloco try-catch

try {
código
} catch (exceção e){
código ;
{
Sintaxe finally
finally{
código;
{
Sintaxe throw
throw objetolançável;
Sintaxe throws
...
nomeMétodo throws Exceção 1, Exceção2...
Exemplo
public class TesteExceção {
public static void main (String [ ]a)
int [ ] a =
0,1,2,3,4,5
};
try {
for (int i=0; i < 6; ++i){
System.out.println(“a[“+i+”]é”+a[i]);
}
} catch (exceção e){
System.out.println (“Exceção :”+e);
}
System.out.println(“código que pode ser executado”);
}
}

Apàndice F

Diunggah oleh

Informasi Dokumen

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

Apàndice F

Diunggah oleh

Hak Cipta:

Format Tersedia

APÊNDICE F

F.1 O que é um programa Java? F.11 Sentenças

F.1 O QUE É UM PROGRAMA JAVA?

Tabela F.1 Ferramentas de JDK

Javac Compilador Java.

1. // Comentários de uma linha só

1. Os comentários de uma linha só começam com // e continuam até o final da linha.

F.3 PALAVRAS RESERVADAS

abstract throw if new import

Salário_mensal posição_Relativa elemento_Tabela

F.5 TIPOS DE DADOS

Tabela F.2 Tipos de dados

Tipo de dado Se utiliza para armazenar Requisitos de armazenamento

boolean Este tipo de dado pode receber dois valores

0,124, -525, 55661, 2354657, -321124

DXD DX12F OXFFED DXFFFF 0X12DEFF

00, 0123, 0777, –045321, –05

Literais de ponto flutuante

1.2345 1234.5678 0.1 305 –24.123

Se o número da ponto flutuante termina com um sufixo f ou F será de tipo Float.

1.23f 3.456F of .5Ff –45673F

O sufixo d ou D pode ser utilizado para representar tipos double.

‘a’, ‘A’, ‘i’, ‘4’

Tabela F.3 Seqüência de escape

Seqüência de escape Descrição

\ddd Caractere octal (ddd)

F.6.1 Declaração de variáveis

Uma variável deve ser declarada antes de poder ser utilizada.

Sintaxe nometipo identificador

É possível declarar duas ou mais variáveis por vez.

Nometipo id1, id2...;

Existem duas categorias de variáveis:

F.6.2 Modificação de variáveis

public A classe ou variável de instância é acessível de todos os escopos.

F.6.3 Inicialização de variáveis

A inicialização é realizada em três formatos:

F.6.4 Variáveis parâmetro

F.6.5 Variáveis locais

F.6.6 Variáveis finais

static final int MAX_CONTA=100,

F.6.7 Conversão de tipos

• As variáveis primitivas nunca podem ser moldadas a um objeto classe.

• Para converter um inteiro em uma cadeia, acrescentar um literal de cadeia vazia.

Tabela F.4 Caracteres especiais

F.7.1 Arrays de uma dimensão

1. int [ ] dados =new int [15]; int dados [ ];

F.7.2 Arrays multidimensionais

Tipovariável [ ] nomearray=[val1,val2...valn];

Tipovariável[ ] nomearray=new tipovariável[ ]{val1,val2...vanln}

Essa sentença atribui um array de inteiros, 4 por 5, e o atribui a dosD

Sintaxe alternativa da declaração de arrays

As seguintes declarações são equivalentes:

int a1[ ]=new int[3];

As duas seguintes declarações são também equivalentes:

char mod1[ ][ ]=new char[3][4],

Acesso e atribuição de valores a elementos de um array

E para atribuir o valor ao membro do array, é especificado ao índice. Por exemplo:

F.7.3 Arrays de duas dimensões

Inicialização de um array de duas dimensões

public class tesArray2D

F.7.4 A variável lenght

As palavras reservadas this, super e null.

Expressão com parênteses

Expressão de índices de arrays