A programação orientada a objetos facilita, e muito, a vida do desenvolvedor. Podemos utilizar o mesmo código em vários lugares, para diferentes situações, modificando e estendendo apenas o que for necessário, sem precisar reescrever código. A Mootools, além de todas as outras funcionalidades, contém um sistema de criação de classes muito bem-pensado. Vamos ver como escrever classes utilizando esse sistema, assim como extendê-las e herdá-las.

Por que Classes?

Classes têm algumas vantagens sobre funções independentes. Podemos modificar e reusar suas funcionalidades sem precisar modificar o código original, criar objetos que armazenam informações dentro de seu próprio escopo e também utilizar métodos relacionados ao objeto. Além disso, com classes é possível utilizar menos código em mais situações.

Um bom exemplo da implementação de classes é a própria Mootools. Boa parte do que há na biblioteca é baseado em classes, estendendo-as, modificando-as e herdando-as. Funções não são muito utilizadas pela Mootools, pois o poder da utilização das classes é muito maior.

Definindo Classes

Para definir classes com a Mootools, utilizamos o construtor Class. O construtor leva como parâmetros os métodos e atributos da classe, através de uma literal de objeto.

var Vehicle = new Class({
	"initialize": function(features) {
		// Salvando as características no escopo do objeto
		this.features = features;
		this.position = 0;
	},
	"goForward": function(distance) {
		this.position += distance;
	},
	"goBackward": function(distance) {
		this.position -= distance;
	}
});

Na classe acima, definimos três métodos: initialize, goForward e goBackward. O método initialize deve estar presente em cada definição de classe, por ser o método que é chamado quando a classe é instanciada.

Após termos criado nossa classe, podemos instanciá-la sempre que necessário.

var myVehicle = new Vehicle({"color": "red"});
// Utilizando os métodos do objeto
myVehicle.goForward(100);
// Acessando propriedades
myVehicle.position; // 100

Estendendo Classes

Como em outras linguagens orientadas a objeto, as classes podem ser estendidas para criar funcionalidades mais específicas. No caso da classe Vehicle, podemos estendê-la para criar tipos de veículos específicos, como carros e motos. Para isso, usamos o método Class.extend, levando como parâmetro os novos métodos e propriedades que a classe deve conter.

var Car = Vehicle.extend({
	// O novo método de inicialização
	"initialize": function(features) {
		// Inicializamos a classe pai dentro da classe atual
		this.parent(features);
		this.wheels = 4;
		this.gear = 0;
	},
	"gearUp": function() {
		if(this.gear < this.features.gears) this.gear++;
	},
	"gearDown": function() {
		if(this.gear > -1) this.gear--;
	}
});
var Motorcycle = Vehicle.extend({
	"initialize": function(features) {
		this.parent(features);
		this.wheels = 2;
		this.gear = 0;
	},
	"gearUp": function() {
		if(this.gear < this.features.gears) this.gear++;
	},
	"gearDown": function() {
		if(this.gear > 0) this.gear--;
	}
});

Através do código acima, criamos duas novas classes baseadas em Vehicle, Car e Motorcycle, cada uma com suas características específicas, mas herdando os métodos da classe pai.

Assim como podemos criar tipos específicos de veículos, também podemos criar tipos específicos de carros e motos, bastando estender essas duas classes. Não há limite para extensões.

Além de estender outras classes, também é possível estender a própria classe, implementando novos métodos. Note que não é necessário recriar o método Class.initialize, já que não o modificamos, apesar de ser possível se necessário.

var Car = Car.extend({
	"horn": function() {
		this.soundHorn = true;
	}
});

Implementando Novos Métodos

Ao estender classes, o método Class.extend cria uma nova cópia da classe, não alterando-a de maneira alguma. Isso é facilmente percebido, já que, em nosso exemplo, myVehicle.gearUp não funciona, pois a classe não foi modificada quando criamos as outras extensões.

Para modificar a classe sem criar uma cópia sua e sem precisar modificar código algum, a Mootools usa o método Class.implement, recebendo como parâmetros os métodos e propriedades a serem implementados.

Modificando o último exemplo, poderíamos trocar Car.extend para Car.implement, eliminando a cópia desnecessária que criamos.

Car.implement({
	"horn": function() {
		this.soundHorn = true;
	}
});

Vale lembrar que utilizando Class.implement não temos acesso ao método this.parent, já que não estamos criando uma outra classe, somente implementando propriedades. Nesse caso, não há classe pai.

O uso de classes permite muito mais do que reutilização de código. Poupa-se tempo tanto no desenvolvimento quanto no uso do código e esse uso torna-se muito mais intuitivo, já que aproxima a programação de objetos reais. Por essas e outras que sou adepto dessa maravilhosa biblioteca. Até a próxima!