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.
4 comentários
1 menção
Pular para o formulário de comentário
Bom, valeu.
Poderia ter colocado exemplos mais simples para aqueles que estão querendo aprender!
muitoooooooo fixe, ajudou-me bastante a compriender a função de cada elemento da POO..obrigado.
Dá pra ver que veio de outra linguagem. Usa muito o ponteiro “this” no C++.
[…] 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 + […]