No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Organización

19/24
Recursos

Aportes 7

Preguntas 0

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

Clase 19: Organización

  • Variables → Son conocidas como propiedades en el mundo POO → son todos esos elementos donde vamos a guardar información.
  • Constantes → Son todos esos elementos que no van a cambiar su valor, también son conocidas como propiedades
  • Variables estáticas → Son elementos que pueden o no estar en la clase.
  • Métodos → Tus métodos son tus funciones, solo que en POO se le reconoce así, no olvides que dentro de una clase los métodos deben ser ordenados de mayor importancia a menor importancia. Lo ordenas de la siguiente manera, creas una clase y esta clase tiene un método funcional y los otros métodos que se crean es para apoyar el primer método.
  • Funciones estáticas → se le dicen estáticas, ya que estas no deben ser heredadas a otra clase, solo se usan en la clase principal.
  • Getters y setters → Estas permiten alterar y obtener alguna propiedad de tu clase. Recuerda esto se usa para no poder acceder directamente a la propiedad JS si lo permite, pero NO es buena práctica.

Organización de clases

  • Variables
  • Constantes
  • Variables estáticas
  • Métodos
  • Funciones estáticas
  • Getters y setters

Porque tener setter y getters

Los setters y getters son funciones para asignar y devolver un valor. Por ejemplo ten en cuenta los siguientes ejemplos

// SIN gettes y setters ❌
class Person {
  constructor(name) {
    this.name = name
  }
}
const irving = new Person("irving")
irving.name = "Irvong" // asignando propiedad
console.log(irving.name) // accediendo

// CON getters y setters ✔️
class Person {
  constructor(name) {
    this._name = name
  }

  get name(){
    return this._name
  }

  set name(newValue){
    this._name = newValue
  }
}
const irving = new Person("irving")
irving.name = "Irvong" // asignando propiedad
console.log(irving.name) // accediendo

Estas dos classes hacen los mismo, asignan y retornan propiedad. Suena un poco como a lo mismo, no? Porque usar setters y getters entonces?
.
Ahí esta el asunto, con los getters y setters nosotros podemos crear ciertas validaciones. Por ejemplo, para asignar el valor a irving.name = 4, nosotros podemos validar que el nuevo valor sea de tipo string. Con los setters se puede lograr, mientras que sin ellos, no es posible.
.
Lo mismo aplica para los getters. Lo que se esta haciendo es un proxy, o una capa de validación para ver si el dato que se quiere entregar o asignar puede ejecutar esa acción de acuerdo a diversas validaciones o contextos

Las variables estáticas son variables en programación que mantienen su valor durante toda la vida útil del programa y se pueden compartir entre diferentes partes del código, como por ejemplo entre diferentes funciones o instancias de una clase.

Los getters y setters son métodos que te permiten acceder y modificar las propiedades de un objeto de manera controlada. Los getters te permiten obtener el valor de una propiedad, mientras que los setters te permiten modificar su valor.

Para definir un getter o un setter, se utiliza la sintaxis de métodos de acceso, que es muy similar a la de los métodos normales, pero con la palabra clave “get” o “set” antes del nombre del método.

Los getters y setters son útiles para agregar validaciones y restricciones antes de obtener o modificar una propiedad, lo que te permite mantener un mayor control sobre los datos que manejas.

* Constantes → Las constantes (estáticas y finales) deben colocarse al inicio de la clase, antes de cualquier otra variable o método. Esto hace que sean fácilmente localizables, ya que suelen representar configuraciones o valores inmutables importantes para la clase. * Variables de instancia → Las variables de instancia (no estáticas) deberían venir después de las constantes. Ayuda a saber cuáles son los datos que la instancia de esta clase manejará. * Variables estáticas → Las variables estáticas (no constantes) pueden ir después de las variables de instancia. Colocarlas aquí aclara que pertenecen a la clase en lugar de a las instancias individuales. * Constructor → El constructor debe ir después de las variables, ya que permite inicializar el estado de la clase y es uno de los elementos más relevantes para entender cómo se configura una instancia. * Métodos estáticos → Los métodos estáticos deben ir después del constructor. Esto da claridad sobre las utilidades relacionadas con la clase que no requieren una instancia específica. * Métodos públicos → Los métodos públicos de la clase son las funcionalidades principales que expone la clase. Al colocarlos después del constructor y métodos estáticos, el lector puede ver directamente las operaciones que puede realizar una instancia de la clase. * Getters y setters → Aunque los getters y setters son métodos públicos, suelen colocarse juntos después de los demás métodos públicos para no interrumpir la lectura de las operaciones principales de la clase. * Métodos privados → Finalmente, los métodos privados deben ir al final de la clase, ya que son detalles de implementación interna y no están destinados a ser utilizados fuera de la clase. ```js public class MiClase { // Constantes private static final int CONSTANTE = 100; // Variables de instancia private int variableInstancia; // Variables estáticas private static int contador; // Constructor public MiClase(int valor) { this.variableInstancia = valor; } // Métodos estáticos public static void metodoEstatico() { // lógica } // Métodos públicos public void metodoPublico() { // lógica } // Getters y setters public int getVariableInstancia() { return variableInstancia; } public void setVariableInstancia(int variableInstancia) { this.variableInstancia = variableInstancia; } // Métodos privados private void metodoPrivado() { // lógica interna } } ```public class MiClase { // Constantes private static final int CONSTANTE = 100; // Variables de instancia private int variableInstancia; // Variables estáticas private static int contador; // Constructor public MiClase(int valor) { this.variableInstancia = valor; } // Métodos estáticos public static void metodoEstatico() { // lógica } // Métodos públicos public void metodoPublico() { // lógica } // Getters y setters public int getVariableInstancia() { return variableInstancia; } public void setVariableInstancia(int variableInstancia) { this.variableInstancia = variableInstancia; } // Métodos privados private void metodoPrivado() { // lógica interna } }
Un ejemplo ```js class Producto { // Constantes static const IVA = 0.21; static const DESCUENTO_MAXIMO = 0.5; // Variables estáticas static contadorProductos = 0; // Variables de instancia #id; #nombre; #precio; #descuento; constructor(nombre, precio) { this.#id = ++Producto.contadorProductos; this.#nombre = nombre; this.#precio = precio; this.#descuento = 0; } // Getters get id() { return this.#id; } get nombre() { return this.#nombre; } get precio() { return this.#precio; } get descuento() { return this.#descuento; } // Setters set nombre(nuevoNombre) { if (typeof nuevoNombre === 'string' && nuevoNombre.trim() !== '') { this.#nombre = nuevoNombre.trim(); } } set descuento(nuevoDescuento) { if (nuevoDescuento >= 0 && nuevoDescuento <= Producto.DESCUENTO_MAXIMO) { this.#descuento = nuevoDescuento; } } // Métodos calcularPrecioFinal() { const precioConDescuento = this.#precio * (1 - this.#descuento); return precioConDescuento * (1 + Producto.IVA); } // Funciones estáticas static compararPrecios(producto1, producto2) { return producto1.calcularPrecioFinal() - producto2.calcularPrecioFinal(); } } // Uso de la clase const producto1 = new Producto("Laptop", 1000); producto1.descuento = 0.1; console.log(producto1.calcularPrecioFinal()); const producto2 = new Producto("Smartphone", 500); console.log(Producto.compararPrecios(producto1, producto2)); ```