Polimorfismo - parte 2: programação orientado a objetos com Java

Neste post abordamos a continuidade da aula anterior (parte 1) sobre o conceito do Polimorfismo aplicado na prática. Desta vez mostramos como criar as próprias classes para utilizar o conceito.

Fonte imagem

---

// Animal.java
package entidades;

public class Animal {

 private String nome;

 // opera›es
 public void emitirSom() {
  
 }

 public String getNome() {
  return nome;
 }

 public void setNome(String nome) {
  this.nome = nome;
 }
 
}

// Cachorro.java
package entidades;

public class Cachorro extends Animal {

 @Override
 public void emitirSom() {
  super.emitirSom();
  
  System.out.println("Latindo...");
 }
 
}

// Gato.java
package entidades;

public class Gato extends Animal {

 @Override
 public void emitirSom() {
  super.emitirSom();
  
  System.out.println("Miando...");
 }
 
}


// PetShop.java
import entidades.Animal;
import entidades.Cachorro;
import entidades.Gato;


public class PetShop {

 /**
  * POLIMORFISMO (aula pratica - parte 2)
  * 
  * Objetivos:
  * 
  * 1) Entender o conceito de Polimorfismo na pr‡tica
  *    usando as classes definidas pelo usu‡rio.
  *    
  *    - definicao de hierarquia classes
  *    - implementacao de exemplos
  * 
  * @author Douglas Frari
  * @see http://profdouglas.blogspot.com.br
  */

 
 public static void main(String[] args) {

  // criar dois objetos
  Cachorro cachorro1 = new Cachorro();
  Gato gato1 = new Gato();
  
  Animal animal1 = gato1;
  
  cachorro1.setNome("Totoh");
  gato1.setNome("Lu");
  
  cachorro1.emitirSom();
  gato1.emitirSom();
  
  // qual eh o metodo que serah usado? (cachorro ou gato)?
  animal1.emitirSom();
  
  animal1 = cachorro1;
  animal1.emitirSom();
  
  
  
  
 }

}

Polimorfismo - parte 1: programação orientado a objetos com Java

Neste post abordaremos o conceito de programação orientada a objetos conhecido como Polimorfismo. Como aplicar o conceito na prática usando a linguagem Java. Para entendermos estou organizando alguns vídeos para ilustrar melhor duas formas de utilização:

1. Usando as classes da linguagem Java de algumas bibliotecas que já estão disponíveis;
2. Construir nossos próprios tipos e então entender como tirar proveito do Polimorfismo.

Neste pequeno artigo veremos o primeiro caso.

Polimorfismo precisa ter uma hierarquia de classes com herança. Fonte imagem 

De acordo com a Wikipédia (fonte), podemos considerar o conceito de Polimorfismo:

"Na programação orientada a objetos, o polimorfismo permite que referências de tipos de classes mais abstratas representem o comportamento das classes concretas que referenciam. Assim, é possível tratar vários tipos de maneira homogênea (através da interface do tipo mais abstrato). O termo polimorfismo é originário do grego e significa "muitas formas" (poli = muitas, morphos = formas).

O polimorfismo é caracterizado quando duas ou mais classes distintas tem métodos de mesmo nome, de forma que uma função possa utilizar um objeto de qualquer uma das classes polimórficas, sem necessidade de tratar de forma diferenciada conforme a classe do objeto.^[1]"

Vejamos o exemplo que fiz no vídeo:

---

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;


public class Polimorfismo_parte1 {

 /**
  * POLIMORFISMO (aula pr‡tica - parte 1)
  * 
  * Objetivos:
  * 
  * 1) Entender o conceito de Polimorfismo na pr‡tica
  *    usando as classes j‡ existentes no Java
  * 
  * @author Douglas Frari
  * @see http://profdouglas.blogspot.com
  */
 
 
 public static void main(String[] args) {
  
  ArrayList lista1 = new ArrayList();
  List lista2 = new ArrayList();
  List lista3 = new LinkedList();
  
  
  lista1.add("Elemento 1");
  lista1.add("Elemento 2");
  lista1.add("Elemento 3");
  
  
  lista2.add("Elemento 1.1");
  lista2.add("Elemento 2.1");
  lista2.add("Elemento 3.1");
  
  lista3.add("Elemento 1.1.1");
  lista3.add("Elemento 2.1.1");
  lista3.add("Elemento 3.1.1");
  
  // imprimir elementos
  imprimirLista(lista1);
  imprimirLista(lista2);
  imprimirLista(lista3);
  
 }
 
 static void imprimirLista(final List lista) {
  
  for (String itemLista : lista) {
   System.out.println(itemLista);
  }
  
 }
 
 
 
}

Conclusões

O conceito de polimorfismo em programação orientada a objetos é bastante útil para compreender como os objetos podem assumir diferentes responsabilidades no programa, dependendo de como foram declarados e como são instanciados pode-se reusar estruturas e operações. O resultado disso pode não ser tão útil assim, mas é. Quando se entende o conceito começamos a pensar de forma a favorecer o reuso e assim minimizamos a quantidade de linhas de código programáveis.

Conceito de Encapsulamento em POO (java)

Oi pessoal! Antes de mais nada, se desejar me seguir no twitter está aqui (@douglasddf)

Neste post vou comentar o conceito chamado Encapsulamento relativo a programação orientada a objetos (POO). Observem as perguntas iniciais:

1. Por que encapsular informações em nosso programa? 
2. Como fazemos isso na prática usando Java?
3. É realmente necessário encapsular?

Essas questões são abordadas no vídeo que fiz (veja abaixo) para tentar responder as duas primeiras perguntas acima. Porém, a terceira pergunta é mais difícil de explicar. Alguém poderia dar uma resposta ou opinar sobre isso?

---

---

Encapsulamento, segundo Wikipédia (fonte: http://pt.wikipedia.org/wiki/Encapsulamento):

"Encapsulamento vem de encapsular, que em programação orientada a objetos significa separar o programa em partes, o mais isoladas possível. A idéia é tornar o software mais flexível, fácil de modificar e de criar novas implementações."

Ou seja, é uma forma de tornar visível para o usuário as funcionalidades que são importante para o sistema e somente isso. Em nosso exemplo, temos a classe Cliente que na prática, adicionou o tipo de acesso private do Java nos atributos e o tipo de acesso público nos métodos da classe. Só que foram criados um par de métodos (GET e SET) para recuperar e alterar, respectivamente, para cada atributo.

public class Cliente {

 // atributos para representar o cliente com acesso PRIVATE
 private String nome;
 private String CPF;
 private int quantidadePedidos;

 // para que se possa acessar os dados, criamos métodos PÚBLICOS get e set
 // para
 // cada atributo que se pretenda dar esse acesso

 /**
  * @return the nome
  */
 public String getNome() {
  return nome;
 }

 /**
  * @return the cPF
  */
 public String getCPF() {
  return CPF;
 }

 /**
  * @return the quantidadePedidos
  */
 public int getQuantidadePedidos() {
  return quantidadePedidos;
 }

 /**
  * @param nome the nome to set
  */
 public void setNome(String nome) {
  this.nome = nome;
 }

 /**
  * @param cPF the cPF to set
  */
 public void setCPF(String cPF) {
  CPF = cPF;
 }

 /**
  * @param quantidadePedidos the quantidadePedidos to set
  */
 public void setQuantidadePedidos(int quantidadePedidos) {
  this.quantidadePedidos = quantidadePedidos;
 }
 
 // operacoes que o cliente poderá
 // fazer neste sistema
 public void efetuarPedidoCompra() {
  System.out.println("efetuando pedido de compra");
  quantidadePedidos++;
 }

 // imprimir os seus valores
 @Override
 public String toString() {
  String atributosClasse = "Nome: " + nome + ", CPF: " + CPF
    + " , quantidade pedidos: " + quantidadePedidos;
  return atributosClasse;
 }

}

Isso simplesmente porque ao mudar o tipo de acesso aos atributos o Java não terá mais acesso a referência direta para LER e ESCREVER. Logo, temos que criar métodos para cada atributo GET e SET (sujestão de nome do Java). Desta maneira, quando precisarmos acessar (LER) o atributo do objeto usaremos:

  Cliente c = new Cliente();
  // acesso para ESCREVER (write)
  c.setNome("Douglas Frari"); 
  c.setCPF("222.222.222.11");
  
  // acesso para LER (read)
  System.out.println("Nome: "+c.getNome());
  System.out.println("CPF: "+c.getCPF());
  
  
  // ACESSO direto NAO é permitido pelo comilador java 
  // se não for da mesma classe. Logo, é preciso usar os SETs neste caso
  c.nome = "Douglas Frari";
  c.CPF = "222.222.222.11";
  

E quanto a pergunta 3 (É realmente necessário encapsular?)

É importante perceber que não é necessário encapsular para que o programa funcione. Mas é uma boa prática SIM encapsular os dados (atributos), pois assim tornamos o acesso DIRETO às referências dos objetos "seguros" do ponto de visto de escrita e leitura. O acesso somente será permitido usando os métodos públicos GET e SET.