Programacao em java

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

Página 1 de 44

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 2 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 3 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 4 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.

Desenvolvidor

.java

source fileWrite in editor

Compile with compiler

.class

bytecode

file

Run in JVMRUNNING

PROGRAM

Use / test


Página 5 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 6 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 7 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 8 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 9 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

ocupada

Menor valor Maior valor

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 10 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

ocupada

Menor valor Maior valor

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

ocupada

Valores

char 16 bits Qualquer carácter pertencente ao unicode

6.3.4 Boolean

Tipo Memória

ocupada

Valores

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 11 de 44

Exemplo:

String st = “Java course”;

System.out.println(st);


Página 12 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 13 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 14 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 15 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 16 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 17 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 18 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 19 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 20 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 21 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 22 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 23 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 24 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 25 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 26 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 27 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 28 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 29 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 30 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 31 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 32 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 33 de 44


Página 34 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 35 de 44


Página 36 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 37 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 38 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 39 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 40 de 44

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

0x40506070 motor

0x40506070

40

Motor()

// Bytecode

alteraVelocidade()

// Bytecode

1232004F


Página 41 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:

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;

0x40106070 motor1

0x40106070

10

Motor()

// Bytecode

alteraVelocidade()

// Bytecode

4562004Z

0x40101010 motor1

0x40101010

50

Motor()

// Bytecode

alteraVelocidade()

// Bytecode

7682004B


Página 42 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:

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.

0x40106070 Motor1

0x40106070

10

Motor()

// Bytecode

alteraVelocidade()

// Bytecode

4562004Z

0x40101010 Motor1

0x40101010

50

Motor()

// Bytecode

alteraVelocidade()

// Bytecode

7682004B


Página 43 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:

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()

y

x


Página 44 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 …………………………….

Programacao em java

Documents

Transcript of Programacao em java