Contruindo classes e Integrando objetos

Neste módulo veremos:

• Abstração (pouco);
• Modularização;
• Integração;
• Chamadas de métodos;

Abstração

Na abordagem orientada a objetos de programação de computadores (POO -- Programação Orientada a Objetos) uma tarefa inicial e fundamental é a definição dos objetos.

Para definir um objeto o analista/programador precisa abstrair os conceitos envolvidos no problema a ser resolvido para identificar os objetos, ou seja, é necessario abstrair para POO os objetos do mundo real.

Neste processo de abstração é crucial definir a granularidade dos objetos, ou melhor, seu nível de detalhamento. Vejamos um exemplo de comoum automóvel pode ser visto como diferentes objetos por diferentes especialistas:

• Engenheiro de transportes: Um automóvel pode ser visto dentro de categorias de veículos em que talvez o peso e o seu tamanho sejam os atributos mais importantes. Estes seriam talvez os atributos mais detalhados de seu modelo;
• Projetista/Designer: As formas, as curvas, o modelo, as tendências e as cores de um automóvel são agora, para esta categoria profissiona,l os aspectos mais importantes. Talvez para um designer de interiores de veículos outros fatores também sejam acrescentados;
• Mecânico: As peças que compõem a suspenção, o motor e o câmbio devem ser muito bem detalhadas e estes atributos são, para o mecânico, fundamentais para a caracterização de um objeto automóvel.

Pelo exemplo acima, podemos inferir que a visão de um analista ou programador pode ter amplitudes diferentes ao se analisar os mesmos objetos.
O problema da granularidade é uma das questões essenciais que a modelagem orientada a objetos auxilia resolver.

Modularização

Juntamente com a tarefa de abstração e posterior definição de um objeto vem a questão da separabilidade ou não de componentes do objeto analisado.

Por exemplo: quando pensamos num automóvel, na visão de um mecânico, será que não poderíamos dividí-lo em sub-objetos, ou seja, em componentes menores, por exemplo: motor, suspensão, chassi, câmbio... e estes ainda em: pistão, rodas, engrenagens...

A modularização é justamente esta outra tatefa árdua de segmentar, dividir um objetos em unidades físicas, no nosso caso de POO, em unidades lógicas, menores e que podem ser tratadas independentemente e, ainda mais, serem reunidas para formarem um novo objeto.

Abstraindo e modularizando um relógio

Vamos imaginar um relógio digital constituído de dois mostradores, um para os minutos e outro para as horas, algo do tipo 13:47, para mostrar treze horas e quarenta e sete minutos.

Para nossa abstração, existirão dois objetos do tipo mostrador, um que mostra de 0 a 24 para as horas e outro de 0 até 60 para os minutos. O conjunto formado por dois mostradores será um relógio.

Vejamos parte do código fonte abaixo:

  public class Mostrador
  {
    private int limite;
    private int value;
    
    // construtor e metodos
  }
  
    public class Relogio
  {
    private Mostrador horas;
    private Mostrador minutos;
    
    // construtor e metodos
  }

A classe Mostrador

/** Mostrador
 * @author Kölling e Barnes
 * @version 20.ago.2005
 */
 public class Mostrador
 {
	 private int limite;
	 private int valor;
	 
	 public Mostrador(int termino)
	 {
		 limite=termino;
		 valor=0;
	 }
	 
	 public int getValor()
	 {
		 return valor;
	 }
	 
	 public void setValor(int entrada)
	 {
		 if((entrada>=0)&&(entrada<limite))
		   valor=entrada;
	 }
	 
	 // retorna o valor do mostrador
	 public String getMostrador()
	 {
		 if (valor<10)
		   return "0"+valor;
		 else
		   return ""+valor;
	 }
	 
	 public void incrementa()
	 {
	     valor=(valor+1)%limite; 
	 }
 }

As partes de Mostrador

	 public String getMostrador()
	 {
		 if (valor<10)
		   return "0"+valor;
		 else
		   return ""+valor;
	 }

Notem mais uma vez que o operador + não é um operador de adição e sim um concatenador de cadeias de caracteres, de String.

O tipo String é o tipo do retorno e "0" é uma string que será concatenada com a string formada pelos caracteres do valor do mostrador.

	 public void incrementa()
	 {
	     valor=(valor+1)%limite; 
	 }

O operador módulo (%) calcula o resto de uma divisão de inteiros. Logo, se o contador ultrapassar o limite estabelecido, o valor retorna para zero.Vejamos agora a classe Relogio:

A classe Relogio

/** Relogio
 * @author Kölling e Barnes
 * @version 20.ago.2005
 */
 public class Relogio
 {
	 private Mostrador hora;
	 private Mostrador minuto;
	 // simula mostrador
	 private String display;
	 
	 public Relogio()
	 {
		 hora = new Mostrador(24);
		 minuto = new Mostrador(60);
		 updateDisplay();
	 }
	 
	 public Relogio(int hora_e, int minuto_e)
	 {
		 hora = new Mostrador(24);
		 minuto = new Mostrador(60);
		 setTime(hora_e, minuto_e);
	 }
	 
	 public void setTime(int hora_e, int minuto_e)
	 {
		 hora.setValor(hora_e);
		 minuto.setValor(minuto_e);
		 updateDisplay();
	 }
	 
	 public String getTime()
	 {
		 return display;
	 }
	 
	 private void updateDisplay()
	 {
		 display=hora.getMostrador()+":"+
		         minuto.getMostrador();
	 }
	 
	 public void avancaTempo()
	 {
		 minuto.incrementa();
		 if(minuto.getValor()==0)
		   hora.incrementa();
		 updateDisplay();
	 }
 }

Vejamos agora cada componente separadamente da classe Relogio.

Os atributos

public class Relogio
 {
	 private Mostrador hora;
	 private Mostrador minuto;
	 // simula mostrador
	 private String display;
	 

Notem que hora e minuto são atributos da classe Mostrador, como já tínhamos adiantado. O identificador display, da classe String, que é a impressão visual dos valores de hora e minuto, também é um atributo da classe.

Os construtores

São dois os construtores. O construtor padrão inicializa o relógio com os limites máximos do mostrador, um suma, declarar que o relógio estará no formato de 24 horas. O outro construtor faz o mesmo mas inicializa o display com qualquer valor, ou seja, ajusta, acerta o relógio.

Veja aqui as chamadas ao métodos construtores da classe Mostrador vista anteriormente.

	 public Relogio()
	 {
		 hora = new Mostrador(24);
		 minuto = new Mostrador(60);
		 updateDisplay();
	 }
	 
	 public Relogio(int hora_e, int minuto_e)
	 {
		 hora = new Mostrador(24);
		 minuto = new Mostrador(60);
		 setTime(hora_e, minuto_e);
	 }

Outros métodos

	 public void setTime(int hora_e, int minuto_e)
	 {
		 hora.setValor(hora_e);
		 minuto.setValor(minuto_e);
		 updateDisplay();
	 }
	 

Observem o envio da mensagem setValor() passada ao tipo Mostrador nos objetos hora e minuto.

	 public String getTime()
	 {
		 return display;
	 }

Simples! Retorna o tipo String na figura do atributo display que poderá ser impresso pelo objeto que invocar o objeto Relogio.

	 private void updateDisplay()
	 {
		 display=hora.getMostrador()+":"+
		         minuto.getMostrador();
	 }

Este método é o responsável por manter a cadeia de caracteres display atualizada e no formato aproximado de um relógio digital. Aqui também há uma concatenação de cadeias de caracteres.

	 public void avancaTempo()
	 {
		 minuto.incrementa();
		 if(minuto.getValor()==0)
		   hora.incrementa();
		 updateDisplay();
	 }

Este método incrementa o valor do minuto no relógio. Quando o valor do minuto chegar ao seu limite as horas são incrementadas.

Fazer em classe

1. Implementar uma classe para testar e executar o funcionamento da classe Relogio.
2. Implementar uma classe Ponto, agregação de um par de coordenadas x e y e, a partir desta classe, construir uma classe retângulo.