Clases, objetos y paquetes
Comprenda cómo definir clases, crear objetos y organizar su código mediante paquetes en Scala.
Clases, objetos y paquetes es una lección gratuita de Scala for Backend Engineering & Functional Programming en CoddyKit. Esta es la lección 1 de 2. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Scala for Backend Engineering & Functional Programming, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Scala for Backend Engineering & Functional Programming incluye 2 lecciones en total.
Bienvenido a la POO en Scala
En esta lección se adentrará en el núcleo de la programación orientada a objetos (POO) en Scala. Exploraremos cómo estructurar el código mediante clases, crear instancias de esas clases (objetos) y mantenerlo todo organizado con paquetes.
¡Comencemos a crear aplicaciones sólidas y modulares!
Clases: los planos
Considere una clase como un plano para crear objetos. Define las propiedades (datos) y los comportamientos (métodos) que tendrán sus objetos. Las clases no almacenan datos por sí mismas, sino que describen qué datos puede contener un objeto.
Esta es una definición básica de clase:
class Car {
// Properties and methods go here
}Definición de una clase sencilla
En Scala, se define una clase mediante la palabra clave class, seguida de su nombre. Creemos una clase Dog sencilla. Todavía no hace gran cosa, pero es un comienzo.
Pruebe a ejecutar esta definición de clase vacía:
class Dog {
// This dog has no properties or behaviors yet
}
object Main {
def main(args: Array[String]): Unit = {
println("Dog class defined!")
}
}Creación de objetos (instancias)
Un objeto es una instancia de una clase. Es una «cosa» real creada a partir del plano. Para crear un objeto, se utiliza la palabra clave new seguida del nombre de la clase.
Cada objeto obtiene su propio conjunto de datos, tal como lo define la clase.
class Dog {
// Still an empty dog blueprint
}
object Main {
def main(args: Array[String]): Unit = {
val myDog = new Dog()
val yourDog = new Dog()
println("Two dog objects created!")
}
}Añadir propiedades a una clase
Las clases pueden tener propiedades (también llamadas campos o miembros) que almacenan datos. Puede definirlas en el constructor de la clase, de modo que sean parámetros al crear un objeto.
Asigne a nuestro Dog un name y un breed:
class Dog(val name: String, val breed: String) {
// 'val' makes name and breed immutable properties
}
object Main {
def main(args: Array[String]): Unit = {
val myDog = new Dog("Buddy", "Golden Retriever")
println(s"My dog's name is ${myDog.name} and breed is ${myDog.breed}.")
}
}Añadir comportamiento (métodos)
Las clases también definen métodos, que son funciones que describen el comportamiento del objeto. Los métodos pueden acceder a las propiedades del objeto y modificarlas.
Ahora nuestro Dog puede hacer bark():
class Dog(val name: String, val breed: String) {
def bark(): String = {
s"${name} says Woof!"
}
}
object Main {
def main(args: Array[String]): Unit = {
val myDog = new Dog("Max", "Labrador")
println(myDog.bark())
}
}El `object` de Scala (Singletons)
En Scala, la palabra clave object define un singleton. Esto significa que solo puede existir una instancia de él. No se utiliza new para crearlo; basta con referirse a su nombre.
Suelen utilizarse para métodos de utilidad o como un único punto de entrada.
object MathUtils {
def add(a: Int, b: Int): Int = a + b
def subtract(a: Int, b: Int): Int = a - b
}
object Main {
def main(args: Array[String]): Unit = {
val sum = MathUtils.add(5, 3)
println(s"5 + 3 = ${sum}")
}
}Objetos complementarios
Un objeto complementario es un object que tiene el mismo nombre que una class y se define en el mismo archivo de código fuente. Ambos tienen acceso especial a los miembros privados del otro.
- La clase contiene datos y métodos específicos de cada instancia.
- El objeto complementario contiene métodos similares a los estáticos o métodos de fábrica.
class Circle(val radius: Double) {
def area: Double = Circle.PI * radius * radius
}
object Circle {
// This is the companion object for the Circle class
val PI: Double = 3.14159
def apply(r: Double): Circle = new Circle(r) // Factory method
}
object Main {
def main(args: Array[String]): Unit = {
val c = Circle(5.0) // Using the apply method from companion object
println(s"Circle area: ${c.area}")
}
}Organización del código con paquetes
Los paquetes permiten organizar las clases y los objetos en grupos lógicos, evitar conflictos de nombres y mejorar el mantenimiento del código.
Considérelos como carpetas para su código. La palabra clave package declara el paquete en la parte superior de un archivo de Scala.
package com.coddykit.animals
class Cat(val name: String) {
def meow(): String = s"${name} says Meow!"
}
// This class is now inside com.coddykit.animals packageImportación de miembros de paquetes
Para utilizar clases u objetos definidos en otro paquete, debe importarlos. La palabra clave import hace que los miembros de un paquete estén disponibles en el ámbito actual.
Importemos nuestra clase Cat:
package com.coddykit.app
// Define a class in a package first for import example
package com.coddykit.animals {
class Cat(val name: String) {
def meow(): String = s"${name} says Meow!"
}
}
import com.coddykit.animals.Cat
object Main {
def main(args: Array[String]): Unit = {
val myCat = new Cat("Whiskers")
println(myCat.meow())
}
}Comprobación rápida: ¿clase u objeto?
Ha aprendido sobre clases, objetos y paquetes. ¡Pongamos a prueba sus conocimientos!
Repaso: clases, objetos y paquetes
¡Excelente trabajo! Ha aprendido los fundamentos de la POO en Scala:
- Las clases son planos que definen propiedades y comportamientos.
- Los objetos son instancias creadas a partir de clases mediante
new. - La palabra clave
objectde Scala crea singletons, útiles para utilidades o fábricas. - Los objetos complementarios se asocian con clases para proporcionar miembros similares a los estáticos.
- Los paquetes organizan el código, evitan conflictos de nombres y mejoran su estructura.
A continuación, desarrollaremos esta base explorando la herencia y el polimorfismo.
Preguntas frecuentes
¿La lección «Clases, objetos y paquetes» es gratis?
Sí — el texto completo de «Clases, objetos y paquetes» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Scala for Backend Engineering & Functional Programming, actualiza a CoddyKit PRO. El curso de Scala for Backend Engineering & Functional Programming incluye 2 lecciones en total.
¿Qué aprenderé en «Clases, objetos y paquetes»?
Comprenda cómo definir clases, crear objetos y organizar su código mediante paquetes en Scala. Practicas Scala for Backend Engineering & Functional Programming con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar Scala for Backend Engineering & Functional Programming?
No se requiere experiencia previa. Scala for Backend Engineering & Functional Programming en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 2.
¿Cuánto tiempo toma la lección «Clases, objetos y paquetes»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de Scala for Backend Engineering & Functional Programming?
Sí. Cada lección de Scala for Backend Engineering & Functional Programming incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- Clases, objetos y paquetes
- Herencia y polimorfismo