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 classes para definir(moldar) os objetos. Apesar disso, podemos programar orientado a objetos de varias formas diferentes, Vejamos um exemplo de como criar( simular ) uma classe:

 

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

Sim, 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", "25" );

Agora que temos uma instância de "Pessoa", podemos ter acesso aos atributos e métodos, veja:

 

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

Já temos um inicio para programar de forma OO em JavaScript, mas ainda falta implamentar encapsulamento e herança... primeiro vejamos como criar o 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; 

    /* criando metodos de acesso ( metodos publicos ) */
    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() );

Básicamente quando é usado o "var" e "this" dentro de uma classe/função estamos usando respectivamente os modificadores de acesso privado e público (ainda não encontrei uma boa ideia para simular o protegido).

Com isso já podemos considerar nosso código encapsulado. Agora vamos implementar herança em JavaScript.

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: carro é um veiculo

Carro herda as características e comportamentos de um veiculo. 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.

Algo interessante é que também podemos criar novas características para as "classes" 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, colocando um método parseInt em String, assim:

 


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

Foi apenas uma introdução, mas a idéia é essa... ;)