JavaScript orientado a objetos
Javascript no necesita presentación, sin embargo, para cumplir con el protocolo podemos recordar que es un lenguaje interpretado, basado en prototipos (sin clases o basado en instancias) cuyo estándar es defino por ECMAScript.
Javascript se considera un lenguaje de programación multiparadigma, esto quiere decir, que a pesar de sus particularidades puede moldearse a diferentes enfoques, como programación funcional, procedural, Reactiva e incluso orientado a objetos.
En mi caso particular escucho con frecuencia decir “JavaScript no es POO (programación orientada a objetos) es basada en prototipos” haciendo referencia a la distancia que guarda con lenguajes POO tradicionales como C++ o java. Esta y otras miles de afirmaciones que derivan en debates donde todos tienen la razón son comunes en el área.
Se procede a compartir a través de un ejemplo una propuesta de POO en javaScript, que puede ser adaptada a las necesidades de cada quien.
// Podemos ver las funciones como Clase/Constructor
function Guerrero(nombre,fuerza){
//Atributos, usamos la nomenclatura “_nombreVariable” para indicar que su objetivo es ser usada como variable privada,
this._nombre=nombre;
this._fuerza=fuerza;
// Métodos getter y setter
this.getNombre=function(){
return this._nombre;
}
this.getFuerza=function(){
return this._fuerza;
}
this.setNombre=function(nuevoNombre) {
this._nombre=nuevoNombre;
}
this.setFuerza=function(nuevaFuerza) {
this._fuerza=nuevaFuerza;
}
}
// Definimos los métodos públicos haciendo uso de prototype fuera de la clase
Guerrero.prototype.entrenar=function(){
console.log('Entrenando...');
this.setFuerza((this.getFuerza()+1));
}
//Atributo estáticos
Guerrero.SONIDO_DE_PELEA='BAM, BOOM, AHHH, POW, AAARGH';
//Método estático
Guerrero.presentar=function(Guerrero1,Guerrero2){
console.log('EL PROXIMO ENCUENTRO ES ENTRE EL PODEROSO '+Guerrero1+' Y EL GRAN '+Guerrero2);
}
//Metodo publico
Guerrero.prototype.calcularNivel= function(fuerza){
console.log('Calculando Nivel...');
if(fuerza >= 10){
console.log('Guerrero Digno');
}else{
console.log('sigue entrenando insecto');
}
}
//Creando una clase Hija
function Saiyajin(nombre,fuerza){
//llamamos al constructor de padre
Guerrero.prototype.constructor.call(this, nombre, fuerza);
// Aquí creamos los atributos y métodos getter y setter de la clase hija si se requieren
}
Saiyajin.prototype= new Guerrero(); // Indicamos la herencia
Saiyajin.prototype.constructor= Saiyajin; //actualizamos el constructor, dado que se perdió con la instrucción anterior
//Creando otra clase hija, necesitamos a otro guerrero
function Kryptoniano(nombre,fuerza){
Guerrero.prototype.constructor.call(this,nombre,fuerza);
}
Kryptoniano.prototype=new Guerrero();
Kryptoniano.prototype.constructor=Kryptoniano;
//Función autoejecutable para fines prácticos
(function CampoDeBatalla(){
//relación entre clases agregación/composición
var goku = new Saiyajin("kakaroto",20);
var superMan = new Kryptoniano ('Clark kent', 10);
//Polimorfismo
superMan.entrenar();
goku.entrenar();
//...
Guerrero.presentar(goku.getNombre(),superMan.getNombre());
//goku.atacar();
//superMan.atacar();
console.log(Guerrero.SONIDO_DE_PELEA);
} )();
Como se mencionó antes, este ejemplo es una propuesta que se puede adaptar y ajustar a criterio. Como ejercicio práctico puedes implementar métodos “defender” y “atacar” e incluso crear más guerreros para construir una batalla más interesante.
Si tienes inclinación por POO de seguro te interesara googlear un poco sobre las bondades que ofrece ECMAScript 6 en términos de legibilidad para el enfoque clásico de POO.