1

MÓDULO 3
Conceitos básicos II
Iniciação à Programação orientada a Objetos

Instâncias e
métodos
construtores
1 Instâncias e métodos
construtores

Conteúdo
1.1 Método construtor 06
1. Instâncias e métodos construtores

Os objetos são modelos de programação que compreendem uma série de propriedades mediante variáveis,
assim como uma funcionalidade através de métodos em Java e funções em C++. Neste sentido, muitas das
características de Java são heranças de C++, linguagem da qual deriva quase diretamente.

Por outro lado, as classes pressupõem a generalização dos objetos, de forma que um conjunto de objetos com
as mesmas características e funcionalidade formará uma classe.

Vamos introduzir agora o termo instância: uma instância de uma classe não é mais do que um objeto particular
desta. Logo, quando criamos um objeto de uma determinada classe, diremos que este se instanciou da classe
a que pertence:

Classe Objeto

Os componentes de uma classe, como já mencionámos anteriormente, no que toca à generalização dos objetos,
serão:

1. Atributos ou propriedades: características; trata-se das variáveis.

2. Métodos (comportamento): funcionalidade; trata-se das funções, que agora se chamam métodos e ser-
vem para trabalhar com as variáveis da classe.

Para nos referirmos à herança das classes, devemos recordar o conceito de herança: se dispomos de uma
classe Pai e uma classe Filha, que deriva dela, esta adquire (herda) todas as características (variáveis) e funções
(métodos) da classe Pai.

AS CLASSES PREDEFINIDAS DE JAVA

O Java conta já com um conjunto de classes predefinidas, as classes primitivas. Para incluir, no nosso programa,
pacotes (ou seja, o conjunto de classes já predefinidas que em inúmeras ocasiões são necessárias, pois fornecem
uma determinada funcionalidade ao nosso programa) com outras classes definidas por nós, teclaremos o comando
import seguido do nome do pacote que nos interessa carregar e, posteriormente, o da classe a que esse pacote
pertence.

Exemplo:

import java.appletApplet.;
importamos a classe Applet do pacote java.applet

import java.awt.Color;
importamos a classe Cor do pacote java.awt

04 MÓDULO 3 • Iniciação à Programação orientada a Objetos

1. Instâncias e métodos construtores

Se nos interessa incluir todas as classes do pacote java.awt, digitaremos o comando import seguido do nome do
pacote e depois o símbolo * (asterisco) para nos referirmos a todas as classes incluídas nele.

import java.awt.*;
importamos todas as classes do pacote java.awt

PARÂMETROS DE UMA CLASSE

Seguidamente vamos ocupar-nos daqueles parâmetros que podem aparecer quando definimos uma classe.

Definição de uma classe:

[Modificador] class Nome_classe [extends Nome_classe] [implements Nome_Interface]

{

Tudo o que se situa entre parêntesis é opcional.

• [Modificador] Aplicável a classes. Posteriormente abordaremos os possíveis modificadores.

• class. Palavra reservada que se utiliza para declarar uma classe. Todos os atributos e métodos desta
definir-se-iam dentro das chaves situadas abaixo.

• Nome da classe. É o nome que adjudicamos à classe.

• [extends Nome_classe]. Assinala que a classe herda de outra, cujo nome também se indica.

• [implements Nome_interface]. Indica que se implementa uma interface Java, cujo conceito desenvolve-
remos posteriormente.

Iniciação à Programação orientada a Objetos • MÓDULO 3 05

1. Instâncias e métodos construtores

1.1 Método construtor

a. Métodos
Um método é uma função associada a um objeto; logo, sempre que um método seja executado devem especificar-se
os dados do objeto. Além disso, o método não apresenta o modificador static à frente do nome.

class data {
int dia, mes, ano;

void imprimir () {
System.out.println (this.dia+”/”+this.mes+”/”+
this.ano);
}
}

Contrariamente às funções, os métodos necessitam que se tenha criado o objeto para poder executar-se. As
operações que se podem realizar sobre objetos, realizam-se através de métodos.

data f1 = new data();

data f2 = new data();
f1.dia = 20; f1.mes = 9; f1.ano = 2000;
f2.dia = 6; f2.mes = 11; f2.ano = 1999;
f1.imprimir(); // Chamada ao método à 20/9/2000
f2.imprimir(); // Chamada ao método à 6/11/2000

b. Construtores

Figura 1

06 MÓDULO 3 • Iniciação à Programação orientada a Objetos

1. Instâncias e métodos construtores

Trata-se de um método especial que se executa, precisamente depois de ter criado o objeto da classe new e que
serve para o inicializar, reservando memória.

O construtor caracteriza-se por apresentar o mesmo nome que a classe e por não possuir retorno, nem sequer
se adiciona o modificador void. Uma classe pode ter vários construtores, estes diferenciam-se pela quantidade
de argumentos e pelo seu tipo (sobrecarregados).

Class ponto {
int x, y;

ponto (int x, int y) {

this.x = x; CONSTRUTOR
this.y = y;
}
}

ponto p1 = new ponto (3,1);

ponto p2 = new ponto (5,4);

O construtor pode estar sobrecarregado:

class data {
int dia, mes, ano;

data () { // Construtor por defeito.

this.dia = 14;
this.mes = 10; data f1 = new data()
this.ano = 2000;
}

data (int dia, int mes, int ano) {

this.dia = dia;
this.mes = mes; data f2 = new data(1, 1, 2000)
this.ano = ano;
}

data (int dia, int mes) {

this.dia = dia;
this.mes = mes; data f1 = new data(1, 2)
this.ano = 2000;

Iniciação à Programação orientada a Objetos • MÓDULO 3 07

1. Instâncias e métodos construtores

TIPOS DE CONSTRUTORES

• Denominamos construtor por defeito, o que não recebe parâmetros.

• Denominamos construtores gerais, aqueles que recebem um ou mais parâmetros.

Se uma classe não possui construtores, o compilador atribui-lhe, um construtor por defeito anónimo (de modo que
não é obrigatório definir um construtor dentro de uma classe) com o mesmo nome e modificador de acesso que
a classe e com uma só linha de código (super()). Todas as classes têm construtor, quer seja explícito ou implícito.

class ponto {
int x, y;

ponto (int x, int y) {

this.x = x;
this.y = y;
}

ponto (int xy) {

this (xy, xy); // Chama o construtor anterior.
}
}

Antes de continuar, vamos fazer referência a palavras classes de Java (this, super), posteriormente vamos
aprofundá-los e alargaremos a informação seguinte.

• Um construtor de uma classe pode chamar outro construtor da mesma classe fazendo referência à palavra
classe this. Esta palavra chave apenas pode aparecer na primeira linha de código de um construtor.

• Um construtor de uma subclasse pode chamar outro construtor da sua superclasse com a palavra super();

• Os construtores podem ter qualquer um dos 4 tipos de modificadores de acesso (public, protected, default
ou package e private).

• Dentro de uma classe os construtores apenas podem ser chamados por outros construtores ou por
métodos static.

Exemplo:

Temos uma primeira classe, sem método main com 2 construtores, um com parâmetros e outros sem parâmetros:

public class Construtores {

public int base;
public int altura;

public Construtores (int base, int altura) { //Construtor com 2 parâmetros

this.base=base; //Com isto indicamos ao construtor que o
this. Altura =altura; // parâmetro que lhe passámos é igual ao da variável
//declarada acima

08 MÓDULO 3 • Iniciação à Programação orientada a Objetos

1. Instâncias e métodos construtores

public int areaRetangulo () {

return base+altura;

Dispomos de 2 construtores, com vários tipos de dados, isto chama-se sobrecarga, ou seja, 2 construtores com
o mesmo nome, que realizam funções diferentes para chegar a uma mesma execução.

Neste caso apenas temos 2, mas podemos colocar sempre os que queiramos e quando não se repetir nenhum
padrão.

Esta classe é para calcular a área de um retângulo, mas por não ter método main, se a executarmos, não faz
nada. Necessitamos de um método main, que vamos colocar numa segunda classe.

Esta segunda classe não tem variáveis, apenas tem um método main, e a partir dele chamaremos os construtores
da classe, para obter a área do retângulo:

public class TesteConstrutores {

public static void main (String [] args) {

//TODO Auto-generated metod stub

Construtores c=new Construtores () ; //Ao criar este objeto e não ter

// parâmetros, vamos ao construtor

// sem parâmetros,
// que nos leva a outro construtor
// passando-lhe os argumentos com
// a palavra-chave this.

System. out. printIn (c.areaRetangulo () ) ;

Construtores c1=new Construtores (3,5) ; // Ao criar este objeto ter
//parâmetros, se vamos ao
//construtor que contém esses
//argumentos irá adicionar os
//mesmos argumentos aos seus valores
//variáveis.
System.out.printiIn (c1.areaRetangulo () ) ;

Iniciação à Programação orientada a Objetos • MÓDULO 3 09

1. Instâncias e métodos construtores

Nesta classe, primeiro criamos um objeto chamado c da classe Construtores. Ao passar-lhe um construtor,
sem argumentos, irá à classe anterior, onde o construtor não tem argumentos, este chamará outro construtor,
passando-lhe dois argumentos colocados, por defeito. Imprimimos por ecrã, a área do retângulo, que deve
devolver-nos 9, já que, por defeito, colocámos base 3 e altura 3.

Posteriormente, criamos outro objeto da mesma classe anterior chamado c1, a este construtor passamos 2
argumentos que o construtor nos exige, passando a valer 3 a base e 5 a altura e imprimimos por ecrã, o objeto
c1 dando-nos como resultado 15.

c. Sobrecarga de funções
O Java permite criar várias funções com o mesmo nome, de forma a que estas se distingam:

• Pelo número de parâmetros.

• Pelo tipo de parâmetros.

Quando se chamar uma função, o compilador decidirá qual das funções sobrecarregadas chamar, dependendo
dos seus parâmetros.

1 static int soma (int a, int b) { à soma_int_int

return (a + b);
}

2 static int soma (int a, int b, int c) { à soma_int_int_int

return (a + b + c);
}

3 static double soma (double a, double b) { à soma_double_double

return (a + b);
}

int a = 3, b = 5, c = 8;
float f = 3.7f;
double d = 8.2, e = 1.7;
soma (a,b); // Chama 1.
soma (a, b, c); // Chama 2.
soma (d, e); // Chama 3.
soma (a, d); // Chama 3.
soma (a, b, f); // Erro não se pode ajustar.
Soma (a, b, (int) f); // Chama 2.

10 MÓDULO 3 • Iniciação à Programação orientada a Objetos

1. Instâncias e métodos construtores

A sobrecarga de funções apenas se pode efetuar relativamente aos parâmetros, não sobre o retorno:

double x = soma (a, b); // Chama 1.

int y = soma (d, e); // Chama 2 e é produzido um erro.
int y = (int) soma (d, e); // Chama 2.

Iniciação à Programação orientada a Objetos • MÓDULO 3 11