Uma linguagem que poucos sabem abordar a nível de Programação Orientada a Objectos (OOP – Oriented Object Programming) é o JavaScript e por isso pretendo fazer uma breve abordagem a este tema. Não irei fazer uma introdução sobre o que é a Programação Orientada a Objectos por isso é aconselhável que o leitor tenha as noções bases de utilização desta técnica, bem como que tenha uma noção básica da linguagem de programação abordada.
A linguagem JavaScript tem um estilo bastante particular no que toca a Programação Orientada a Objectos, não é uma sintaxe dificil de aprender mas comporta-se de forma diferente do que os programadores de linguagens compiladas como o Java ou o C++ estão habituados.
Isto porque o JavaScript não é uma Linguagem Orientada a Objectos completamente desenvolvida mas sim uma linguagem estruturada, e não estão implementados alguns conceitos classes e instâncias mas existem objectos, protótipo e herança implicita bem como variáveis públicas e privadas.
O JavaScript suporta variáveis / funções privadas declaradas usando a palavra reservada var. Propriedades publicas e métodos “priveligiados” são declarados utilizando a expressão this
Métodos “priveligiados” podem aceder variáveis / funções privadas que não estão acessíveis fora da classe.
Herança Através de Funções
Como o JavaScript não suporta tem um operador de herança explicitado esta pode ser implementada de duas maneiras. A primeira maneira para criar um objecto como uma subclass de outro objecto é chamar o constructor de uma “Super Classe” dentro da sub classe. Vejamos o seguinte.
function superClasse() {
this.adeus = superAdeus;
this.ola = superOla;
}
function subClasse() {
this.inheritFrom = superClasse;
this.inheritFrom();
this.adeus = subAdeus;
}
function superOla() {
return "Super Classe diz-lhe: Olá";
}
function superAdeus() {
return "Super Classe diz-lhe: Adeus";
}
function subAdeus() {
return "Sub Classe diz-lhe: Até já (TMN pubber)";
}
Clique aqui para invocar o seguinte trecho de código que é um PoC (Proof of Concept) do que vimos anteriormente.
function mostraSubClasse() {
var novaClass = new subClasse();
alert(novaClass.adeus());
alert(novaClass.ola());
}
Explicando tudo o que se passou até agora.
Temos na função superClasse declarada uma classe (termo não técnico, não confundir com as classes do C++, Java, PHP, etc.) em que através da palavra reservada this definimos dois métodos: o adeus e o ola e lhes atribuimos uma acção a cada um através de uma função, a superAdeus e a superOla, respectivamente. De seguida, definiu-se a classe subClasse que vai herdar os métodos da superClasse através do método inheritFrom [(this.inheritFrom = superClasse -> define) (this.inheritFrom() -> herda)] e define-se o método adeus.
Como se pode reparar no PoC o nosso código apenas retorna um ola e um adeus. Isto dá-se porque ao definirmos o método adeus na subClasse, estamos a anular o método adeus definido primeiramente na superClasse. Para não restarem dúvidas:
function sprClasse() {
this.teste = alert("A definir o método teste na Super Classe");
}
function sbClasse() {
this.inheritFrom = sprClasse;
this.inheritFrom();
this.teste = alert("A reescrever o método teste na Sub Classe");
}
Testar a re-escrita dos métodos aqui.
function ExReescrita() {
var nClasse = new sbClasse();
}
Como foi possível reparar com os JavaScript Alert existe a escrita primeiramente do método teste na super classe e posteriormente esta é reescrita na sub classe ficando assim acessível o método da sub classe.
Existe um outro método, mais sólido, para estabelecer a hierarquia de classes. Este método, funciona criando um objecto da super classe e de seguida usá-lo como um protótipo do objecto da sub classe. Supondo que a ssoa super classe se chama superClasse (original não?) o protótipo será da sub classe será algo como isto:
subClasse.prototype = new superClasse;
Usando o mesmo exemplo que utilizamos acima substituindo apenas a forma que usamos para a herança temos o seguinte código que se irá comportar da mesma forma que o exemplo anterior.
function superClasse() {
this.adeus = superAdeus;
this.ola = superOla;
}
function subClasse() {
this.adeus = subAdeus;
}
subClasse.prototype = new superClasse;
function superOla() {
return "Super Classe diz-lhe: Olá";
}
function superAdeus() {
return "Super Classe diz-lhe: Adeus";
}
function subAdeus() {
return "Sub Classe diz-lhe: Até já (TMN pubber)";
}
function teste() {
var novaClass = new subClasse();
alert(novaClass.adeus());
alert(novaClass.ola());
}
Vejamos então como se comportam estas classes aqui.
—
Hoje vimos como funciona a herança de classes em JavaScript, mas a POO em JavaScript não fica por aqui, escreverei uma série de posts relativos a este tema abordando, encapsulamento, uma simulação do instance of, propriedades estáticas, etc. mostrarei também exemplos mais concretos, exemplos práticos de cada caso para não termos apenas a teoria com adeus, olá, entre outros.
Para estarem actualizados de novos postos podem subscrever ao RSS Feed. E para não variar, comentários agradecem-se. Até à próxima.
1 comment