Tipos de Dados, Selecção, Classes e Métodos em Java

Tipos de Dados, Selecção Repetição, Classes, Construtores e Métodos

UNIVERSIDADE SÃO TOMÁS DE MOÇAMBIQUE
FACULDADE DE CIÊNCIA E TECNOLOGIAS DE INFORMAÇÃO
DEPARTAMENTO DE TECNOLOGIAS E SISTEMAS DE INFORMAÇÃO

Disciplina: Programação I

1 História da Linguagem Java........................................................................................ 3
2 Componentes da Plataforma Java ............................................................................... 3
3 Compilar um Programa em Java ................................................................................. 4
4 Primeiro Programa em Java ou Classe Simples .......................................................... 5
5 Compilação e execução de um programa java ............................................................ 7
6 Estrutura de um Programa .......................................................................................... 7
6.1 Variáveis............................................................................................................... 8
6.2 Constantes ............................................................................................................ 9
6.3 Tipos de Dados Primitivos ................................................................................... 9
6.3.1 Números inteiros ........................................................................................... 9
6.3.2 Números reais ............................................................................................... 9
6.3.3 Caracteres .................................................................................................... 10
6.3.4 Boolean ....................................................................................................... 10
7 O Tipo (A Classe) String ...................................................................................... 10
8 Convenção para os Identificadores ........................................................................... 12
9 Instrução de atribuição .............................................................................................. 13
10 Expressões................................................................................................................. 13
10.1 Expressões aritméticas .................................................................................... 13
10.1.1 A Classe Math ............................................................................................. 15
10.1.2 Conversões de tipos (Casting) .................................................................... 16
10.2 Expressões Lógicas......................................................................................... 17
11 Entrada (Input) e Saída (Output) de Dados da Consola e Excepções ................ 18
11.1 Saída de Dados ............................................................................................... 18
11.2 Entrada de Dados e Excepções ....................................................................... 20
11.3 I/O com JOptionPane...................................................................................... 23
12 Instruções de Selecção .............................................................................................. 23
13 Instruções de Repetição ............................................................................................ 24
14 ARRAYS.................................................................................................................... 26
14.1 Arrays .................................................................................................................. 26
14.1.1 Declarando um Array: .................................................................................. 26
14.1.2 Criando Objetos Arrays:............................................................................... 26
14.1.3 Acessando os Elementos do Array ............................................................... 26
14.1.4 Arrays Multidimensionais ............................................................................. 27

Página 1 de 44


15 Métodos..................................................................................................................... 28
15.1 Criação de um método .................................................................................... 28
15.2 Parâmetros ...................................................................................................... 29
15.2.1 Parâmetros formais e reais .......................................................................... 29
15.2.2 Passagem de parâmetros ............................................................................. 30
15.3 Valor de retorno .............................................................................................. 30
15.4 Organização de um programa ......................................................................... 31
15.4.1 Visibilidade ou escopo das variáveis .......................................................... 31
15.4.2 Variáveis locais ........................................................................................... 32
15.4.3 Variáveis globais ......................................................................................... 34
16 Classes e objectos ..................................................................................................... 36
16.1 Criação de uma Classe .................................................................................... 37
16.1.1 Atributos ..................................................................................................... 37
16.1.2 Construtores ................................................................................................ 38
16.1.3 Métodos....................................................................................................... 38
16.2 Criação de objectos ......................................................................................... 38
16.3 Cópia de objectos............................................................................................ 43
16.4 Padronização de nomes de métodos (Java beans) .......................................... 44
17 Ficheiros .................................................................................................................... 44

Página 2 de 44


1 História da Linguagem Java

A linguagem Java foi criada, em 1995, nos laboratórios de investigação da empresa
americana Sun Microsystems, por uma equipa liderada por James Gosling, com a
intenção de ser usado para controlar pequenas máquinas electrónicas – por exemplo o
software que corre na maior parte dos celulares foi feito em Java. Tem uma herança nas
linguagens C++ e Smalltalk, a qual pode ser vista nas características da sintaxe.

Nessa altura a Web já tinha um crescimento substancial, que era acompanhado pelo
desenvolvimento de browsers cada vez mais poderosos. Uma das limitações então
existentes era o carácter estático das páginas. Só era possível obter alguma dinâmica
através de programas que residiam e eram executados nos servidores e, por isso, tinham o
seu desempenho muito limitado pela velocidade de transmissão e capacidade de
processamento disponível no servidor. A solução era transmitir os programas e executá-
los localmente na máquina cliente. Esta era uma ideia interessante, mas com muitos
problemas, devido essencialmente à diversidade de arquitecturas e sistemas operativos
dos computadores ligados à Web e a problemas de salvaguarda da segurança desses
computadores.

O Java era uma resposta satisfatória em relação a estes problemas, uma vez que
proporcionava independência quanto à máquina onde o programa era executado,
integrava alguns mecanismos de segurança e era fácil de integrar nos browsers existentes.
Por isso, actualmente, todos browsers executam código Java.

Assim, devido ao facto de ter sido criado para fácil utilização e aprendizagem, utilização
em todos tipos da hardware e por causa do marketing da Sun, num espaço não muito
longo tornou-se a plataforma de programação mais usada no mundo, podendo ser usada
em todos os tipos de aplicações.

2 Componentes da Plataforma Java

Página 3 de 44


A plataforma Java é um conjunto de tecnologias que, juntos, fornecem um ambiente
completo para programação de computadores digitais. Essas tecnologias são, a seguir,
explanadas:
JVM (Java Virtual Machine – Máquina Virtual Java): executa o código por cima
de qualquer hardware;
Ficheiros .java e .class: o „java‟ file contém o código fonte que um ser humano
pode entender e o „class‟ file contém o binary „bytecode‟ que um JVM pode
entender e
Pacotes básicos: fornecem muitas ferramentas a desenvolvedores para
implementar tarefas comuns que noutras línguas precisam ser criadas a mão.

3 Compilar um Programa em Java

O esquema abaixo descreve o processo de criação, compilação e execução de um
programa em Java.

.java
Write in editor
source file

Desenvolvidor

Use / test Compile with compiler

.class
RUNNING
Run in JVM bytecode
PROGRAM
file

Página 4 de 44


4 Primeiro Programa em Java ou Classe Simples

A seguir, se apresenta, o primeiro programa em java ou a primeira classe e é explanada
cada uma das instruções do programa.

// Primeiro programa Java
public class PrimeiroPrograma
{
public static void main(String[] args)
{
System.out.println("WelCome to USTM, ladies and gentlemen.");
}
}

Esclarecimento de cada uma das linhas de código:

// Primeiro programa Java

// Inicia uma linha de comentário, todo o restante da linha é ignorado. Existe também
um outro tipo de comentário formado por /* Coloca-se aqui o texto a ser
ignorado */. Este tipo de comentário pode ser intercalado em uma linha de código.
Comentários são tratados como espaços me branco.

public class PrimeiroPrograma
{

class é a palavra reservada que marca o início da declaração de uma classe.

public é um qualificador que indica a visibilidade da classe em relação a outros pacotes.

PrimeiroPrograma é o nome da classe. O “abre – chavetas” indica o início das
declarações da classe.

Página 5 de 44


{
}
}

public é um qualificador que indica que este é acessível externamente a esta classe.

static é um outro qualificador que indica o método deve ser compartilhado por todos os
objectos criados a partir desta classe. Os métodos static podem ser invocados mesmo
quando não foi criado nenhum objecto para a classe, para tal deve-se seguir a sintaxe:
<NomeClasse>.<NomeMetodoStatic>(argumentos).

void é o valor de retorno da função, quando a mesma não retorna nenhum valor ela
retorna void, uma espécie de valor vazio que tem que ser especificado.

main é um nome particular de método que indica para o compilador o início do
programa, é dentro deste método e através das iterações entre os atributos, variáveis e
argumentos visíveis nele que o programa se desenvolve.

(String[] args) é o argumento de main e por consequência do programa todo, ele é
um vector de String´s que é formado quando são passado ou não os argumentos através
da invocação do nome do programa na linha de comando do sistema operativo, por
exemplo: java PrimeiroPrograma arg1 arg2.

{ ... } “Abre – chavetas” e “fecha – chavetas” podem ser entendidos como algo
semelhante ao begin end de Pascal.


Página 6 de 44


Chamada do método println para o atributo out da classe ou objecto System, o
argumento é uma constante do tipo String. println, assim como writeln de Pascal,
imprime o String e posiciona o cursor na linha abaixo, analogamente print não avança
linha.

5 Instação e Compilação um programa java

5.1 Instalação e configuração do compilador java

……………………

5.2 Compilação e execução de um programa em java

Para compilar uma classe java usa-se o comando javac e para executar o programa usa-se
o comando java.

Exemplo:
javac PrimeiroPrograma.java (compilação)
java PrimeiroPrograma (execução)

Note que ao compilar o programa, indicamos o nome do ficheiro com extensão java.
Após a compilação, o compilador cria um ficheiro com nome igual ao nome da classe e
com extensão class, neste caso concrecto PrimeiroPrograma.class.

Atenção: o nome do ficheiro .class não deve ser obrigatoriamente igual ao nome do
ficheiro .java, o nome do ficheiro .class deve ser igual ao nome que vem depois da
declaração class no corpo do ficheiro .java (public class PrimeiroPrograma)

Ao compilar um ficheiro, o compilador corre o ficheiro indicado, e para cada erro
detectado, informa a posição e o erro detectado. Caso a classe não tenha nenhum erro, ele
cria o ficheiro com o nome da classe e extensão class.

6 Estrutura de um Programa

Um programa em Java, como se pode ver no tópico anterior, é um conjunto de uma ou
mais classes, uma das quais será a classe principal do programa. Esta classe deve ter um

Página 7 de 44


método chamado main(), o método principal do programa, que segue uma

declaração específica, a saber: "static void main(String[] args)”.
Uma classe pode ser vista como um conjunto de atributos e métodos, sendo que o
primeiro caracteriza a classe e o segundo determina o comportamento da mesma. Por
exemplo, a classe Pessoa pode ter como atributos altura, cor de cabelo, etnia e
como métodos andar, comer, casar, etc.

O objectivo da linguagem é procurar representar os objectos da natureza e o seu
comportamento, através de métodos, daí a designação da linguagem Java com sendo
orientado a objectos.

6.1 Variáveis

Uma variável representa uma localização em memória na qual podemos guardar um valor
de um dado tipo. A cada variável está associado um tipo e um nome. O conhecimento do
tipo é necessário para determinar o espaço de memória que deve ser reservado para
armazenar o valor correspondente, bem como a forma de representação utilizada. O nome
da variável identifica-a, permitindo ao programador a sua manipulação, sem que
necessite de saber a localização de memória onde a mesma se encontra.

A sintaxe de declaração de variáveis é a seguinte:
tipoDeDado = nomeDaVariavel1, nomeDaVariavel2, ..., nomeDaVariavelN; ou
tipoDeDado = valorInicial;

Exemplos:
int conta;
int max = 1;
int conta, soma;

A declaração é terminada por ponto e vírgula (;). Este é o símbolo que se usa em Java,
assim como em Pascal, para indicar o final de qualquer declaração ou instrução.

Página 8 de 44


6.2 Constantes
Há valores que ao longo do programa não alteram, os quais recebem a denominação de
constantes. E em Java, a sintaxe é a seguinte:

final NOME_DA_CONSTANTE = valorInicial;

Exemplo:
final double PI = 3.14;

6.3 Tipos de Dados Primitivos

6.3.1 Números inteiros

Tipo Memória Menor valor Maior valor
ocupada
byte 8 bits -128 127
short 16 bits -32768 32767
int 32 bits -2 147 483 648 2 147 483 647
long 64 bits -9 223 372 036 854 775 808 -9 223 372 036 854 775 807

6.3.2 Números reais

Os números reais podem ser representados por float ou double, sendo que este último
apresenta melhor precisão. Os valores reais podem ser representados usando a notação
decimal ou a exponencial. No primeiro caso, utiliza-se a parte inteira da parte
fraccionária do número. Por exemplo, 37.0 ou 0.234 estão na notação decimal. No
segundo caso, é usada a letra E para indicar o expoente na base 10. Por exemplo, 2.5E6
representa o número 2,5 x 106. Em qualquer dos casos, o número pode ser seguido das
letras f ou d indicando que se pretende o seu armazenamento como float ou como

Página 9 de 44


double (as letras F e D também podem ser usadas com o mesmo objectivo). A ausência
de indicação (f ou d) implica que o número seja considerado como double.

Exemplo:
double doub=1000000000f; // valor armazenado como float
double doub=1000000000d; // valor armazenado como double
double doub=1000000000; // valor armazenado como double
float flou=2432423; // valor sempre armazenado como float

Tipo Memória Menor valor Maior valor
ocupada
float 32 btis -3.4 x 1038 3.4 x 1038
double 64 bits -1.7 x 10308 -1.7 x 10308

6.3.3 Caracteres
Tipo Memória Valores
ocupada
char 16 bits Qualquer carácter pertencente ao unicode

6.3.4 Boolean
Tipo Memória Valores
ocupada
Boolean 1 bit True ou false

7 O Tipo (A Classe) String
O tipo String é um tipo de dados que não é primitivo. Ele difere dos tipos anteriores pelas
seguintes razões:
Ele começa por uma letra maiúscula e os outros minúsculos, representado, desta
forma, uma classe
Por ser uma classe ele possui métodos, o que não acontece com os do tipo
primitivo

Página 10 de 44


Exemplo:

String st = “Java course”;
System.out.println(st);

Página 11 de 44


8 Convenção para os Identificadores

É comum usar certas convenções para os identificadores quando se programa em java:
O nome da classe começa por maiúscula (por exemplo, Estudante);
O nome de um método começa por minúscula (por exemplo, main());
Se para a construção de um identificador (variável ou nome de classe), precisar de
usar mais de uma palavra, deve-se capitalizar as iniciais da segunda palavra em
diante (exemplo nomeDoEstudante, estudanteNumero)
O nome de uma variável começa por minúscula (por exemplo, area) e
O nome de uma constante é todo em maiúsculas (por exemplo, MAX), e se quiser
juntar mais de uma palvarra para o nome da constante deve juntar com “_” (por
exemplo MAXIMO_NUMERO_INTEIRO)

As regras de definição de identificadores vistas em Pascal, também são aqui válidas.
Recordando, os identificadores não podem ser palavras reservadas, nem começar por
um dígito, nem possuir caracteres acentuados ou cedilhados. Mas sim podem ser
formados por quaisquer combinações de letras, dígitos e os caracteres _ e $.

NB: O java, diferentemente do Pascal, é case sensitive, ou seja, só por substituir um
letra minúscula por maiúscula ele percebe a palavra é outra. Por exemplo:

String s="USTM", S="USTM";
System.out.println(s);
System.out.println(S);

As variáveis s e S, em Java, são tidas, diferentemente do Pascal, como diferentes. Mas em
Pascal esta declaração originaria um erro: duplicate identifyer.

Página 12 de 44


9 Instrução de atribuição
A atribuição é uma instrução bastante simples e útil que permite armazenar um valor
numa variável. Esse valor pode ser fornecido directamente ou resultar do cálculo de uma
expressão. A sintaxe da instrução é a seguinte:

nomeDaVariavel = expressão;

10 Expressões
Uma expressão é uma sequência de operadores e de valores. A linguagem Java tem
definido um conjunto de operadores, aritméticos e lógicos, que permitem a construção de
expressões.

10.1 Expressões aritméticas
A tabela abaixo indica a função e a ordem de prioridade no cálculo de uma expressão.

Operador Prioridade Operação
+ 1 Multiplicação
/ 1 Divisão
% 1 Resto da divisão (tanto para operandos inteiros
como reais)
+ 2 Adição
- 2 Subtracção

Consideremos, por exemplo, a seguinte expressão:

5 * (2 + 3) + (7 – 3) / 2

Uma vez que há dois conjuntos de parêntesis, eles vão ser calculados primeiro (da
esquerda para direita), resultando em:

5 * 5 + 4 / 2

Página 13 de 44


Na expressão existem agora três operadores, mas a multiplicação e a divisão têm
prioridade 1, pelo que serão calculadas primeiro, resultando em:

25 + 2

O resultado final pode, então, ser calculado: 27.

Na divisão, caso algum dos operandos for real (float ou double), o resultado será
também um número real. Por exemplo:

10 / 4.0 = 2.5

No entanto, se ambos operadores forem inteiros o resultado será também inteiro. Assim,

10 / 4 = 2

A linguagem Java inclui também operadores de incrementação e de decrementação de
variáveis, ++ (soma um ao seu operando) e - - (subtrai um ao seu operando). Por
exemplo:

conta ++
conta --

ou ainda:
++ conta
-- conta

A distinção entre as duas formas destes operadores, antes ou depois do operando, só é
relevante quando fazem parte de uma expressão maior. Por exemplo, supondo, que a
variável num tem o valor 7, a expressão

Página 14 de 44


x = ++ num;

incrementa o valor de num (para 8) e depois atribui-o a x (por isso x passa a ter o valor 8).
No entanto, se for utilizada a expressão:

x = num ++;

primeiro é feita a atribuição de num a x (x fica com o valor 7) e só depois é que é feito
incremento de num.

A linguagem Java possui ainda os operadores +=, -=, *= e /= que permitem simplificar a
escrita de algumas instruções. O operador += permite somar um valor, ou ainda uma
variável, a outra variável, guardando o resultado nesta última. Por exemplo, a instrução:

var1 += var2;

é equivalente a :

var1 = var1 + var2;

O funcionamento dos restantes três operadores (-=, *= e /=) é semelhante.

10.1.1 A Classe Math

O JDK (Java Development Kit) contém várias classes as quais são usadas para várias
finalidades. Uma das classes que é útil para operações matemáticas é Math. a qual possui
vários métodos nomeadamente Math.sqrt() que calcula a raiz quadrada,
Math.random() que gera número aleatórios entre 0 e 1, Math.sin() que calcula o seno
de um ângulo, Math.cos() que calcula o co-seno de um ângulo, Math.pow() que
calcula a potencia de um terminado número sendo dado o expoente. É de realçar que os
métodos que implementam funções trigonométricas utilizam operandos expressos em
radianos. A seguir, se apresenta, o exemplo do uso do método pow() da classe Math:

Página 15 de 44


int base = 2;
int expoente = 8;
resultado = Math.pow(base, expoente);

Esta classe também inclui constantes, como por exemplo o que pode ser invocador
através de Math.PI.

10.1.2 Conversões de tipos (Casting)

O tipo de resultado de uma expressão aritmética depende do tipo dos seus operandos. Se
todos forem do mesmo tipo, o resultado será também desse tipo. Se forem de diversos
tipos, os mesmos são convertidos, se possível, para um tipo comum pois os operadores
aritméticos estão definidos para funcionar com operandos do mesmo tipo. A seguir, se
apresenta a cadeia de conversão automática do compilador:

byte > short > int > long > float > double
char > int

É, assim, sempre possível converter um int para double ou float, mas não é possível
converter um double em float ou long sem que haja perda de informação.

Perante uma determinada expressão aritmética, o compilador identifica qual dos tipos
presentes está mais à direita na cadeia de conversão e converte os restantes operandos
para esse tipo, permitindo assim o cálculo da expressão. O resultado final será sempre
desse tipo. Por exemplo, considere-se o seguinte código:

int var_int=10,resultado_int;
double var_double=5.2, resultado_double;

resultado_double = var_int + var_double;
resultado_int = var_int + var_double;

Página 16 de 44


Na primeira expressão o valor de var_int é convertido para double, a soma é efectuada
e o resultado 15.2 (double) é armazenado em resultado_double (double).

A segunda expressão é problemática, uma vez que o compilador verifica a possibilidade
de armazenar o resultado da operação (double) numa variável int, o que não é possível
sem perca de informação. Assim o compilador origina o seguinte erro:
“possible loss of precision
found : double
required: int”

A conversão de tipos com perca de informação é permitida nalguns casos, mas o
programador tem que indicar explicitamente que a pretende. A este mecanismo chama-se
cast. Trata-se de um mecanismo útil em diversas circunstâncias, por exemplo quando se
pretende obter a parte inteira de um número real. Para o conseguir, basta colocar o tipo
pretendido entre parêntesis antes do valor, ou da expressão, a converter. A segunda
expressão acima poderia ser alterada para:

resultado_int = (int) (var_int + var_double);

10.2 Expressões Lógicas

Para além de operadores aritméticos, a linguagem Java possui também operadores
relacionais e lógicos. Estes operadores permitem a construção de expressões que têm
como resultado um valor lógico, true o false.

Os operadores relacionais permitem comparar valores ou variáveis de outros tipos,
obtendo-se resultados lógicos. Na tabela seguinte apresentam-se os operadores
relacionais e respectivo significado:

Operador Operação
> Maior que

Página 17 de 44


Operador Operação
< Menor que
>= Maior ou igual a
<= Menor ou igual a
== Igual a
!= Diferente de

Os operadores lógicos recebem operandos lógicos e produzem resultados do mesmo tipo.
Na tabela seguinte apresentam-se os operadores lógicos de utilização mais comum:

Operador Operação
&& Conjunção
|| Disjunção
! Negação

11 Entrada (Input) e Saída (Output) de Dados da Consola e
Excepções

11.1 Saída de Dados

A saída de dados na tela é feita através da instrução: System.out.println() que pode
ou não, opcionalmente, ter argumentos. Esta instrução é equivalente ao writeln do
Pascal. Por exemplo, a instrução:

System.out.println(“Bem vindo ao USTM!”);

escreve na tela:

Bem vindo ao USTM!

Esta mesma instrução pode ser usada para escrever o valor corrente de uma variável, por
exemplo:

Página 18 de 44


int dias = 30;
System.out.println(dias)

escreve na tela:

30

Também é possível escrever vários elementos de uma só vez. Para isso usa-se +. Claro
que neste contexto o operador + não significa adição, mas sim concatenação. Por
exemplo:

int dias = 30;
System.out.println(“Este mês tem ” + dias + “dias”);

escreve na tela:

Este mês tem 30 dias

É ainda possível colocar expressões na lista de elementos a escrever. Neste caso a
expressão é calculada antes da escrita, embora o resultado desse cálculo não seja
armazenado em memória. Por exemplo:

int var_int1 = 10, var_int2 = 4;
System.out.println(var_int1 + “ menos ” + var_int2 + “ é igual a ” +
(var_int1 – var_int2));

escreve na tela:

10 menos 4 é igual a 6

Página 19 de 44


Deve levar-se em conta que a utilização de expressões na instrução de escrita pode se
fonte de alguma confusão, nomeadamente se a expressão incluir uma ou mais adições
sem parêntesis. Por exemplo, na instrução que se segue:

System.out.println(var_int1 + “ mais ” + var_int2 + “ é igual a ” +
var_int1 + var_int2);

na tela aparecerá:

10 mais 4 é igual a 104

Este resultado, aparentemente estranho, é coerente, pois o compilador interpreta os sinais
+ nas instruções de escrita como concatenações. Assim, a expressão var_int1 +
var_int2 é interpretada como escrever o valor de var_int1 (10) seguido do valor de
var_int2 (4). Como não há espaço entre estes valores aparece 104. Esta ambiguidade
pode ser resolvida com a utilização de parêntesis:

System.out.println(var_int1 + “ mais ” + var_int2 + “ é igual a ” +
var_int1 + var_int2);

o que resulta em:

10 mais 4 é igual a 14

Assim como Pascal, a linguagem Java possui uma instrução que imprime a mensagem
numa única linha que é System.out.print() que tem a mesma função como o write
do Pascal.

11.2 Entrada de Dados e Excepções

Página 20 de 44


Durante as aulas os professores das aulas práticas vão fornecer a seguinte classe a qual
será usada para leitura de dados via teclado. Neste momento não se preocupem com esta
classe, irão, de certeza, percebê-la ao longo do semestre. Assim o que importa é usá-la.

No que respeita às excepções de entrada/saída, as mesmas são geradas quando não se
introduz o valor esperado. Por exemplo, no caso de um método que lê caracteres se
introduzir um símbolo, o mesmo (método) gera um erro, já tratado, que clarifica ao
utilizador que ele não introduziu nem um dígito nem uma letra.

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

//int readInt()
//double readDouble()
//String readString()
//char readChar()

public class InputReader
{

public static char readChar() // le um caracter
{
BufferedReader reader = getReader();
while (true)
{
String line = readLineOrThrowRuntime(reader);
if (line != null && line.length() > 0)
{
char c = line.charAt(0);
if (Character.isLetterOrDigit(c))
{
return c;
}
}
System.out.println("erro - nao foi nem letra nem numero.");
}
}

public static double readDouble() // le um double
{

while (true)
{
try
{
return Double.valueOf(line.trim()).doubleValue();

Página 21 de 44


}
catch (NumberFormatException e2)
{
reportError();
}

}
}

private static String readLineOrThrowRuntime(BufferedReader reader)
{
try
{
return reader.readLine();
}
catch (IOException e)
{
throw new RuntimeException(e);
}
}

private static BufferedReader getReader()
{
return new BufferedReader(new InputStreamReader(System.in));
}

private static void reportError()
{
System.out.println("Erro no numero, tente de novo");
}

public static int readInt() // le um inteiro
{

while (true)
{
try
{
return Integer.parseInt(line);
}
catch (NumberFormatException e)
{
reportError();
}
}
}

public static String readString() // le um String
{
return readLineOrThrowRuntime(reader);
}
}

Página 22 de 44


11.3 I/O com JOptionPane.
Esta é a outra forma usada para a leitura de dados via teclado em que a sua
implementação é ilustrada no programa abaixo:

import javax.swing.*;
public class Entrada
{
Public static void main(Sring[] args)
{
//leitura do valor inteiro
String nStr=JOptionPane.showInputDialog("Entra um valor
inteiro");
//conversão do valor para inteiro
int n=Integer.parseInt(nStr);
//impressa da raiz quadrada do numero
System.out.println("O quadrado de "+n+" e
"+Math.sqrt(n));
}

}

12 Instruções de Selecção
Para fazer escolha em java usam-se três instruções nomeadamente if, if-else e o
switch-case.

A instrução if(selecção simples) permite escolher entre a execução, ou não, de um
conjunto de instruções. A sua sintaxe é:
if (condicao)
{
instruções;//executadas apenas quando condição for
//verdadeira
}
A decisão é tomada com base no resultado da condição (expressão de resultado lógico),
pois as instruções só são executadas quando ele é verdadeiro.

Página 23 de 44


A instrução if-else (selecção em alternativa) possibilita a escolha entre dois conjuntos
de instruções. A sua sintaxe é:

if (condicao)
{
instruções1; //executadas quando condição é verdadeira
} else
{
instruções2;// //executadas quando condição é falsa
}
Também neste caso, a decisão é tomada em função do resultado da condição, pois este
determina qual dos conjuntos de instruções será executado.

É possível utilizar um conjunto destas instruções de selecção para seleccionar uma de
várias hipóteses. No entanto, quando a escolha tem que ser feita em função do valor de
uma expressão inteira ou carácter, é mais eficaz utilizar a instrução switch-case
(selecção múltipla). A sua sintaxe é:
switch (expressao)
{
case v1 : I1;break;
case v2 : I2;break;
...
case vn : In;break;
default : Id;break;
}

13 Instruções de Repetição
As instruções de repetição, ou ciclos, são as instruções que nos permitem fazê-lo de
forma simples. Em java existem três instruções de repetição, o while, o do-while e o
for.

A instrução while permite repetir um conjunto de instruções enquanto uma condição for
verdadeira. A sua sintaxe é:

while (condicao)
{

Página 24 de 44


instruções;//executadas apenas enquanto condição for
//verdadeira
}

É possível que num ciclo while as instruções nunca sejam executadas. Se a condição for
falsa à partida o ciclo termina de imediato, antes que as instruções sejam executadas. Por
outro lado, um cuidado a ter ao programar um ciclo é criar as condições para que ele
possa terminar. Para isso, entre as instruções do ciclo terá que haver pelo menos uma que,
numa dada circunstância, altere o valor da condição para false. Se tal não acontecer,
ciclo torna-se infinito, as suas instruções são executadas consecutivamente, sem que o
mesmo termine.

A instrução do-while permite repetir um conjunto de instruções enquanto uma condição
se mantiver verdadeira. A sua sintaxe é:
do
{
instruções;//executadas enquanto condição for verdadeira
} while (condicao)

Uma das utilizações mais comuns do do-while é a validação de dados fornecidos pelo
utilizador.

A diferença entre o while e o do-while é que neste as instruções são executadas e só
depois é calculada a condição, ou seja, contrariamente ao while, no do-while as
instruções são executadas pelo menos uma vez.

A instrução for apresenta uma terceira forma de repetição. É normalmente utilizada
quando o número de vezes que o clico deve ser repetido é conhecido a priori, embora não
esteja limitada a essas situações. A sua sintaxe é:

for (inicio;condicao;acção)
{
instruções;
}

O início e a acção são constituídos por 0 ou mais instruções. O início é executado
apenas uma vez, no início do ciclo. Serve normalmente para inicializar a variável que vai
controlar o número de vezes que as instruções vão ser repetidas. A condição é calculada
antes de cada execução das instruções. Se for verdadeira, as instruções são executadas; se
for falsa, o ciclo termina. A acção é executada automaticamente, em cada iteração, após
as instruções do ciclo normalmente serve para calcular o novo valor da variável de
controlo (usualmente é uma incrementação ou decrementação dessa variável).

Tal como no while, num for é possível que as instruções a repetir nunca sejam
executadas, bastando para isso, que a condição seja falsa à entrada no ciclo.

Página 25 de 44


14 ARRAYS
14.1 Arrays
Arrays em Java são diferentes do que em outras linguagens. Arrays em Java são
objetos que podem ser passados e acoplados a outros objetos.
Arrays podem conter qualquer tipo de elemento valorado(tipos primitivos ou
objetos), mas você não pode armazenar diferente tipos em um simples array.
Ou seja, você pode ter um array de inteiros, ou um array de strings, ou um array de array,
mas você não pode ter um array que contenha ambos os objetos strings e inteiros.
A restrição acima descrita significa que os arrays implementados em Java são
genéricos homogêneos, ou seja, um único array pode armazenar qualquer tipo de objeto com
a restrição que todos sejam do mesma classe.

14.1.1 Declarando um Array:

String difficult[];
Point hits[];
int temp[];

Outra alternativa de declaração:

String[] difficult;
Point[] hits;
int[] temp;

14.1.2 Criando Objetos Arrays:
Um dos caminhos é usar o operador new para criar uma nova instância de um array,
por exemplo:

int[] temps = new int[99];

Quando voce cria um objeto array usando o operador new, todos os índices são
inicializados para você ( 0 para arrays numéricos, falso para boolean, „0‟ para caracteres, e
NULL para objetos). Você também pode criar e inicializar um array ao mesmo tempo.

String[] chiles = { “jalapeno”, “anaheim”, “serrano” , “jumbou”, “thai”};

Cada um dos elementos internos deve ser do mesmo tipo e deve ser também do
mesmo tipo que a variável que armazena o array. O exemplo acima cria um array de Strings
chamado chiles que contém 5 elementos.

14.1.3 Acessando os Elementos do Array
Uma vez que você têm um array com valores iniciais, você pode testar e mudar os
valores em cada índice de cada array.

Página 26 de 44


Os arrays em Java sempre iniciam-se na posição 0 como no C++. Por exemplo:
String[] arr= new String[10];
arr[10]=”out”;

Isto provoca um erro de compilação pois o índice 10 não existe, pois isto está fora
das bordas do array.

arr[9] = “inside”;

Esta operação de atribuição é válida e insere na posição 9 do array, a string “inside”.

14.1.4 Arrays Multidimensionais
Java não suporta arrays multidimensionais. No entanto, você pode declarar e criar
um array de arrays e acessá-los como você faria no estilo-C.

int coords[][]= new int[12][12];
coords[0][0] = 1;
coords[0][1] = 2;

Página 27 de 44


15 Métodos
Um programa é constituído por instruções elementares (de atribuição, de selecção, de
repetição) e por métodos, também conhecidos por subprogramas, (por exemplo, para
cálculo matemático ou para a leitura de dados e a escrita de dados). O desenvolvimento
de um programa implica, a criação e a chamada de diversos métodos.

15.1 Criação de um método

Imaginemos que queiramos verificar se um triângulo é equilátero. Teríamos que
desenvolver um método similar ou equivalente ao que se apresenta a seguir:
/* Método que determina se um triângulo é equilátero sendo dadas
as medidas dos três lados */
public static boolean eEquilatero(double a, double b, double c)
{
return (a==b)&&(b==c);
}
Os métodos dividem-se em duas partes, cabeçalho e as instruções. O cabeçalho é
constituído por um conjunto de palavras reservadas, public, static e boolean neste
exemplo, pelo nome do método, eEquilatero neste caso, e pela lista de parâmetros entre
parêntesis. Como na maior parte das vezes os subprogramas servem para efectuar uma
acção específica, os eus nomes são, geralmente, formas verbais. A função das palavras
reservadas e dos parâmetros formais será abordada em pontos subsequentes. É de notar
ainda que, é comum anteceder o código de um método de comentários onde se indica o
seu propósito e dos dados de que necessita para funcionar.

Um método tem que ser integrado num programa ou numa classe para que possa ser
executado e útil. No caso do triângulo equilátero, poderia ser feito da seguinte forma:

public class Triangulo
{
{
String input1=JOptionPane.showInputDialog("Entre o
valor do lado a");
double a=Double.parseDouble(input1);
valor do lado b");
double b=Double.parseDouble(input2);
valor do lado c");
double c=Double.parseDouble(input3);
if (eEquilatero(a,b,c)) System.out.println("o
triangulo e equilatero");

Página 28 de 44


else System.out.println("o triangulo nao e
equilatero");
System.exit(0);
}

public static boolean eEquilatero(double a, double b,
double c)
//Condicao para que um triangulo seja equilatero a=b=c
{
return (a==b)&&(b==c);
}
}

O método eEquilatero() foi colocado separadamente do método main(), mas ambos
dentro da classe Triangulo. O mesmo aconteceria com outros métodos se existissem.
Cada um seria colocado em separado, mas sempre dentro da classe.

15.2 Parâmetros

O método eEquilatero(), desenvolvido no ponto anterior, só pode verificar se um
triângulo é equilátero mediantes os valores fornecidos pelo utilizador.

15.2.1 Parâmetros formais e reais

Os parâmetros classificam-se em formais e reais. Os primeiros (formais) servem para dar
forma ao método e permitir que a concretização dos valores a utilizar seja feita apenas no
momento da chamada. Os segundos (reais) são eles que realmente vão ser utilizados
durante a execução do programa.

A chamada de um método é feita indicando o seu nome e a lista de parâmetros reais a
utilizar. Existe uma relação de número de ordem e de tipo entre os parâmetros formais e
os reais. A cada parâmetro formal corresponde um parâmetro real, pelo que o número de
parâmetros formais e reais tem que ser igual. A correspondência é feita pela ordem em
que os parâmetros aparecem na declaração e na chamada, respectivamente. Ao primeiro
parâmetro formal é atribuído o valor do primeiro real e assim sucessivamente. Deve ainda
haver uma relação de tipos entre os parâmetros correspondentes. Se um parâmetro formal
tiver sido declarado como int, então o parâmetro real que lhe corresponde deverá ser
uma constante ou uma variável de tipo int ou de um tipo que possa ser armazenado
numa variável de tipo int (short ou byte). Por exemplo, o método eEquilatero()
pode ser chamado através da seguinte instrução:

eEquilatero(1,1,1);

Esta chamada provoca uma atribuição ordenada dos parâmetros reais aos parâmetros
formais. Ao parâmetro a é atribuído valor 1, ao b valor 1 e ao c valor 1 também.

Página 29 de 44


15.2.2 Passagem de parâmetros

Em java, a passagem de parâmetros de tipos predefinidos (por exemplo, int, float,
boolean,...) é feita por valor. Isto significa que não é o parâmetro real que é passado
ao método, mas apenas o seu valor. Quando o parâmetro real é uma constante, este facto
não tem impacto. No entanto, se o parâmetro real for uma variável, este tipo e passagem
de parâmetros implica que o seu valor se mantém inalterável após a execução do método,
independentemente das alterações feitas ao parâmetro formal correspondente no interior
do método. O exemplo a seguir permite concretizar esta situação.

public class Exmplo
{
{
int x=70;
muda(x);
System.out.println(x);
}

Public static void muda(int valor)
{
valor=20;
}
}
A execução deste programa começa pelo método main(), como é habitual. A instrução int
x=70; cria uma variável x e inicializa-a com valor 70. Em seguida é chamado o método
muda(), tendo como parâmetro real x. Este parâmetro corresponde ao parâmetro formal
valor. Durante a execução do método, a instrução valor=20; altera o valor deste
parâmetro, pelo que se poderia pensar que o mesmo aconteceria ao parâmetro real x. De
facto, isso não acontece, uma vez que é o valor de x que é passado ao método e não a
própria variável x, pelo que a instrução System.out.println(x); do método main()
escreve 70 no ecran e não 20.

15.3 Valor de retorno

Os métodos podem devolver ou não algum valor. No primeiro caso no cabeçalho
especifica-se o tipo de retorno à semelhança do método eEquilatero() do ponto 2. No
segundo caso o tipo é substituído pela palavra reservada void à semelhança do método
muda do ponto 3.2.

Página 30 de 44


15.4 Organização de um programa

public class Exemplo
{
//Declaração de variáveis
{
//Declaração de variávies
//Instruções elementares e/ou chamada de métodos
}

public static void nomeDoMetodo(parâmetros)
{
//Declaração de variávies
//Instruções elementares e/ou chamada de métodos
}
}

15.4.1 Visibilidade ou escopo das variáveis

Existe uma diferença importante entre as instruções e as declarações de variáveis. As
instruções têm que estar sempre dentro de um método, enquanto que a declaração de
variáveis pode estar dentro ou fora de um método. Para além disso, é importante notar
que um método não pode utilizar variáveis declaradas noutros métodos. Isto pode ser
verificado no seguinte exemplo:

public class Visibilidade
{
{
int valor=5;
System.out.println(“Valor = ”+valor+” antes da
chamada”);
muda();
System.out.println(“Valor = ”+ valor+” depois da
chamada”);
}

public static void muda()
{
//tenta alterar o valor de uma variável declarada em
main()
valor=10;
System.out.println(“Valor = ”+valor+” dentro do
muda()”)
}

}

Como se de pode verificar, a instrução valor=10; localizada dentro do método muda(),
tenta alterar o valor da variável valor. Tendo sido declarada no método main(), a variável

Página 31 de 44


valor está dentro da sua “caixa preta”, pelo que só é visível dentro deste método e,
consequentemente, é invisível no método muda(). Esta situação é detectada pelo
compilador que, ao compilar o método muda(), gera uma mensagem de erro: cannot
resolve symbol variable valor.

15.4.2 Variáveis locais

Uma variável declarada dentro de um método é chamada de variável local ao método.
No exemplo anterior, a variável valor é local ao método main(). É importante notar que
uma variável local é criada sempre que o método é activado e destruída quando ele
termina a sua execução. A existência de uma variável local está, pois, limitada ao tempo
de execução de um método, sendo, por isso, um erro tentar aceder-lhe ou obter o seu
valor fora dele. É também um erro transmitir informação numa variável local entre duas
execuções de um método onde seja declarada, ainda que essas execuções sejam
imediatamente uma a seguir a outra. Mesmo neste caso a variável é destruída no final da
primeira execução e criada de novo, eventualmente noutro local de memória, no início da
segunda execução.

Assim sendo, não se aUSTMra que seja possível declarar variáveis com o mesmo nome
em métodos diferentes. Ainda que tenham o mesmo nome, trata-se de variáveis
diferentes, localizadas em espaços de memória separadas e com visibilidade diferente. O
exemplo seguinte ilustra este facto:

{
{
int valor=5;
chamada”);
muda();
chamada”);
}

{
main()
int valor=10;
muda()”)
}

}

O resultado da execução deste programa é o seguinte:
Valor=5 antes da chamada
Valor=10 dentro do muda()
Valor=5 depois da chamada

Página 32 de 44


Página 33 de 44


15.4.3 Variáveis globais

Para além das variáveis locais aos métodos, é também possível declarar variáveis fora de
qualquer método. Estas variáveis, denominadas por variáveis globais, são criadas no
início da execução do programa, só sendo destruídas quando o programa termina. As
variáveis globais são visíveis a partir de qualquer método, pelo que podem ser utilizadas
em qualquer um deles. Apesar de à primeira vista poder parecer mais fácil declarar todas
as variáveis de um programa como globais, esta prática não é aconselhável, pois facilita o
aparecimento de erros, limita significativamente a legibilidade dos programas e
impossibilita o desenvolvimento de métodos independentes do seu contexto de utilização.
A utilização de variáveis globais é ilustrada no exemplo:

{
//Variável global – declarada fora dos métodos
static int valor=5;
{
valor=5;
chamada”);
muda();
chamada”);
}

{
main()
valor=10;
muda()”)
}

}
O resultado da execução deste programa é o seguinte:
Valor=5 antes da chamada
Valor=10 dentro do muda()
Valor=10 depois da chamada

Neste caso existe apenas uma variável valor que foi declarada fora dos métodos. Esta
localização leva o interprete do Java a criar um espaço de memória acessível a partir de
qualquer ponto do programa.

Página 34 de 44


Página 35 de 44


16 Classes e objectos

A programação orientada aos objectos refere-se à construção de programas que
funcionam essencialmente à custa de elementos (objectos) que possuem características
próprias e que são capazes de desempenhar tarefas. É através destas funcionalidades e
dos mecanismos de inteiração entre os objectos que os programas trabalham.

Em Java, como em qualquer linguagem orientada a objectos, não é possível definir
objectos sem definir primeiro a classe a que pertencem. Uma classe é usada para criar um
ou mais objectos, definindo os seus atributos e comportamentos. Assim a definição de
uma classe implica a especificação dos atributos (variáveis) e dos comportamentos
(métodos) que os objectos criados a partir dela devem possuir.

Um objecto pode ser caracterizado por três componentes:
Identidade
Atributo
Comportamento.

Deste modo é comum ter num programa objectos semelhantes, com mesmo
comportamento, mas com atributos e identidade diferentes.

Um objecto é assim definido como uma instância de uma classe e possui todas as
variáveis (atributos) e métodos (comportamentos) definidos por essa classe. Uma
vantagem da programação orientada aos objectos é, então, permitir reunir na forma mais
simples os seus atributos e comportamento, o que permite modelar de forma mais simples
e aproximada os elementos do mundo real.

Página 36 de 44


16.1 Criação de uma Classe
A criação de uma classe passa pela definição dos atributos e dos comportamentos que os
objectos criados a partir dessa classe devem apresentar.

Exemplo:
public class Motor //nome da classe
{
//Área reservada ao código
}

16.1.1 Atributos
Entre vários atributos destacamos velocidade, número do motor. A sua declaração pode
se feita da seguinte forma:

public class Motor //nome da classe
{
//Área reservada ao código
//Atributos da classe
private int velocidade
private String numMotor
}

De notar a utilização da palavra reservada private, em vez de public, na declaração dos
atributos. Desta forma, indica-se ao compilador que estas variáveis só podem ser acedidas
directamente pelos métodos (comportamentos) definidos na própria classe. Assim, os
atributos de um objecto criado a partir da classe mantêm-se inacessíveis a partir de
qualquer outro objecto, ainda que criado a partir da mesma classe. Esta opção permite
criar cada objecto como uma entidade fechada ou encapsulada, cujos detalhes internos
não são visíveis a partir do exterior e cuja utilização é independente do contexto em que a
mesma se faça.

Página 37 de 44


16.1.2 Construtores
Cada classe dever ter pelo menos um construtor. Trata-se de um tipo especial de método
utilizado apenas na criação e inicialização de objectos da classe. Distinguem-se dos
restantes métodos por terem o mesmo nome da classe e por não terem valor de retorno,
nem mesmo void.

Os construtores não são chamados como os outros métodos. Apenas a instrução de
criação de objectos da classe os pode chamar (como será descrito na secção 1.2). Estes
métodos são usados muitas vezes para inicializar os atributos de um objecto. No caso da
classe Motor, o construtor pode ser:

public Motor(int velocidade, String numMotor) //nome do construtor
{
//Inicialização dos atributos
this.velocidade = velocidade;
this.numMotor = numMotor;
}

16.1.3 Métodos
Para além do construtor, podem ser considerado o seguinte comportamento para a classe
motor:

public alteraVelocidade(int velocidade) //nome do método
{
//mudança da velocidade
this.velocidade = velocidade;
}

16.2 Criação de objectos
A declaração de um objecto pode ser feita com uma declaração semelhante à das
variáveis de tipos primitivos:

Página 38 de 44


//Declaração de um objecto de nome nomeDoObjecto
//pertencente a classe ClasseDoObjecto
ClasseDoObjecto nomeDoObjecto;

Concretizando o caso do Motor:
Motor motor;

É importante realçar que esta declaração por si só não cria o objecto. Apenas cria na
memória um espaço capaz de armazenar um endereço do espaço de memória onde um
objecto desse tipo deste tipo venha a ser armazenado. A este espaço de memória chama-
se referência, por permitir referenciar um objecto quando ele for criado. Nesta altura
sabe-se que motor pode vir a referenciar um objecto da classe Motor, mas o seu valor,
neste momento, é indefinido.

A criação de objectos é realizada através do operador new. Este operador deve ser
seguido do nome da classe a partir da qual se pretende criar o objecto e de parêntesis (),
eventualmente contendo um conjunto de parâmetros. Genericamente, a criação de um
objecto tem a seguinte sintaxe:

//Declaração de um objecto de nome nomeDoObjecto
//Pertencente a classe ClasseDoObjecto
ClasseDoObjecto nomeDoObjecto = new ClasseDoObjecto(parâmetros);

O operador new encarrega-se de chamar o construtor da classe, permitindo a realização
das operações de inicialização nele definidas. De facto, o que aparece à frente de new é a
instrução de chamada do método construtor da classe, incluindo também os respectivos
parâmetros, se houver. Concretizando para o caso da classe Motor, instrução seguinte
permite criar um novo objecto da classe Motor, guardar o seu endereço na referência
motor e inicializar os seus atributos:

motor = new Motor(40,1232004F);

Página 39 de 44


motor 0x40506070
0x40506070
40 1232004F

Motor()
// Bytecode

alteraVelocidade()
// Bytecode

O operador new reservou um espaço de memória suficiente para armazenar todos os
atributos (variáveis) do objecto, bem como para guardar uma cópia em bytecode de
todos os métodos na classe Motor. O endereço de memória a partir do qual o objecto foi
armazenado foi armazenado (0x40506070 neste exemplo) é guardado na referência
motor, permitindo o acesso posterior ao objecto à sua custa. A localização de um objecto
em memória não é controlada pelo programador, ficando o espaço respectivo ocupado até
que o objecto seja destruído.

Tendo em conta que uma referência não tem utilidade antes de ser colocada a apontar
(referenciar) para um objecto, é comum juntar as instruções de criação da referência e do
objecto numa só.

Motor motor = new Motor(40,1232004F);

O objecto assim definido é um representante da classe, caracterizado pelo seu conjunto de
dados. Em terminologia de programação orientada aos objectos, diz-se que o objecto é
uma instância da classe, pelo que as suas variáveis (atributos) são variáveis da
instância. O processo de criação de objecto chama-se instanciação.

A alteração do valor de uma variável deve ser feita com cuidado, pois pode levar à perda
de objectos por ela referenciados. Para concretizar esta questão, vamos supor que foram
criadas duas referências, motor1 e motor2, para objectos da Classe Motor. Suponhamos

Página 40 de 44


também que foram criados dois objectos, cada um deles referenciado por uma das
referências.

Motor motor1 = new Motor(10,4562004Z);
Motor motor2 = new Motor(50,7682004B);

Este conjunto de instruções dá origem à situação descrita na figura seguinte:

motor1 0x40106070
0x40106070
10 4562004Z

Motor()
// Bytecode

alteraVelocidade()
// Bytecode

motor1 0x40101010
0x40101010
50 7682004B

Motor()
// Bytecode

alteraVelocidade()
// Bytecode

Existem dois objectos em sítios diferentes da memória, cada um deles acessível por uma
referência. A instrução seguinte é válida do ponto de vista sintáctico.

motor1=motor2;

Página 41 de 44


Um erro comum é utilizar esta instrução com o objectivo de atribuir ao primeiro objecto
os dados do segundo. De facto, esta instrução não iguais os objectos, mas as referências,
atribuindo o valor da segunda à primeira. O resultado é o da figura seguinte:

Motor1 0x40106070
0x40106070
10 4562004Z

Motor()
// Bytecode

alteraVelocidade()
// Bytecode

Motor1 0x40101010
0x40101010
50 7682004B

Motor()
// Bytecode

alteraVelocidade()
// Bytecode

O que aconteceu foi na realidade foi a atribuição À variável motor1 do conteúdo de
motor2 (0x40101010), fazendo com que ambas fiquem a referenciar o mesmo objecto.
Esta situação dever se encarada com algum cuidado, pois, por vezes, há a tendência para
pensar que se há duas referências diferentes, então também há dois objectos diferentes, o
que nem sempre é verdade, como se mostra no exemplo anterior.

O primeiro objecto está agora inacessível, pelo que ocupa espaço de memória
inutilmente. O intérprete de Java efectua periodicamente a libertação de memória por
objectos sem referência válida, devolvendo ao sistema operativo, de modos a que possa
voltara ser utilizado. Este processo é conhecido na terminologia inglesa como garbage
collection (recolha de lixo).

Dois aspectos devem ser destacados em relação a esta classe Motor.

Página 42 de 44


Primeiro é que, do ponto de vista de programa o funcionamento interno da classe Motor é
irrelevante e não necessita de ser conhecido. Basta saber, por exemplo, que o método
alteraVelocidade() alterva a velociade do motor, não sendo necessário saber como se
faz.

O segundo aspecto que deve ser realçado é a forma como os métodos são chamados ou,
em terminologia orientada aos objectos, como se envia uma mensagem a um objecto.
Uma mensagem é um pedido que se faz a um objecto para que apresente um
comportamento. Claro que o objecto terá que ser uma instância de uma classe em que
esse comportamento esteja definido. Para enviar uma mensagem a um objecto é
necessária uma instrução que contenha:
Uma referencia ao objecto receptor (por exemplo motor1);
Um ponto
A mensagem que se pretende enviar (por exemplo altervaVelocidade()).

Assim se justifica, por exemplo, a instrução:

Motor1.alteraVelocidade(100);

16.3 Cópia de objectos
Quando se fala de cópia de objectos os principiantes da programação orientada a objectos
podem perceber que para o efeito é necessário fazer o seguinte:

x=y;// sendo x e y objectos.

Ora, a instrução anterior significa que x passa apontar onde y aponta, graficamente seria:

y

x

Então para copiar um objecto a instrução de atribuição de atribuição não serve. Para criar
realmente uma cópia de um objecto que tenha espaço na memória pode-se usar o método
clone(). A sintaxe é a seguinte:

novoObjecto = umObjecto.clone()

Página 43 de 44


Esta instrução copia um objecto para outro lugar na memória e põe novoObjecto
referenciando para esse lugar.

16.4 Padronização de nomes de métodos (Java beans)

Java beans são classes simples em java, que tem um construtor default, e para cada
atruibuto tem métodos de acesso (get e set).
É comum declarar métodos com nomes getXXX e setXXX(…) para indicar obterXXX e
alterarXXX.

Por exemplo envez de alteraVelocidade ficaria setVelocidade
Envez de obterVelocidade teríamos getVelocidade

17 Ficheiros
…………………………….

Página 44 de 44

Tipos de Dados, Selecção, Classes e Métodos em Java

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (19)

Destacado

Destacado (10)

Similar a Tipos de Dados, Selecção, Classes e Métodos em Java

Similar a Tipos de Dados, Selecção, Classes e Métodos em Java (20)

Más de Portal_do_Estudante_Java

Más de Portal_do_Estudante_Java (12)

Tipos de Dados, Selecção, Classes e Métodos em Java