JavaScript OOP #1

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.