Programación Orientada a Objetos en JS

1class Coche {
2    constructor(marca, modelo, año) {
3        this.marca = marca;
4        this.modelo = modelo;
5        this.año = año;
6        this.kilometraje = 0; // Valor por defecto
7    }
8}
9 
10// Crear instancias
11const miCoche = new Coche("Toyota", "Corolla", 2023);
12console.log(miCoche.marca); // "Toyota"
13console.log(miCoche.kilometraje); // 0

1class Persona {
2    constructor(nombre, edad) {
3        this._nombre = nombre;
4        this._edad = edad;
5    }
6 
7    // Getter - se usa como propiedad, no como método
8    get nombre() {
9        return this._nombre.toUpperCase();
10    }
11 
12    // Setter con validación
13    set edad(valor) {
14        if (valor < 0) {
15            console.log("❌ La edad no puede ser negativa");
16            return;
17        }
18        if (valor > 150) {
19            console.log("❌ La edad no es realista");
20            return;
21        }
22        this._edad = valor;
23    }
24 
25    get edad() {
26        return this._edad;
27    }
28 
29    // Propiedad computada (solo getter)
30    get mayorDeEdad() {
31        return this._edad >= 18;
32    }
33}
34 
35const juan = new Persona("Juan", 25);
36 
37// Usar getters (SIN paréntesis)
38console.log(juan.nombre);        // "JUAN"
39console.log(juan.mayorDeEdad);   // true
40 
41// Usar setters (como asignación)
42juan.edad = 30;                  // ✅ Válido
43juan.edad = -5;                  // ❌ Error: edad negativa

1class CuentaBancaria {
2    constructor(titular, saldoInicial = 0) {
3        this.titular = titular;
4        this._saldo = saldoInicial;
5    }
6 
7    // Métodos
8    depositar(cantidad) {
9        if (cantidad <= 0) {
10            console.log("❌ La cantidad debe ser positiva");
11            return false;
12        }
13        this._saldo += cantidad;
14        console.log(`✅ Depósito: $${cantidad}. Nuevo saldo: $${this._saldo}`);
15        return true;
16    }
17 
18    retirar(cantidad) {
19        if (cantidad > this._saldo) {
20            console.log("❌ Saldo insuficiente");
21            return false;
22        }
23        this._saldo -= cantidad;
24        console.log(`✅ Retiro: $${cantidad}. Nuevo saldo: $${this._saldo}`);
25        return true;
26    }
27 
28    get saldo() {
29        return this._saldo;
30    }
31 
32    mostrarInfo() {
33        console.log(`Titular: ${this.titular}, Saldo: $${this._saldo}`);
34    }
35}
36 
37const cuenta = new CuentaBancaria("Ana García", 1000);
38cuenta.depositar(500);    // ✅ Depósito: $500. Nuevo saldo: $1500
39cuenta.retirar(200);      // ✅ Retiro: $200. Nuevo saldo: $1300
40cuenta.mostrarInfo();     // Titular: Ana García, Saldo: $1300

1class Contador {
2    constructor() {
3        this.count = 0;
4    }
5 
6    incrementar() {
7        this.count++;
8        console.log(`Count: ${this.count}`);
9    }
10 
11    mostrarValor() {
12        console.log(`Valor actual: ${this.count}`);
13    }
14}
15 
16const c = new Contador();
17 
18// ✅ Llamada directa - this funciona correctamente
19c.incrementar();        // Count: 1
20c.mostrarValor();       // Valor actual: 1
21 
22// ✅ Múltiples llamadas - this siempre apunta a 'c'
23c.incrementar();        // Count: 2
24c.incrementar();        // Count: 3

1class Temporizador {
2    constructor(nombre) {
3        this.nombre = nombre;
4    }
5 
6    saludar() {
7        console.log(`¡Hola! Soy ${this.nombre}`);
8    }
9}
10 
11const temp = new Temporizador("Ana");
12 
13// ✅ Llamada directa funciona
14temp.saludar();   // "¡Hola! Soy Ana"
15 
16// ❌ Pasar el método como callback - PIERDE el contexto
17setTimeout(temp.saludar, 1000);
18// ❌ ERROR: Cannot read property 'nombre' of undefined
19// Razón: this es undefined, no apunta a 'temp'
20 
21// ❌ Asignar método a variable - PIERDE el contexto
22const funcionSaludo = temp.saludar;
23funcionSaludo();
24// ❌ ERROR: Cannot read property 'nombre' of undefined

1class Matematicas {
2    // Método estático
3    static sumar(a, b) {
4        return a + b;
5    }
6 
7    static factorial(n) {
8        if (n <= 1) return 1;
9        return n * this.factorial(n - 1);
10    }
11 
12    // Constante estática
13    static PI = 3.14159;
14}
15 
16// Usar métodos estáticos (sobre la clase, NO sobre instancias)
17console.log(Matematicas.sumar(5, 3));        // 8
18console.log(Matematicas.factorial(5));       // 120
19console.log(Matematicas.PI);                 // 3.14159
20 
21// ❌ ERROR: No puedes llamar métodos estáticos desde instancias
22const mat = new Matematicas();
23// mat.sumar(2, 3); // ❌ Esto dará error

1// Clase padre
2class Animal {
3    constructor(nombre) {
4        this.nombre = nombre;
5    }
6 
7    hacerSonido() {
8        console.log(`${this.nombre} hace un sonido`);
9    }
10}
11 
12// Clase hija
13class Perro extends Animal {
14    constructor(nombre, raza) {
15        super(nombre);  // Llama al constructor del padre
16        this.raza = raza;
17    }
18 
19    // Sobrescribir método
20    hacerSonido() {
21        console.log(`${this.nombre} ladra: ¡Guau guau!`);
22    }
23 
24    // Método propio
25    mostrarRaza() {
26        console.log(`${this.nombre} es un ${this.raza}`);
27    }
28}
29 
30const miPerro = new Perro("Rex", "Labrador");
31miPerro.hacerSonido();    // Rex ladra: ¡Guau guau!
32miPerro.mostrarRaza();    // Rex es un Labrador