Clases y POO

Forja soporta programación orientada a objetos con clases, constructores, métodos y el keyword este (equivalente a self en Rust o this en otros lenguajes).

Estructura de una clase

🧱 Plantilla

clase Nombre {
    campo1
    campo2

    constructor(param1, param2) {
        este.campo1 = param1
        este.campo2 = param2
    }

    funcion metodo() {
        // usar este.campo
    }
}

Ejemplo completo

Una clase Estudiante con campos, constructor y métodos:

🎓 Clase Estudiante

clase Estudiante {
    nombre
    edad

    constructor(n, e) {
        este.nombre = n
        este.edad = e
    }

    funcion presentarse() {
        escribir("Hola, soy " + este.nombre +
                " y tengo " + este.edad + " años")
    }

    funcion esMayorDeEdad() -> Booleano {
        retornar este.edad >= 18
    }
}

// Uso
variable alumno = nuevo Estudiante("Ana", 20)
alumno.presentarse()
// → Hola, soy Ana y tengo 20 años

si (alumno.esMayorDeEdad()) {
    escribir("Es mayor de edad")
}

Keyword `este`

este se refiere a la instancia actual. Se usa para acceder a campos y métodos propios desde adentro de la clase:

Forja	Rust / Otros
`este.nombre`	`self.nombre` / `this.nombre`
`este.edad = 10`	`self.edad = 10`

Keyword `nuevo`

Instancia una clase y (si existe) llama al constructor automáticamente:

🚀 Instanciación posicional

variable p = nuevo Persona("Juan")    // con constructor posicional
variable q = nuevo Punto()               // sin constructor

Inicialización struct-literal

Podés inicializar objetos usando llaves con nombres de campo, sin necesidad de definir un constructor posicional:

🏗️ Struct-literal

clase Persona {
    nombre
    edad
}

// Inicialización con llaves y nombres de campo
variable p = nuevo Persona { nombre: "Ana", edad: 25 }
escribir(p.nombre) // → "Ana"
escribir(p.edad)   // → 25

💡 La sintaxis struct-literal nuevo Clase { campo: valor } es especialmente útil cuando la clase tiene muchos campos. El orden de los campos no importa y el código resulta más legible.

Clase sin constructor

Si no definís un constructor, los campos se inicializan con nulo:

📍 Punto 2D

clase Punto {
    x
    y
}

variable p = nuevo Punto()
escribir(p.x)  // → nulo (no inicializado)

Traits e interfaces

Las clases pueden implementar rasgos (interfaces) con rasgo e implementa:

🧬 Rasgo + Clase

rasgo Volador {
    funcion volar() -> Texto
}

clase Pajaro {
    nombre
    constructor(n) { este.nombre = n }
}

implementa Volador para Pajaro {
    funcion volar() -> Texto {
        retornar este.nombre + " vuela"
    }
}

💡 Los rasgos se definen con rasgo y se implementan con implementa ... para. Son equivalentes a trait e impl ... for en Rust.

Equivalencia con Rust

Forja	Rust generado
`clase X { ... }`	`struct X { ... }` + `impl X { ... }`
`constructor(p) { ... }`	`fn nuevo(p: String) -> Self { ... }`
`este.campo`	`self.campo`
`nuevo X(args)`	`X::nuevo(args)`
`nuevo X { campo: val }`	`X { campo: val }`
`objeto.metodo()`	`objeto.metodo()`