Curso
Introducción a Scala
3 h
27.1K
DataCamp ha lanzado recientemente su primer curso de Scala: Introduction to Scala. ¡Échale un vistazo!
Además, te recomendamos estos tutoriales:
Introducción
En general, la programación orientada a objetos (POO) se basa en clases y objetos, y busca modelar entidades del mundo real, como el polimorfismo o la herencia.
La POO acelera el desarrollo, reduce costes y mejora el mantenimiento del software. La clave está en sus características: dispones de clases y objetos que puedes reutilizar fácilmente según las necesidades, a diferencia de un programa sin clases ni objetos. Esto se traduce en software de mayor calidad, extensible con nuevos métodos y atributos.
Imagina que tienes un concesionario de coches. Cada pocos meses sale un modelo nuevo y, para informar a tu audiencia de su nombre y características, tendrías que definir métodos y atributos desde cero. Sin embargo, si tu programa es orientado a objetos y ya tienes una clase coche, solo tendrías que crear un objeto para ese modelo nuevo que haga uso de los métodos y atributos de la clase con la información del vehículo.
Una clase puede entenderse como la representación o el plano de los objetos. Las clases suelen tener sus propios métodos (comportamiento) y atributos.
Los atributos son elementos que diferencian unos objetos de otros y determinan sus cualidades. Los métodos, por su parte, funcionan de forma parecida a una función en programación: definen cómo se comporta la instancia de la clase. Gracias a los métodos (el comportamiento), podemos "hacer cosas" con los objetos.
La figura anterior ayuda a entender el flujo de la programación orientada a objetos y, en concreto, cómo se ve una clase. En la imagen hay una class car con attributes: fuel, max speed y podría tener más, como model, make, etc. También incluye varios methods como refuel(), getFuel(), setSpeed(), y otros posibles como change gear, start the engine, stop the engine, etc.
Cuando hablas de un coche concreto, trabajas con un objeto, que es una instancia de una clase.
Ahora, hablemos de la programación orientada a objetos en Scala.
Clases y objetos en Scala
Al igual que en C++ y Java, la programación orientada a objetos en Scala sigue convenciones muy similares. Tiene el concepto de definir classes y objects y, dentro de la clase, constructors. Eso es, en esencia, la POO en Scala.
Declaración de clases
class Class_name{
// methods and attributes
}
En Scala, una clase se define con la palabra clave class seguida del nombre de la clase, que por convención empieza con mayúscula. Hay algunas partes opcionales que pueden aparecer en la declaración de una clase en Scala: class-name, que debería comenzar en mayúscula; superclass, el nombre de la clase padre precedido por la palabra clave extend; y traits, una lista separada por comas implementada por la clase y también precedida por extend.
Una clase en Scala solo puede heredar de una única clase padre; es decir, Scala no admite herencia múltiple. No obstante, se puede lograr un efecto similar con el uso de Traits.
Por último, el cuerpo de una clase en Scala va entre llaves {}.
// Name of the class is Car
class Car
{
// Class variables
var make: String = "BMW"
var model: String = "X7"
var fuel: Int = 40
// Class method
def Display()
{
println("Make of the Car : " + make);
println("Model of the Car : " + model);
println("Fuel capacity of the Car : " + fuel);
}
}
object Main
{
// Main method
def main(args: Array[String])
{
// Class object
var obj = new Car();
obj.Display();
}
}
Puedes guardar el código anterior con el nombre class.scala y ejecutarlo en la terminal con scala class.scala. Deberías ver una salida como la siguiente.
Ahora bien, este código no aprovecha realmente las ventajas de un programa orientado a objetos. La salida será siempre la misma por muchas veces que lo ejecutes. Has definido variables estáticas dentro de la clase, y sus valores permanecerán constantes incluso si creas infinitos objetos nuevos. En resumen, no puedes esperar que te dé información de un Mercedes-Benz o un Ferrari.
Constructor en Scala
Los constructores se usan principalmente para inicializar el estado del objeto. Esta inicialización ocurre en el momento de crear el objeto y se ejecuta solo una vez.
En Scala hay dos tipos de constructores: Primary y Auxiliary. En este tutorial verás el constructor primario (Fuente: O'Reilly).
class Class_name(Parameter_list){
// methods, attributes
}
El constructor primario comparte cuerpo con la clase y se crea de forma implícita junto con la definición de la clase. Comienza en la definición de la clase y abarca todo su cuerpo. Además, cuando solo hay un constructor en el programa Scala, se considera el constructor primario. Puede definirse con cero, uno o más parámetros.
Retomemos el ejemplo anterior, pero esta vez añadiendo el constructor primario para ver el efecto.
Aquí también verás otra característica de las clases: una misma clase puede tener múltiples objetos o instancias, independientes entre sí.
// Name of the class is Car
class Car(make: String, model: String, fuel: Int)
{
// Class method
def Display()
{
println("Make of the Car : " + make);
println("Model of the Car : " + model);
println("Fuel capacity of the Car : " + fuel);
}
}
object Main
{
// Main method
def main(args: Array[String])
{
// Multiple Class object
var obj1 = new Car("BMW", "X7", 40);
var obj2 = new Car("Mercedes Benz", "S350D", 50);
obj1.Display();
obj2.Display();
}
}
Veamos rápidamente la salida:
¿A que está bien? Con la ayuda de un constructor has podido obtener resultados mucho más útiles.
Declaración de objetos en Scala
Declarar objetos en Scala también se conoce como instanciar o invocar una clase. Al igual que las clases, los objetos son una unidad fundamental de la programación orientada a objetos.
Un objeto puede tener tres características (Fuente: GeeksforGeeks):
State:los atributos de un objeto lo representan y reflejan sus propiedades.Behavior:los métodos de un objeto lo representan y reflejan cómo responde ante otros objetos.Identity:proporciona un nombre único al objeto y permite que interactúe con otros objetos.
Considera un perro como objeto y fíjate en el siguiente diagrama para ver su identidad, estado y comportamiento.
Todas las instancias u objetos comparten los atributos y métodos de la clase. Una sola clase puede tener múltiples objetos, como has visto aquí. Sin embargo, el estado o los valores de cada objeto son únicos.
Para terminar, escribirás un código que combine constructores primarios, variables de clase, atributos y métodos en un único ejemplo.
A continuación tienes una representación gráfica de los componentes reunidos en la clase Motorcycle.
El siguiente código se explica casi solo; a grandes rasgos, comprueba si el motor de la moto está on o off. Inicialmente, el motor está apagado, el programa te lo indica y lo enciende.
class Motorcycle(make:String,color:String) {
var engineState: Boolean = false;
def startEngine() {
if (engineState == true){
println("The engine is already on.");
}
else {
engineState = true
println("The engine is now on.");
}
}
def showAtts() {
println("This motorcycle is a "+ color + " " + make);
if (engineState == true){
println("The engine is on.");
}
else{
println("The engine is off.");
}
}
}
object Main
{
def main (args: Array[String])
{
var m = new Motorcycle("BMW K 1600 GTL","White");
println("Calling showAtts...");
m.showAtts();
println("------");
println("Starting engine...");
m.startEngine();
println("------");
println("Calling showAtts...");
m.showAtts();
println("------");
println("Starting engine...");
m.startEngine();
}
}
¡Enhorabuena!
Enhorabuena por completar este tutorial.
Ya sabes cómo declarar clases y métodos, instanciar objetos, establecer sus atributos y llamar a métodos de instancia en Scala. Estos conceptos te serán útiles no solo en Scala, sino también en otros lenguajes de programación.
Los conceptos de programación orientada a objetos son interesantes y, al mismo tiempo, muy potentes. Aportan una nueva dimensión a tu código y fomentan la reutilización. A medida que tu programa crece, también lo hace la complejidad de tu código. Hay mucho contenido en POO: herencia, polimorfismo, métodos de instancia… Otra característica muy potente es el patrón Singleton. Los principios de diseño ayudan a mantener tu código más estructurado y legible. Para profundizar en patrones de diseño, te recomendamos este libro.
Si tienes cualquier duda sobre este tutorial, déjala en los comentarios.
Y no olvides hacer el nuevo curso de Scala en DataCamp, Introduction to Scala.
Temas
