JavaScript - Programação orientada a objetos

Introdução

A linguagem JavaScript, geralmente, é usada de forma procedural, alguns provavelmente acreditam que essa seja a única forma (paradigma) possível, mas também, podemos programar de forma orientada a objetos (OO) em JavaScript.

A programação OO em JavaScript é um pouco diferente do que estamos acostumados. Diferente de Java, PHP, Ruby e outras, JavaScript não têm uma definição para uma classe, mas possui um recurso chamado Prototype (não confundir com o Framework), que podemos utilizar para programar de forma OO.

Vamos a um exemplo simples. Vou criar uma "classe" Pessoa. Pode parecer estranho, mas acredite, podemos escrever uma "classe" desse jeito:

function Pessoa( nome, idade ) {
 
    this.nome = nome;
    this.idade = idade;
 
    this.digaOi = function() {
 
        alert( "oi" );
    }
}

Sim, você deve ter percebido que isso é uma função, mas podemos criar uma instância dela através do operador new (como nas outras linguagens) e simular uma classe, assim:

var eu = new Pessoa( "paulo", "28" ); 

E agora, que temos uma instância de "Pessoa", podemos ter acesso aos atributos e métodos de um jeito bem intuitivo:

alert( eu.nome );
eu.digaOi();

Com isso já temos uma "classe" e um objeto.

Encapsulamento

O encapsulamento é um do principais pontos da programação orientada a objetos (OO).Basicamente, encapsular significa separar um programa em partes, protegendo o acesso direto aos atributos de uma classe.

Para isso, geralmente, são utilizados modificadores de acesso e métodos específicos para a manipulação destes atributos (set / get).

Em JavaScript não temos estes modificadores de acesso, mas podemos criar encapsulamento assim:

function Objeto() {
 
    var atributoPrivado;
 
    this.setAtributoPrivado = setAtributoPrivado;
    this.getAtributoPrivado = getAtributoPrivado;
 
    function setAtributoPrivado( valor ) {
 
        atributoPrivado = valor;
    }
 
    function getAtributoPrivado() {
 
        return atributoPrivado;
    }
}
 
var objeto = new Objeto();
 
objeto.setAtributoPrivado( "teste" );
 
alert( objeto.getAtributoPrivado() );

Neste exemplo, usei "var" e "this" para simular os modificadores de acesso privado e público.

Com isso já podemos considerar nosso código encapsulado.

Herança

Herança é a habilidade de uma classe reutilizar (herdar) as características (atributos) e comportamentos (métodos) de outra. A herança é geralmente caracterizada usando a relação "é um".

Exemplo: Cachorro é um Animal

Cachorro herda as características e comportamentos de um animal.

Vejamos um exemplo sobre como usar herança em JavaScript. Primeiro criamos duas "classes" (super e sub-classe):

function VeiculoTerrestre() {
 
    this.andar = function() {
 
        alert("andando");
    }
 
    this.parar = function() {
 
        alert("parando");
    }
}
 
function Carro() {
 
    this.ligarFarois = function() {
 
        alert("ligando os farois");
    }
}

Carro é um VeiculoTerrestre - Por isso é interessante herdar as características e comportamentos de VeiculoTerrestre em Carro.

JavaScript não implementa uma palavra chave (extends) para indicar que uma classe herda de outra, mas podemos utilizar herança através do prototype assim:

Carro.prototype = new VeiculoTerrestre;
 
var carro = new Carro();

carro.andar();
carro.parar();
carro.ligarFarois();

Neste exemplo, usamos o prototype para criar a herança entre as "classes" VeiculoTerreste e Carro.

O prototype é propriedade que nos permite adicionar características e comportamentos para as "classes", após sua definição, assim podemos reutilizar toda a definição de uma classe em outra.

Mais do prototype

Utilizamos o prototype para criar herança colocando as funcionalidades de "VeiculoTerrestre" em "Carro". O que pode ter passado desapercebido, é que através do prototype podemos criar novas características para as "classes" já definidas pelo JavaScript.

Como exemplo, vamos colocar um novo método na "classe" String do JavaScript.

Geralmente, usamos a função parseInt para converter String para inteiros, vamos deixar essa conversão mais OO (Orientada a Objetos), colocando um método parseInt em String, assim:

String.prototype.parseInt = function() {
 
    return parseInt( this );
}
 
alert( "10".parseInt() )

É um exemplo simples (talvez inútil), mas a ideia é essa...

Conclusão

Termino esse artigo por aqui. Espero que seja útil. Qualquer correção, dúvida ou sugestão, basta comentar. Paulo Dias | blog: http://blog.prmsistemas.com/