Programação Orientada a Objectos em JAVA. Instanciação de classes. Constructores. Encapsulamento. Notação UML. Implementação de uma classe de teste

1. JAVA – Classes e Objectos
– Encapsulamento
ATAI
1

2. POO
 Objectos e Classes
 Três pilares da POO
 Encapsulamento
 Herança
 Polimorfismo
2

3. Objecto
 Objecto
 identidade
 Identifica o objecto entre a colecção de objectos existentes
 atributos
 Propriedades que definem o estado do objecto (estrutura
interna).
 métodos
 Acções ou procedimentos que alteram o estado do objecto
(comportamento).
 Objectos podem ser agrupados em Classes
3

4. Classe
 Uma CLASSE é um molde que serve de padrão para a criação de Objectos
similares designados por instâncias da classe e que caracterizam-se por:
 Possuem a mesma estrutura interna: atributos
 Possuem o mesmo interface: métodos
 CLASSES representam ainda um muito importante mecanismo de partilha
de código, dado que os métodos que implementam a funcionalidade de
todas as instâncias têm o seu código num único local, ou seja, a sua
CLASSE, contendo as instâncias apenas os valores que representam o seu
estado interno.
4

5. Exemplo: Classe Conta
class Conta {
private final long numeroConta;
private double saldo;
public Conta (long id) {
NumeroConta = id;
}
public void credito (double valor) {
saldo = saldo + valor;
}
public void debito (double valor) {
saldo = saldo - valor;
}
public double getSaldo () {
return saldo;
}
public long getNumConta () {
return numeroConta;
}
public String toString () {
return (“Numero da Conta: ”+ numeroConta + “tSaldo:” + saldo);
}
}
5

6. Classes em UML (Unified Modeling Language)
 Uma classe é representada por um rectângulo,
subdividido em três áreas:
 A primeira contém o nome da Classe.
 A segunda contém seus atributos.
 A terceira contém suas operações.
Nome da
Conta classe
- numeroConta:long
- saldo : double atributos
+ Conta(long)
+ debito(double) operações
+ credito(double)
+ getSaldo() : double
+ getNumConta() : long
6

7. Exemplo: Uso da Classe Conta
class CriaConta {
/** Criar objecto do tipo Conta */
public static void main (String [] args) {
Conta conta1, conta2;
conta1 = new Conta (4563764);
conta2 = new Conta (1238765);
conta1.credito(500.00);
conta1.debito(45.00);
conta2.credito(400.00);
conta2.debito(60.00);
System.out.println(conta1);
System.out.println(conta2);
}
}
7

8. Criar Instâncias (Objectos)
 Em Java, como em qualquer linguagem OO, não é possível definir
objectos directamente.
 É necessário definir primeiro a classe a que o objecto pertence.
 A classe funciona como um molde que pode ser utilizado para criar
qualquer número de objectos semelhantes.
 A definição de uma classe implica a especificação dos seus
atributos (variáveis) e do seu comportamento (métodos).
 Um objecto é, assim, definido como instância de uma classe e
tem todas as variáveis e métodos definidos para essa classe.
 A operação new cria uma instância de uma classe, e é responsável
pela alocação dos objectos em memória.
8

9. Sobre os Dados
 Visibilidade dos Dados  Instanciação dos dados
 As variáveis numeroConta e saldo na
 A visibilidade dos dados é a zona
classe Conta são atributos de
do programa no qual os dados
instancia, porque cada objecto da
podem ser utilizados. Classe Conta possui uma variável
não partilhada.
 Dados declarados fora dos
métodos podem ser usados por  Numa classe são declarados os
todos os métodos da classe. atributos, mas não é reservado
memória para eles.
 Dados declarados num método só
podem ser usados no método.  Sempre que um objecto Conta é
criado, novas variáveis numeroConta
e saldo são criadas. Todos os
objectos partilham o código dos
métodos, mas cada um possui o seu
espaço de dados.
9

10. Métodos Especiais: Construtor
 similares a métodos;
 possuem o mesmo nome das respectivas classes;
 não têm tipo de retorno;
 podem existir mais do que um por classe (sobrecarga de métodos
/overloading).
 Atenção !
Existe sempre um construtor implícito com o mesmo nome da
classe e sem parâmetros, o qual inicializa os atributos com
seus valores por defeito!
Conta () {NumeroConta = 111111; saldo = 0;}
Conta (long n) {NumeroConta = n; saldo = 0;}
Conta (long n, double s) {NumeroConta = n; saldo = s;}
10

11. Noção de Encapsulamento
O encapsulamento leva a observar um objecto como uma caixa preta
Métodos públicos Atributos públicos
Métodos privados Atributos privados
11

12. Encapsulamento
objecto1
Um objecto é uma capsula que possui:
Estrutura de Dados
privada •Estrutura de dados privada
•Uma API constituída por métodos públicos
m1 método público 1
•Um conjunto de métodos privados
m2 método público2
m3 método público3
método privado1
12

13. Encapsulamento em Java
 O Encapsulamento numa classe é feita pelo uso de palavras
reservadas que estão associadas aos atributos e métodos da
classe.
 Estes são designados por modificadores de visibilidade.
 São so seguintes os modificadores de visibilidade:
 public - permite acesso a partir de qualquer classe
 private - permite acesso apenas na própria classe
 protected - permite acesso apenas na própria classe e nas
subclasses (associado a herança!)
 nada
Nota:
Um atributo ou método sem modificador de acesso é acessível a
qualquer classe do mesmo package.
13

14. Uso dos modificadores nos Atributos
 Consequências de tornar um atributo privado
 Tentar aceder a um atributo privado (i.e. fora da classe) resulta
em um erro de compilação!
 Mas como torná-lo acessível apenas para consulta (leitura)?
 Isto é possível definindo-se um método que retorna o atributo (na
própria classe onde o atributo se encontra)
 Consequências de tornar um atributo publico
 É possível, mas viola o encapsulamento, é aceitável no caso
dos atributos constantes (i.e. Com o modificador final)!
14

15. Modificadores de visibilidade
public private
Atributos Viola Reforça
encapsulamento encapsulamento
Suporta outros
Proporciona Serviços
Métodos metodos na
aos clientes
classe
15

16. Composição na definição de Classes
 Composição
 Mecanismo básico e simples de reutilização que consiste em uma classe poder usar na
sua definição classes já definidas.
 Este mecanismo de composição consiste na possibilidade de as variáveis de instância
definidas numa classe poderem ser associadas a classes já existentes.
 A manipulação de tais variáveis dentro da classe que se está a definir se toma simplificada,
dado que apenas teremos que enviar as mensagens que activam os métodos que são
disponibilizados por tais classes já definidas.
 Tipos de relacionamento
 Usa
 Diz-se que A usa (uses) B, sempre que uma classe, no código dos seus métodos de
instância, cria e manipula objectos de outra.
 Contém
 Diz-se que a classe A contém (has) objectos da classe B, sempre que algumas
variáveis de instância de A vão ter objectos que são instâncias da classe B. De B dir-se-
á que é parte de (part-of) A
16

17. Definição de Classes Usando Composição…
Definição de uma Conta bancária
 Requisitos Iniciais
 Uma conta bancária pode ter 1 ou mais titulares, sendo um deles o titular principal, do qual
se conhece a morada.
 Cada conta possui um saldo actual e um "plafond" de crédito que pode variar de conta para
conta, mas que é definido quando esta é criada.
 A qualquer momento é possível realizar um depósito.
 Um levantamento apenas pode ser realizado se a importância pedida não ultrapassar o
"plafond" de crédito definido.
 A qualquer momento deverá ser possível saber o saldo da conta.
 Deverá ser possível eliminar titulares e acrescentar titulares novos.
 Deverá registar-se o número total de movimentos activos realizados sobre a conta, ou seja,
depósitos e levantamentos.
 Definição de Estrutura
 String NumConta
 String morada
 Vector titulares
 int saldo
 int numMov
 int plafond
17

18. Definição de Classes Usando Composição…
Classe Vector
 Classe Vector implementa uma abstracção de dados que é uma estrutura
linear indexada a partir de índice 0. Idêntica ao array, mas sem limite de
dimensão.
 Os métodos
 Vector (int capInicial);
 Vector();
 void addElement (Object obj);
 void insertElementAt (Object obj, int index);
 Object clone();
 boolean contains (Object obj);
 Object firstElement();
 Object elementAt (int index);
 boolean remove (int index);
 Object [] toArray();
 int size();
18

19. Definição de Classes Usando Composição…
import java.util.*;
public class ContaBanc {
// construtor
public ContaBanc (String numct, String titp, String mora,
int sld, int plf) {
numConta = numct;
morada = mora;
saldo = sld >=0 ? sld : 0;
plafond = plf >=0 ? plf : 0;
numMov = 0;
titulares = new Vector(5);
this.insereTit(titp);
}
// variáveis de instância
private String numConta;
private String morada;
private Vector titulares;
private int saldo;
private int plafond;
private int numMov;
19

20. Definição de Classes Usando Composição…
// métodos de instância
public String getNumConta () {
return numConta;
}
public String getTitular () {
return (String) titulares.firstElement();
}
public int getSaldo () {
return saldo;
}
public int getNumMov() {
return numMov;
}
public int getPlafond() {
return plafond;
}
20

21. Definição de Classes Usando Composição
public Object[] getTitulares() {
return titulares.toArray(); }
public boolean preLevanta (int valor) { // pré-cond
return (saldo + plafond) >= valor ;}
void levanta (int valor) { // ver pré-cond
saldo = saldo - valor;
numMov = numMov +1;}
public void deposita (int valor) {
saldo = saldo + valor;
numMov = numMov + 1;}
public void insereTit (String titular) {
titulares.addElement(titular); }
public void alteraMorada (String mora) {
morada = mora;}
public void alteraPlafond (int nplaf) {
plafond = nplaf;}
}
21

22. Complementos na Definição de Classe…
 Uma classe pode conter sua própria estrutura de dados e os seus próprios métodos
(static), para além de possuir uma definição das variáveis e métodos das suas
instâncias:
 Variáveis de classe
 Representam a estrutura interna de uma classe
 O acesso as variáveis deverá apenas ser realizado através de métodos de
classe, mantendo-se o princípio do encapsulamento.
 Permitem guardar na classe informações que podem dizer respeito à
globalidade das instâncias criadas e que não fariam sentido colocar em
qualquer outro local.
 Métodos de classe
 Implementam o comportamento de uma classe
 Servem para garantir o acesso e a manipulação dos valores associados às
variáveis de classe
22

23. Complementos na Definição de Classe…
 Requisitos adicionais na Classe ContaBanc:
 Deverá ser possível possuir a cada momento o número total de contas já criadas.
 Deverá ser possível possuir a cada momento o somatório dos saldos das contas existentes.
public class ContaBanc {
// variaveis de Classe
static int numContas = 0;
static int saldoTotal = 0; int total = ContaBanc.getNumContas();
int saldot = ContaBanc.getSaldoTotal();
// metodos de Classe
static int getNumContas() {
return numContas; ContaBanc.incNumContas();
}
static int getSaldoTotal() { ContaBanc.actSaldoTotal(novoSaldo);
return saldoTotal ;
}
static void incNumContas() {
numContas++;
}
static void actSaldoTotal(int saldo) {
saldoTotal += saldo;
}
…
23

24. Complementos na Definição de Classe…
// actualização do construtor
public ContaBanc(String numct, String titp, String mora,
int sld, int plf) {
incNumContas();
numConta = numct;
morada = mora;
saldo = sld >=0 ? sld : 0;
actSaldoTotal (saldo);
plafond = plf >=0 ? plf : 0;
numMov = 0;
titulares = new Vector(5);
this.insereTit(titp);
}
24

25. Projecto: Contador
 Requisitos Iniciais: Especificar a estrutura e o comportamento de Objectos do
tipo contador que satisfaçam os seguintes requisitos:
 Os contadores deverão ser contadores de tipo inteiro.
 Deverá ser possível criar contadores com valor inicial igual a 0.
 Deverá ser possível criar contadores com valor inicial igual ao valor dado como parâmetro.
 Deverá ser possível saber qual o valor actual de um dado contador.
 Deverá ser possível incrementar o contador de 1 unidade ou de um valor dado como
parâmetro.
 Deverá ser possível decrementar o contador de 1 unidade ou de um valor dado como
parâmetro.
 Deverá ser possível obter uma representação textual de um contador.
 Definição de Estrutura:
 i.e., quais deverão ser as suas variáveis de instância (os seus nomes e os seus tipos).
 cada contador deverá ter apenas que ser capaz de conter um valor de tipo inteiro
correspondente à contagem que tal contador representa.
 Definição do Comportamento:
 Construtores de Instância
 Métodos de Instância
25

26. Definição do comportamento…
 Construtores de Instância
 Os construtores de uma classe são todos os métodos especiais que são declarados na classe
e que têm por identificador o exacto nome da classe
 Podem ter argumentos (valores de qualquer tipo de dados)
 Têm como objectivo criar instâncias de tal classe que sejam de imediato manipuláveis.
 Os construtores, dado criarem instâncias de uma dada classe, não têm que especificar qual o
seu resultado, que será sempre uma instância da respectiva classe.
 É possível definir mais do que um construtor de instâncias de uma dada classe, construtores
que, em geral, apenas diferem nas inicializações realizadas.
 Métodos de Instância: <tipo de resultado> <identificador> (<pares tipo-nome >)
 <tipo de resultado>
 Tipo primitivo
 Nome de uma classe ( String, Date, Point, etc.)
 void caso o método não devolva qualquer resultado
 <identificador>
 <pares tipo-nome>
 lista de parâmetros formais
26

27. Definição do comportamento
 Sobrecarga de métodos
 Possibilidade de numa mesma classe definir métodos tendo o mesmo nome mas diferentes
parâmetros formais de entrada.
 Os métodos construtores são métodos particulares que estão sempre em sobrecarga, dado
que são mesmo obrigados a ter o mesmo nome (identificador da classe).
 Métodos de instância passa-se exactamente o mesmo.
 Em PPO métodos e mensagens são entidades distintas: mensagens são as entidades que
são responsáveis pela activação da computação programada num dado método.
 Assim, quando se envia uma mensagem com um certo identificador e uma certa lista de
argumentos a um objecto, a determinação de qual o método que deve ser executado pelo
objecto receptor depende da compatibilidade entre a estrutura da mensagem recebida e as
assinaturas dos métodos pelo mesmo tomados acessíveis. É escolhido para execução o
método cuja assinatura corresponda à estrutura da mensagem recebida quanto ao nome,
número, tipo e ordem dos parâmetros actuais de tal mensagem.
27

28. Implementação Classe Contador…
class Contador{
//construtores
Contador(){conta = 0; }
Contador(int val){ conta = val;}
//variáveis de instância
int conta;
//métodos de instância
int getConta() { return conta; // interrogador - selector}
void incConta() {conta = conta + 1;// modificador do estado}
...
28

29. Implementação Classe Contador…
…
void incConta(int x) {conta = conta + x;// modificador do estado}
void decConta() {conta = conta - 1;// modificador do estado}
void decConta(int x) { conta = conta -x; // modificador do estado}
String toString() { return (new String("Contador = " + conta));}
}
29

30. Exemplo: Classe Contador com modificadores
de acesso
public class Contador{
// construtores
public Contador(){
conta = 0;
}
public Contador(int val){
conta = val;
}
// variáveis de instância
private int conta;
// métodos de instância
public int getConta() {
return conta; // interrogador - selector
}
30

31. Exemplo: Classe Contador com modificadores
de acesso
public void incConta() {
conta = conta + 1;// modificador do estado
}
public void incConta(int x) {
conta = conta + x;// modificador do estado
}
public void decConta() {
conta = conta - 1;// modificador do estado
}
public void decConta(int x) {
conta = conta -x; // modificador do estado
}
public String toString() {
return (new String("Contador = " + conta));
}
}
31

32. Exemplo: Teste da Classe Contador
public class TesteContador {
// Classe de teste da Classe Contador
public static void main(String args[]) {
// Criação de Instâncias
Contador ct1, ct2, ct3;
ct1 = new Contador();
ct2 = new Contador(20);
ct3 = new Contador(10);
// Utilização das Instâncias
int c1, c2, c3; // variáveis auxiliares
c1 = ct1.getConta();
c2 = ct2.getConta();
32

33. Exemplo: Teste da Classe Contador
// primeira saída de resultados para verificação
System.out.println("c1 = " + c1);
System.out.println("c2 = " + c2);
// alterações às instâncias e novos resultados
ct1.incConta(); ct2.incConta(12);
c1 = ct1.getConta(); c2 = ct2.getConta();
c3 = c1 + c2;
System.out.println("c1 + c2 = " + c3);
ct3.decConta(); ct2.decConta(5);
c1 = ct2.getConta(); c2 = ct3.getConta();
c3 = c1 + c2;
System.out.println("c1 + c2 = " + c3);
// conversão para string e apresentação
System.out.println(ct1.toString());
System.out.println(ct2.toString());
}
}
33