Clases en la Programación: ¡Construyendo los Cimientos de Tu Código!
¡Hola HaWker! Jeff Bruchado por aquí.
Este es un artículo más de nuestra serie de artículos que va a cubrir nuestro viaje para Aprender Programación desde Cero.
Bueno, las Clases en el mundo de la programación son como los personajes principales de una película, cada una con su propio conjunto de características y habilidades.
En JavaScript, una clase es como un molde para crear objetos. Es una manera de definir características (propiedades) y acciones (métodos) que un cierto tipo de objeto tendrá.
¿Por qué sumergirse en el mundo de las Clases es bueno?
- Organización: Clases ayudan a organizar tu código. Es como tener diferentes capítulos en un libro, cada uno contando una parte de la historia.
- Reutilización: Con clases, creas un modelo una vez y lo reutilizas para crear cuantos objetos quieras. Como hacer varias copias de una llave maestra.
- Herencia: Clases pueden heredar características de otras clases. Eso significa menos código repetido y una estructura más clara.
- Encapsulamiento: Clases permiten encapsular datos, lo que significa que puedes esconder detalles internos y mostrar apenas lo necesario para el uso externo.
Pero Jeff, ¿cómo funcionan las Clases en JavaScript?
Definición
Comienzas definiendo una clase con la palabra clave class, seguida del nombre de la clase. Dentro de ella, defines propiedades y métodos.
Constructor
Dentro de una clase, puedes tener un método especial llamado constructor. Este método es llamado cuando creas un nuevo objeto de la clase. O sea, siempre es llamado al instanciar una clase.
Instancia de Objetos
Después de definir una clase, puedes crear objetos (instancias) de esa clase usando la palabra clave new.
Herencia
Con extends, una clase puede heredar propiedades y métodos de otra clase. O sea, puedes crear clases y mezclarlas con otras clases.
Por ejemplo:
class Animal {
constructor(nombre) {
this.nombre = nombre;
}
hablar() {
console.log(`${this.nombre} hace un sonido.`);
}
}
class Perro extends Animal {
hablar() {
console.log(`${this.nombre} ladra.`);
}
}
let miPerro = new Perro('Rex');
miPerro.hablar(); // Rex ladra.En este ejemplo, Animal es una clase con un método hablar(). Perro es una subclase de Animal y tiene su propia versión del método hablar().
Entonces, mira:
Clases son como esqueletos que dan forma y función a los objetos en tu código. Son súper útiles para mantener todo organizado, reutilizable y fácil de mantener. Es como tener un conjunto de herramientas que personalizas para construir varias cosas diferentes, pero todas con la misma base.
¡Sensacional, verdad? Vamos a profundizar más a continuación.
Clases
Es una forma de definir un modelo para un objeto, en explicaciones más antiguas, básicamente es la abstracción de entidades del mundo real en el mundo virtual.
Es una forma de definir las propiedades y comportamientos (métodos) que un objeto debe tener, de manera que puedas crear varios objetos que son de la misma "categoría", con las mismas características.
A continuación un ejemplo de clase:
class Person {
constructor(name, age) {
this.name = name;
this.age = age;
}
greet() {
console.log(
`Hello, my name is ${this.name} and I am ${this.age} years old.`
);
}
}En este ejemplo, estamos creando una clase llamada "Person", que posee dos atributos (name y age) y un método (greet).
El método "constructor" es un método especial que es llamado cuando creas un nuevo objeto a partir de esa clase. O sea, ese método realizará la construcción de tu Object.
Para crear un nuevo objeto a partir de esa clase, puedes hacer así:
const person1 = new Person('Jefferson', 25);
const person2 = new Person('Lucas', 40);Con eso, puedes acceder a las propiedades y métodos de esos objetos de la siguiente forma:
console.log(person1.name); // Jefferson
console.log(person2.age); // 40
person1.greet(); // Hello, my name is Jeff and I am 25 years old.
person2.greet(); // Hello, my name is Lucas and I am 40 years old.Además del método "constructor" que ya mencioné, las clases también pueden tener otros métodos.
Por ejemplo:
class Person {
constructor(name, age) {
this.name = name;
this.age = age;
}
greet() {
console.log(
`Hello, my name is ${this.name} and I am ${this.age} years old.`
);
}
incrementAge() {
this.age += 1;
}
}
const person1 = new Person('Jefferson', 25);
person1.incrementAge();
console.log(person1.age); // 26En este ejemplo, creamos una clase "Person" con dos métodos: "greet" y "incrementAge". El método "incrementAge" incrementa la edad de la persona en 1.
Otra cosa importante a saber es que las clases son "constructores", o sea, puedes usarlas para crear nuevos objetos usando la palabra clave "new".
Por ejemplo:
const person1 = new Person('Jeff', 25);
const person2 = new Person('John', 40);Esos objetos creados a partir de la clase "Person" son llamados "instancias" de la clase.
Poseen todas las propiedades y métodos definidos en la clase, pero cada uno tiene sus propios valores para esas propiedades.
Además de eso, es posible crear nuevas clases que "extienden" otras clases.
Eso significa que la nueva clase tendrá todas las propiedades y métodos de la clase padre, y también puede tener propiedades y métodos adicionales.
Por ejemplo:
class Person {
constructor(name, age) {
this.name = name;
this.age = age;
}
greet() {
console.log(
`Hello, my name is ${this.name} and I am ${this.age} years old.`
);
}
incrementAge() {
this.age += 1;
}
}
class Student extends Person {
constructor(name, age, major) {
super(name, age); // llama el constructor de la clase padre
this.major = major;
}
study() {
console.log(`I am studying ${this.major}.`);
}
}
const student1 = new Student('Jeff', 25, 'Computer Science');
student1.greet(); // Hello, my name is Jeff and I am 25 years old.
student1.study(); // I am studying Computer Science.En este ejemplo, creamos una clase "Student" que extiende la clase "Person".
La clase "Student" tiene un nuevo atributo (major) y un nuevo método (study).
En el constructor de la clase "Student", llamamos el constructor de la clase padre usando la palabra clave "super".
Bueno, anteriormente mencioné la palabra super, y a continuación vamos a entender más detalladamente cómo el super funciona.
Super
El "super" es una palabra clave usada dentro de una clase que extiende otra clase (o sea, que es una "subclase").
Se refiere al constructor de la clase padre (o "superclase").
Cuando creas una subclase, es común que tenga un constructor propio, que debe llamar el constructor de la clase padre para inicializar las propiedades de la subclase.
Para hacer eso, puedes usar el "super" como un método, pasando los argumentos necesarios.
Por ejemplo:
class Person {
constructor(name, age) {
this.name = name;
this.age = age;
}
greet() {
console.log(
`Hello, my name is ${this.name} and I am ${this.age} years old.`
);
}
}
class Student extends Person {
constructor(name, age, major) {
super(name, age); // llama el constructor de la clase padre
this.major = major;
}
study() {
console.log(`I am studying ${this.major}.`);
}
}
const student1 = new Student('Jeff', 25, 'Computer Science');
student1.greet(); // Hello, my name is Jeff and I am 25 years old.
student1.study(); // I am studying Computer Science.En este ejemplo, la clase "Student" extiende la clase "Person".
En el constructor de la clase "Student", llamamos el constructor de la clase padre usando "super(name, age)".
Eso inicializa las propiedades "name" y "age" de la subclase.
Además de ser usado en el constructor de una subclase, "super" también puede ser usado para acceder a métodos de la clase padre.
Por ejemplo:
class Person {
constructor(name) {
this.name = name;
}
greet() {
console.log(`Hello, my name is ${this.name}.`);
}
}
class FriendlyPerson extends Person {
greet() {
super.greet(); // llama el método greet de la clase padre
console.log("It's nice to meet you!");
}
}
const friendlyPerson1 = new FriendlyPerson('Jeff');
friendlyPerson1.greet();
// Output:
// Hello, my name is Jeff.
// It's nice to meet you!En este ejemplo, la clase "FriendlyPerson" extiende la clase "Person" y tiene un método "greet" propio.
Sin embargo, el método "greet" de la clase "FriendlyPerson" también llama el método "greet" de la clase padre usando "super.greet()".
Eso permite que la clase "FriendlyPerson" herede el comportamiento del método "greet" de la clase padre (Person) y añade más un comportamiento a él.
Además de ser usado en el constructor y en los métodos de una subclase, "super" también puede ser usado para acceder a propiedades de la clase padre.
Por ejemplo:
class Person {
constructor(name) {
this.name = name;
}
}
class Student extends Person {
constructor(name, major) {
super(name);
this.major = major;
}
getDescription() {
return `${super.name} is studying ${this.major}.`;
}
}
const student1 = new Student('Jeff', 'Computer Science');
console.log(student1.getDescription()); // Jeff is studying Computer Science.En este ejemplo, la clase "Student" extiende la clase "Person" y tiene un método "getDescription" que retorna una string con el nombre y la major del estudiante.
En el método "getDescription", usamos "super.name" para acceder a la propiedad "name" de la clase padre.
Conclusión
En resumen, las clases son una herramienta poderosa para el desarrollo porque permiten que crees objetos que poseen propiedades y métodos.
Proporcionan una manera de organizar y estructurar tu código de manera más clara y fácil de entender. Además de eso, las clases también permiten que crees herencia, lo que significa que puedes crear nuevas clases basadas en clases existentes, compartiendo sus propiedades y métodos.
💡El conocimiento sobre clases es importante porque puede ayudar a hacer tu código más organizado y fácil de entender.
Pues bien HaWker, llegamos al fin de un artículo más.
Como siempre, si tienes cualquier duda o quieres explorar más algún punto, simplemente responde con tu duda, en este email.
¡Y recuerda, estoy aquí para ayudarte a mejorar 1% con cada nuevo artículo!
Si llegaste hasta aquí, como de costumbre, por favor, responde este email con "Conseguí entender las Clases en la Programación".
De esta forma voy a saber que esta serie de artículos está siendo útil para ti, y que estás acompañando y aprovechando.
¡Como ya sabes! Solamente un verdadero HaWker llega hasta el final.
¡Felicitaciones!
Estoy feliz de tenerte aquí.
Te veo pronto.
¡Vamos a por ello! 🦅
- Jeff Bruchado.
Cuando sientas que es el momento existen 2 maneras en que puedo ayudarte:
01) Aprendiendo JavaScript desde Cero: Conviértete en un programador de valor y aprende a programar usando JavaScript, con un contenido organizado y condensado pensado en lo que realmente importa que aprendas. El contenido posee todos los artículos que vengo poniendo a disposición semanalmente para ti, y también posee ejercicios prácticos, con las respuestas para que aprendas la teoría y ya salgas poniendo manos a la obra.
02) Consultoría: Forma parte de mi mentoría y ten clases directamente conmigo. Si te interesa, responde este email con "Tengo interés en la mentoría."
¡Felicitaciones por llegar hasta aquí, HaWker! 🎉
En este momento que aprendiste sobre clases en la programación, ¿qué tal testear tus conocimientos? Participa del quiz abajo y ve cuánto absorbiste de nuestro artículo.
Es una excelente manera de fijar el aprendizaje y prepararte para los próximos pasos en tu viaje de programación.
Presiona para acceder al quiz.
¡Buena suerte y diviértete!