Orientação a Objetos – Parte 5

Após um longo período escrevendo sobre diversas tecnologias, principalmente voltadas para a plataforma .NET, deixei a série Orientação a Objetos um pouco de lado. Mas atendendo a alguns pedidos, principalmente de alunos, com este artigo, volto a cobrir o tema e, nos artigos seguintes, pretendo esgotar o mesmo.

Para a completa compreensão do assunto abordado neste artigo, é indispensável a leitura prévia dos primeiros artigos da série, “Orientação a Objetos – Partes 1, 2, 3 e 4”, ou possuir os conceitos apresentados nos mesmos.

Uma das principais vantagens da orientação a objetos reside em um recurso conhecido como “herança”.

No mundo real, a herança é um procedimento relativamente simples e que ocorre com grande frequência, ou seja, a transferência de recursos e bens de uma pessoa para outra por quem se tem certo grau de familiaridade ou parentesco é comum.

As linguagens O.O. são formas de especificação de situações do mundo real, logo, se determinada situação ocorre no mundo real o modelo O.O. deve contemplá-la.

A herança na orientação a objetos, resulta em várias vantagens na arquitetura de uma aplicação, sendo que, as principais delas são: reaproveitamento de código e a “plugabilidade”.

Código reaproveitável e “plugável”

Um código é dito reaproveitável se sua estrutura é genérica de tal forma que, estruturas orbitantes a ela, podem utilizá-las em sua composição. Uma aplicação é dita “plugável” se esta possui módulos extensíveis (que herdam características e comportamentos e que podem ser herdados).

O mecanismo de herança

Herança é o processo que permite ao desenvolvedor extender características de outra classe e especializá-la. O mecanismo de herança é um dos pilares da orientação a objetos e está presente em todas as linguagens orientadas a objetos. Alguns exemplos de linguagens que implementam herança são: C++,  Java, C#, Eiffel, dentre outras. A Figura 1 ilustra o conceito de herança.

Figura 1: Modelo de herança adequado

Olhando para a Figura 1 podemos notar algumas características importantes e que são fundamentais para definir se uma relçao de herança é ou não pertinente. A primeira característica importante na relação acima é que  “Reserva” e “Pagamento” são especializações de “Transação”, ou seja, características e comportamentos de “Transação” não são sobrepostos ou modificados. Outra característica importante, “Reserva” e “Pagamento” são tipos especiais de “Transação” e não transações autônomas.

Olhando para a Figura 1, poderíamos ter os modelos apresentados pelas Listagens 1 e 2, em C# e Java respectivamente.

[java]
public class Transacao {
private int id;
private String data;
}

public class Reserva extends Transacao {
private int validade;
private int desconto;

public void atribuiValidadeDesconto(int _validade, int _desconto)
{
validade = _validade;
desconto = _desconto;
}

public String retornaValidadeDesconto()
{
return validade + ” / ” + desconto;
}
}

public class Pagamento extends Transacao {
private String produtos;
}

import javax.swing.*;

public class HerancaJava {

public static void main(String[] args) {

int valorDesconto = 0;
int valorValidade = 0;

String desc = “”, valid = “”;

desc = JOptionPane.showInputDialog(“Por favor, informe o percentual de desconto: “);
valid = JOptionPane.showInputDialog(“Por favor, informe a validade: “);

valorDesconto = Integer.parseInt(desc);
valorValidade = Integer.parseInt(valid);

Reserva objReserva = new Reserva();
objReserva.atribuiValidadeDesconto(valorValidade, valorDesconto);

JOptionPane.showMessageDialog(null, “Validade / Desconto: ” + objReserva.retornaValidadeDesconto());

}
}
[/java]

Listagem 1: Exemplo de herança em Java

[csharp]
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace HerancaCSharp
{
class Transacao
{
private int id;
private DateTime data;
}
}

namespace HerancaCSharp
{
class Reserva : Transacao
{
private int validade;
private int desconto;

public void atribuiValidadeDesconto(int _validade, int _desconto)
{
validade = _validade;
desconto = _desconto;
}

public string retornaValidadeDesconto()
{
return validade + ” / ” + desconto;
}
}
}

namespace HerancaCSharp
{
class Pagamento : Transacao
{
private string produtos;
}
}

namespace HerancaCSharp
{
class Program
{
static void Main(string[] args)
{
string desc, valid;
int valorDesconto, valorValidade;

Console.WriteLine(“Digite o percentual de desconto: “);
desc = Console.ReadLine();
Console.WriteLine(“Digite a validade: “);
valid = Console.ReadLine();

valorDesconto = int.Parse(desc);
valorValidade = int.Parse(valid);

Reserva oReserva = new Reserva();
oReserva.atribuiValidadeDesconto(valorValidade, valorDesconto);

Console.WriteLine(“Validade/Desconto: ” + oReserva.retornaValidadeDesconto());
}
}
}
[/csharp]

Listagem 2: Exemplo de herança no C#

Bom pessoal, é isso. Espero que este artigo o ajude a compreender um pouco melhor o mecanismo de herança. No próximo artigo falaremos um pouco sobre herança múltipla, interfaces e classes abstratas.

Não se esqueçam de deixar seus comentários ao final do artigo 🙂 .