Classes e Objectos JAVA

629
-1

Published on

Programação Orientada a Objectos em JAVA.

Instanciação de classes.
Constructores.
Encapsulamento.
Notação UML.
Implementação de uma classe de teste

Published in: Education
0 Comments
1 Like
Statistics
Notes
  • Be the first to comment

No Downloads
Views
Total Views
629
On Slideshare
0
From Embeds
0
Number of Embeds
0
Actions
Shares
0
Downloads
0
Comments
0
Likes
1
Embeds 0
No embeds

No notes for slide
  • Um objecto em PPO possui uma estrutura de dados interna e privada, que corresponde à sua representação definida Claro que tal representação atributiva e de carácter informático é apenas uma das muitas que poderiam ter sido encontradas. Por exemplo, a representação de um Ponto2D, ou seja, um ponto do plano que necessita de ser caracterizado por dois valores inteiros ou reais que representam as suas coordenadas em x e y, tanto poderia ser conseguida à custa de 2 variáveis simples do tipo inteiro ou real, como por um
  • Uma variável que guarde o número total de contas já criadas não é certamente uma variável de instância Nenhuma conta necessita de saber o total de contas já criadas. Se só poderíamos usar variáveis de instância , então tal variável de instância, por exemplo, tcontas, apareceria em todas as instâncias de ContaBanc Se já existissem 120 contas, em todas as instâncias deveria aparecer com o valor 120 Pior ainda, logo que uma nova conta fosse criada, 120 mensagens deveriam ser de imediato enviadas às 120 instâncias, dando a indicação de que agora passam a ser 121.
  • Classes e Objectos JAVA

    1. 1. JAVA – Classes e Objectos – Encapsulamento ATAI 1
    2. 2. POO Objectos e Classes Três pilares da POO  Encapsulamento  Herança  Polimorfismo 2
    3. 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. 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. 5. Exemplo: Classe Contaclass 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. 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. 7. Exemplo: Uso da Classe Contaclass 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. 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. 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. 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. 11. Noção de Encapsulamento O encapsulamento leva a observar um objecto como uma caixa pretaMétodos públicos Atributos públicosMétodos privados Atributos privados 11
    12. 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úblicosm1 método público 1 •Um conjunto de métodos privadosm2 método público2m3 método público3 método privado1 12
    13. 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. 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. 15. Modificadores de visibilidade public privateAtributos Viola Reforça encapsulamento encapsulamento Suporta outros Proporciona Serviços Métodos metodos na aos clientes classe 15
    16. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 30. Exemplo: Classe Contador com modificadoresde acessopublic 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. 31. Exemplo: Classe Contador com modificadoresde acessopublic 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. 32. Exemplo: Teste da Classe Contadorpublic 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. 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

    ×