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
This document is posted to help you gain knowledge. Please leave a comment to let me know what you think about it! Share it to your friends and learn new things together.
Transcript
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
7 O Tipo (A Classe) String ...................................................................................... 10
8 Convenção para os Identificadores ........................................................................... 12 9 Instrução de atribuição .............................................................................................. 13
10.1.1 A Classe Math ............................................................................................. 15 10.1.2 Conversões de tipos (Casting) .................................................................... 16
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
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
16.1 Criação de uma Classe .................................................................................... 37 16.1.1 Atributos ..................................................................................................... 37
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
Tipos de Dados, Selecção Repetição, Classes, Construtores e Métodos
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
Tipos de Dados, Selecção Repetição, Classes, Construtores e Métodos
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
Tipos de Dados, Selecção Repetição, Classes, Construtores e Métodos
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.
Tipos de Dados, Selecção Repetição, Classes, Construtores e Métodos
Página 6 de 44
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:
<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.
System.out.println("WelCome to USTM, ladies and gentlemen.");
Tipos de Dados, Selecção Repetição, Classes, Construtores e Métodos
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
Tipos de Dados, Selecção Repetição, Classes, Construtores e Métodos
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.
Tipos de Dados, Selecção Repetição, Classes, Construtores e Métodos
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
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);
}
}
Tipos de Dados, Selecção Repetição, Classes, Construtores e Métodos
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.
Tipos de Dados, Selecção Repetição, Classes, Construtores e Métodos
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)
{
Tipos de Dados, Selecção Repetição, Classes, Construtores e Métodos
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.
Tipos de Dados, Selecção Repetição, Classes, Construtores e Métodos
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.
Tipos de Dados, Selecção Repetição, Classes, Construtores e Métodos
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;
Tipos de Dados, Selecção Repetição, Classes, Construtores e Métodos
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
{
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");
Tipos de Dados, Selecção Repetição, Classes, Construtores e Métodos
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.
Tipos de Dados, Selecção Repetição, Classes, Construtores e Métodos
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
{
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.
Tipos de Dados, Selecção Repetição, Classes, Construtores e Métodos
Página 31 de 44
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 = ”+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
Tipos de Dados, Selecção Repetição, Classes, Construtores e Métodos
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:
public class Visibilidade
{
public static void main(String[] args)
{
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()
int valor=10;
System.out.println(“Valor = ”+valor+” dentro do
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
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
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:
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 = ”+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()”)
}
}
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.
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
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.
Tipos de Dados, Selecção Repetição, Classes, Construtores e Métodos
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.
Tipos de Dados, Selecção Repetição, Classes, Construtores e Métodos
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:
Tipos de Dados, Selecção Repetição, Classes, Construtores e Métodos
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);
Tipos de Dados, Selecção Repetição, Classes, Construtores e Métodos
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
Tipos de Dados, Selecção Repetição, Classes, Construtores e Métodos
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
Tipos de Dados, Selecção Repetição, Classes, Construtores e Métodos
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
Tipos de Dados, Selecção Repetição, Classes, Construtores e Métodos
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
Tipos de Dados, Selecção Repetição, Classes, Construtores e Métodos
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