Programacao 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 2 3 4 5 6

História da Linguagem Java........................................................................................ 3 Componentes da Plataforma Java ............................................................................... 3 Compilar um Programa em Java ...................................................... ................................................................................. ........................... 4 Primeiro Programa em Java J ava ou Classe Simples .................................................. .......................................................... ........ 5 Compilação e execução de um programa java .................................................... ............................................................ ........ 7 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 Caracteres ................................................. .................................................................................................... ................................................... 10 6.3.4 Boolean ....................................................................................................... 10 7 O Tipo (A Classe) String ...................................................................................... 10 8 Convenção para os Identificadores 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

Tipos de Dados, Selecção Repetição, Classes, Construtores e Métodos 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 Organização de d e 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 o bjectos.............................................. ......................................................................................... ........................................... 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

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

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 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 b rowsers 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

Tipos de Dados, Selecção Repetição, Classes, Construtores e Métodos 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  –  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 p recisam 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.

Write in editor

.java source file

Desenvolvidor

Use / test 

RUNNING PROGRAM

Compile with compiler

Run in JVM

.class bytecode file

Página 4 de 44

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

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 ignorado */.

/* Coloca-se aqui o texto a ser

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

PrimeiroPrograma

pacotes.

é o nome da classe. O “abre –  chavetas” indica o início das

declarações da classe. Página 5 de 44

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

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

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: .(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.

System.out.println("WelCome to USTM, ladies and gentlemen.");

Página 6 de 44

Tipos de Dados, Selecção Repetição, Classes, Construtores e Métodos Chamada do método

println

para o atributo

argumento é uma constante do tipo

out

da classe ou objecto

String. println,

assim como

writeln

imprime o String e posiciona o cursor na linha abaixo, analogamente

System,

o

de Pascal,

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

Tipos de Dados, Selecção Repetição, Classes, Construtores e Métodos 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, como métodos andar,

cor de cabelo, etnia e

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

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

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, segundo caso, é usada a letra

E

37.0

ou

0.234

estão na notação decimal. No

para indicar o expoente na base

10.

Por exemplo,

2.5E6

representa o número 2,5 x 10 6. 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

Tipos de Dados, Selecção Repetição, Classes, Construtores e Métodos 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

Tipos de Dados, Selecção Repetição, Classes, Construtores e Métodos Exemplo: String st = “Java course”;

System.out.println(st);

Página 11 de 44

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

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

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

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

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

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

Tipos de Dados, Selecção Repetição, Classes, Construtores e Métodos 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 +=, escrita de algumas instruções. O operador

+=

-=, *= e /= que permitem simplificar a

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

Tipos de Dados, Selecção Repetição, Classes, Construtores e Métodos 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

Tipos de Dados, Selecção Repetição, Classes, Construtores e Métodos 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

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

Menor que

>=

Maior ou igual a

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 { BufferedReader reader = getReader(); while (true) { String line = readLineOrThrowRuntime(reader); try { return Double.valueOf(line.trim()).doubleValue();

Página 21 de 44

Tipos de Dados, Selecção Repetição, Classes, Construtores e Métodos } 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 { BufferedReader reader = getReader(); while (true) { String line = readLineOrThrowRuntime(reader); try { return Integer.parseInt(line); } catch (NumberFormatException e) { reportError(); } } } public static String readString() // le um String { BufferedReader reader = getReader(); return readLineOrThrowRuntime(reader); } }

Página 22 de 44

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

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

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

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

Tipos de Dados, Selecção Repetição, Classes, Construtores e Métodos instruções;//executadas //verdadeira

apenas

enquanto

condição

for

}

É 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 utilizador.

do-while

é a validação de dados fornecidos pelo

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

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

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

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

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

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

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 { public static void main(String[] args) { String input1=JOptionPane.showInputDialog("Entre o valor do lado a"); double a=Double.parseDouble(input1); String input2=JOptionPane.showInputDialog("Entre o valor do lado b"); double b=Double.parseDouble(input2); String input3=JOptionPane.showInputDialog("Entre o 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

Tipos de Dados, Selecção Repetição, Classes, Construtores e Métodos else System.out.println("o equilatero"); System.exit(0);

triangulo

nao

e

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

b,

}

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

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

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 { public static void main(String[] args) { 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

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

15.4 Organização de um programa  public class Exemplo { //Declaração de variáveis public static void main(String[] args) { //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 { public static void main(String[] args) { int valor=5; System.out.println(“Valor chamada”);

=

”+valor+”

antes

da

depois

da

muda(); System.out.println(“Valor chamada”);

=

”+

valor+”

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

Tipos de Dados, Selecção Repetição, Classes, Construtores e Métodos 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: public class Visibilidade { public static void main(String[] args) { int valor=5; System.out.println(“Valor chamada”);

=

”+valor+”

antes

da

depois

da

muda(); System.out.println(“Valor chamada”);

=

”+

valor+”

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

=

”+valor+”

dentro

do

} }

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

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

Página 33 de 44

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

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: public class Visibilidade { //Variável global – declarada fora dos métodos static int valor=5; public static void main(String[] args) { valor=5; System.out.println(“Valor chamada”);

=

”+valor+”

antes

da

depois

da

muda(); System.out.println(“Valor chamada”);

=

”+

valor+”

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

=

”+valor+”

dentro

do

} }

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

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

Página 35 de 44

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

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

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

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 pri vate, 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

Tipos de Dados, Selecção Repetição, Classes, Construtores e Métodos 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

Tipos de Dados, Selecção Repetição, Classes, Construtores e Métodos //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 chamase 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 permite criar um novo objecto da classe

Motor,

Motor,

instrução seguinte

guardar o seu endereço na referência

motor e inicializar os seus atributos: motor = new Motor(40,1232004F);

Página 39 de 44

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

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 todos os métodos na classe

Motor.

bytecode

de

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

Tipos de Dados, Selecção Repetição, Classes, Construtores e Métodos 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

Tipos de Dados, Selecção Repetição, Classes, Construtores e Métodos 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

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

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