«

»

set 27

Classe, encapsulamento, herança, composição e agregação

Para um programa em uma linguagem qualquer ser orientado a objeto, ele tem que ser formado por classes, heranças, composições e agregações. A maioria das linguagens de programação hoje em dia suporta esse paradigma de desenvolvimento. Vamos então a alguns conceitos básicos sobre o assunto.

Classes

Uma classe é uma espécie de modelo de dados formado por atributos e métodos.

Atributos e métodos

Atributos são variáveis internas de uma classe. Por exemplo, se fôssemos criar uma classe para representar uma Pessoa, provavelmente as variáveis Nome e RG seriam alguns dos seus atributos.

Métodos são funções internas de uma classe. Por exemplo, se fossemos criar uma classe para representar uma Pessoa, provavelmente as funcionalidades definirNome e retornarNome seriam alguns dos seus métodos.

Construtores e destrutores de uma Classe

Construtores são métodos de inicialização de uma classe. Eles serão executados automaticamente assim que um objeto dessa classe for instanciado dentro do programa. Geralmente são usados para inicializar variáveis ou executar algum bloco de código necessário.

Destrutores exercem função parecida a do construtor. São executados automaticamente, mas somente quando o programa decidir que um objeto de uma determinada classe não será mais usado ou quando uma instrução de destruição (inserida pelo programador) for encontrada no código. Geralmente são usados para liberar recursos alocados pelo objeto durante a execução.

Exemplo de classe

Quando queremos construir uma classe para representar um ponto em um universo 2D (coordenadas x,y), devemos definir os atributos e os métodos para ela. Nesse caso, os atributos são valores numéricos de x e y, já os métodos são as funções internas que permitem definir e recuperar os valores de x e y.

Exemplo de classe Ponto implementada em linguagem de programação PHP

class Ponto
{
    //atributos
    private $x;
    private $y;

    //construtor da classe
    function __construct($dx,$dy)
    {
        $this->x = $dx;
        $this->y = $dy;
    }

    //métodos
    public function definirX($dx)
    {
        $this->x = $dx;
    }

    public function retornarX()
    {
        return $this->x;
    }

    public function definirY($dy)
    {
        $this->y = $dy;
    }

    public function retornarY()
    {
        return $this->y;
    }

    //destrutor da classe
    function __destruct()
    {
    }
}

Exemplo da classe Ponto implementada em linguagem de programação C++

class Ponto
{
    private:
        int x,y; //atributos

    public:

        //construtor da classe
        Ponto(int dx, int dy)
        {
            this->x = dx;
            this->y = dy;
        }

        //métodos
        void definirX(int dx)
        {
            this->x = dx;
        }

        int retornarX(void)
        {
            return this->x;
        }

        void definirY(int dy)
        {
            this->y = dy;
        }

        int retornarY(void)
        {
             return this->y;
        }

        //destrutor da classe
        ~Ponto(void)
        {
        }
}

Encapsulamento

O encapsulamento nos permite definir como os atributos e métodos de uma classe serão acessados. Para isso, existem limitadores quem permitem definir quem poderá acessar os tais.

Cada linguagem de programação possui os seus próprios limitadores acesso, mas os mais comuns são:
público (public) – o método ou atributo pode ser acessado por qualquer classe.
protegido (protected) – o método ou atributo pode ser acessado apenas pela própria classe ou classes herdeiras.
privado (private) – o método ou atributo pode ser acessado apenas pela própria classe.

Herança

Uma herança permite que uma classe herde os métodos e atributos públicos e protegidos de uma outra classe. Com isso, a classe herdeira é chamada de classe filho e a classe herdada é chamada de classe pai.

Exemplo de herança

Definiremos uma classe Circulo representada em um universo 2D, a mesma terá como atributos as coordenas x e y que definem onde o seu ponto central está localizado e o seu ráio.

Classe Circulo implementada em linguagem de programação PHP

class Circulo
{
    //atributos
    private $x;
    private $y;
    private $raio

    //construtor da classe
    function __construct()
    {
    }

    //métodos
    public function definirX($dx)
    {
        $this->x = $dx;
    }

    public function retornarX()
    {
        return $this->x;
    }

    public function definirY($dy)
    {
        $this->y = $dy;
    }

    public function retornarY()
    {
        return $this->y;
    }

    public function definirRaio($draio)
    {
        $this->raio = $draio;
    }

    public function retornarRaio()
    {
        return $this->raio;
    }

    //destrutor da classe
    function __destruct()
    {
    }

}

Classe Circulo implementada em linguagem de programação C++

class Circulo
{
    //atributos
    private:
        int x, y, raio;

    public:

        //construtor da classe
        Circulo()
        {
        }

        //métodos
        void definirX(int dx)
        {
            this->x = dx;
        }

        int retornarX(void)
        {
            return this->x;
        }

        void definirY(int dy)
        {
            this->y = dy;
        }

        int retornarY(void)
        {
             return this->y;
        }

        void definirRaio(int draio)
        {
            this->raio = draio;
        }

        int retornarRaio()
        {
            return this->raio;
        }

        //destrutor da classe
        ~Circulo()
        {
        }
}

Agora, com base na classe Circulo, criaremos uma segunda classe chamada Bola (classe filho).

Classe Bola implementada em linguagem de programação PHP

class Bola extends Circulo
{
    //atributo
    private $cor;

    //construtor da classe
    function __construct()
    {
        //chamando o construtor da classe pai (Circulo)
        parent::__construct();
    }

    //métodos
    public function definirCor($dcor)
    {
        $this->cor = $dcor;
    }

    public function retornarCor($dcor)
    {
        return $this->cor;
    }

    //destrutor da classe
    function __destruct()
    {
        //chamando o destrutor da classe pai (Circulo)
        parent::__destruct();
    }

}

Classe Bola implementada em linguagem de programação C++

class Bola : public Circulo
{
    //atributo
    private:
        char* cor;

    public:
        //construtor da classe
        Bola()
        {
        }

        //métodos
        void definirCor(char* dcor)
        {
            this->cor = new char[(sizeof(dcor) / sizeof(char))];
            strcpy(this->cor,dcor);
        }

        char* retornarCor()
        {
            return this->cor;
        }

        //destrutor da classe
        ~Bola()
        {
            if(this->cor)
                delete this->cor;
        }
}

Com isso, todos os métodos da classe pai estarão acessíveis pela classe filho. Veja o exemplo no código abaixo.

Linguagem de programação PHP

    $bola= new Bola();

    //métodos da classe circulo herdados pela classe bola
    $bola->definirX(10);
    $bola->definirY(15);
    $bola->definirRaio(10);

    //método da própria classe bola
    $bola->definirCor("Azul");

Linguagem de programação C++

    Bola *bola;
    bola = new Bola();

    //métodos da classe circulo herdados pela classe bola
    bola->definirX(10);
    bola->definirY(15);
    bola->definirRaio(10);

    //método da própria classe bola
    bola->definirCor("Azul");

Composição

Uma composição acontece quando uma classe A tem instanciada dentro dela um objeto (ou lista de objetos) de uma outra classe B, quando a classe A for destruída, os objetos da classe B instanciados dentro da classe A também serão destruídos.

Pensando sobre a definição de composição acima, um bom exemplo para esclarecer essa associação é construir uma classe para representar o nosso Universo 2D com 20 coordenada possíveis no eixo x e 20 coordenada possíveis no eixo y.

Classe Universo implementada em linguagem de programação PHP

class Universo
{
    private $pontos[20][20];

    //construtor da classe
    function __construct()
    {
        for($x = 0; $x < 20 ; $x++ )
        {
            for($y = 0 ; $y < 20 ; $y++)
                $this->pontos[$x][$y] = new Ponto($x,$y);
        }
    }

    public function retornarPonto($x ,$y)
    {
        return $this->pontos[$x][$y];
    }

    //destrutor da classe
    function __destruct()
    {
    }

};

Classe Universo implementada em linguagem de programação C++

class Universo
{
    private:
        Ponto* pontos[20][20];

    public:
        //construtor da classe
        Universo()
        {
            for(int x = 0; x < 20 ; x++ )
            {
                for(int y = 0 ; y < 20 ; y++)
                    this->pontos[x][y] = new Ponto(x,y);
            }
        }

        Ponto* retornarPonto(int x, int y)
        {
            return this->pontos[x][y];
        }

        //destrutor da classe
        ~Universo()
        {
        }
};

Com o código acima, é fácil visualizar que se o universo for destruído, todos os pontos pertencentes a ele também serão destruídos.

Agregação

Uma Agregação acontece quando uma classe A agrega dentro dela um objeto (ou lista de objetos) de uma outra classe B, quando a classe A for destruída, o objeto da classe B permanece intacto, ou seja, os objetos contidos podem existir sem serem parte do objeto que os contém.

Para demonstrar como funciona uma agregação, iremos fazer algumas modificações na classe Circulo

Classe Circulo implementada em linguagem de programação PHP

class Circulo
{
    //atributos
    private $ponto;
    private $raio

    //construtor da classe
    function __construct()
    {
    }

    //métodos
    public function definirPonto(Ponto $ponto)
    {
        $this->ponto = $ponto;
    }

    public function retornarPonto()
    {
        return $this->ponto;
    }

    public function definirRaio($draio)
    {
        $this->raio = $draio;
    }

    public function retornarRaio()
    {
        return $this->raio;
    }

    //destrutor da classe
    function __destruct()
    {
    }
}

Classe Circulo implementada em linguagem de programação C++

class Circulo
{
    //atributos
    private:
        Ponto* ponto;
        int raio;

    public:
        //construtor da classe
        Circulo()
        {
        }

        //métodos
        Ponto* retornarPonto(void)
        {
            return this->ponto;
        }

        void definirPonto(Ponto* ponto)
        {
            this->ponto = ponto;
        }

        void definirRaio(int draio)
        {
            this->raio = draio;
        }

        int retornarRaio()
        {
            return this->raio;
        }

        //destrutor da classe
        ~Circulo()
        {
        }
}

Finalmente, usando a classe Universo e a classe Circulo, poderemos dar um exemplo real de agregação.
Agregaremos um objeto classe Ponto pertencente ao Universo 2D dentro de uma instância da classe Circulo

Linguagem de programação PHP

    //instanciando os objetos
    $universo = new Universo();
    $circulo = new Circulo();

    //Configurando o raio e as coordenadas do ponto central do circulo
    $circulo->definirRaio(5);
    $circulo->definirPonto($universo->retornarPonto(10,10));

Linguagem de programação C++

    //definindo as variáveis
    Universo* universo;
    Circulo* circulo;

    //instanciando os objetos
    universo = new Universo();
    circulo = new Circulo();

    //Configurando o raio e as coordenadas do ponto central do circulo
    circulo->definirRaio(5);
    circulo->definirPonto(universo->retornarPonto(10,10));

Aqui está uma breve introdução à OOP (Object-oriented programming ou Programação Orientada a Objeto).
Qualquer dúvida ou sugestão, usem a parte de respostas no final do post.

Sobre o autor

Tarcísio

Bacharel em Engenharia da Computação, programador C / C++ , especialista em PHP, MySQL, PostgreSQL.

3 comentários

1 menção

  1. Allan

    Bom, valeu.

  2. charles

    Poderia ter colocado exemplos mais simples para aqueles que estão querendo aprender!

  3. Sonia da sSilva

    muitoooooooo fixe, ajudou-me bastante a compriender a função de cada elemento da POO..obrigado.

  1. Construindo uma classe em PHP para Banco de Dados | DigitalDev

    […] relacionados Classe, encapsulamento, herança, composição e agregação O que é PHP e qual é sua historia? Instalando o ambiente de desenvolvimento PHP (PHP 5.3.x + […]

Deixe uma dúvida, resposta ou sugestão