Clases y objetos en Scala

DataCamp ha lanzado recientemente su primer curso de Scala: Introducción a Scala. ¡Échale un vistazo!

También, revise los siguientes tutoriales:

• Guía para Principiantes de Scala
• IF ELSE en Scala
• Operadores en Scala
• Listas en Scala

Introducción

En general, la Programación Orientada a Objetos (OOP) consiste en clases y objetos y busca implementar entidades del mundo real como el polimorfismo, la herencia.

La OOP acelera y reduce los costos del desarrollo con una mejor mantenibilidad del software. La razón principal para esta magia es la cantidad de características que soporta; tienes clases y objetos que pueden reutilizarse fácilmente en el futuro según la necesidad, en contraste con un programa que carece de clases y objetos. Esto, a su vez, conduce a un software de mayor calidad, que también es extensible con nuevos métodos y atributos.

Imaginemos que tienes un showroom de coches; cada pocos meses, se lanza un nuevo coche, y para informar a los espectadores de su nombre y características, tienes que definir nuevos métodos y atributos desde cero. Sin embargo, si tienes un programa orientado a objetos que tiene una clase de coche, todo lo que tendrás que agregar es un objeto para ese nuevo coche, que llamará los métodos y atributos de la clase con la información del vehículo.

La clase se puede considerar como una representación o un diseño para los objetos. Normalmente, las clases tendrán sus propios métodos (comportamiento) y atributos.

Los atributos son entidades individuales que diferencian cada objeto del otro y determinan varias cualidades de un objeto. Por otro lado, los métodos son más como cómo usualmente una función opera en la programación. Determinan cómo funciona la instancia de la clase. Es principalmente debido a los métodos (comportamiento) que los objetos tienen la capacidad de ser modificados.

La figura anterior te proporciona más intuición sobre el flujo de la programación orientada a objetos o, más específicamente, cómo se ve una clase. En la imagen anterior, hay una clase coche que tiene atributos: combustible, velocidad máxima y puede tener más atributos como el modelo, marca,等等. Puede tener diferentes conjuntos de métodos como reabastecer(), getFuel(), setSpeed() y algunos métodos adicionales pueden ser cambiar la marcha, arrancar el motor, detener el motor,等等.

Así que cuando hablas de un coche específico, tendrás un objeto, que es una instancia de una clase.

Ahora, vamos a hablar sobre la programación orientada a objetos en Scala.

Clases y Objetos en Scala

Mucho como C++ y Java, la programación orientada a objetos en Scala sigue prácticamente las mismas convenciones. Tiene la noción de definir clases y objetos y dentro de las constructores de clase, y eso es todo lo que hay en la programación orientada a objetos en Scala.

Declaración de Clase

class Class_name{
// métodos y atributos
}

Una clase en Scala se define por la palabra clave class seguida del nombre de la clase, y generalmente, el nombre de la clase comienza con una letra mayuscula. Hay unos pocos keywords que son opcionales pero se pueden usar en la declaración de clase de Scala, como: class-name, que debe comenzar con una letra mayuscula: superclass, el nombre de la clase padre precedido por la palabra clave extend: traits, es una lista separada por comas implementada por la clase precedida por la palabra clave extend.

Una clase en Scala puede heredar solo una clase padre, lo que significa que Scala no soporta herencias múltiples. Sin embargo, se puede lograr con el uso de Traits.

Finalmente, el cuerpo de una clase en Scala está rodeado por llaves {}.

// El nombre de la clase es Carro
class Car
{

    // Variables de clase
    var make: String = "BMW"
    var model: String = "X7"
    var fuel: Int = 40

    // Método de clase
    def Display()
    {
        println("Make of the Car : " + make);
        println("Model of the Car : " + model);
        println("Fuel capacity of the Car : " + fuel);
    }
}
object Main  
{

    // Método principal
    def main(args: Array[String])  
    {

        // Objeto de clase
        var obj = new Car();
        obj.Display();
    }
}

Puedes guardar el código de arriba con el nombre class.scala y ejecutarlo en la terminal como scala class.scala, y deberías ver la salida como se muestra a continuación.

Bien, el código de arriba no utiliza completamente los privilegios de un programa orientado a objetos. Dado que la salida del código de arriba devolverá el mismo resultado independientemente de la cantidad de veces que ejecutes. Defines variables estáticas dentro de la clase, y los valores de esas variables serán constantes, incluso si creas infinitos objetos nuevos. En conclusión, no puedes esperar que te proporcione detalles para un Mercedes Benz o un Ferrari.

Constructor en Scala

Los constructores se utilizan principalmente para inicializar el estado del objeto. Esta inicialización del objeto ocurre en el momento de la creación del objeto y se llaman solo una vez.

Hay dos tipos de constructores en Scala: Primary y Auxiliary. Para este tutorial, aprenderás sobre el constructor primario (Fuente: O’Reilly).

class Class_name(Parameter_list){
// métodos, atributos
}

El constructor primario contiene el mismo cuerpo con la clase, y se crea implícitamente junto con la definición de la clase. Comienza en la definición de la clase y abarca todo el cuerpo de la clase. Además, cuando hay solo un constructor en el programa de Scala, se conoce como constructor primario. Un constructor primario puede definir cero, uno o más parámetros.

Los siguientes textos se traducen al español de la siguiente manera, conservando los delimitadores personalizados:

—So, let’s take the previous example, but this time append the primary constructor feature into it and observe the effect.

Also, here you will learn a new feature of a class, i.e., a class can have multiple objects or instances but both independent of each other.

// Nombre de la clase es Car
class Car(make: String, model: String, fuel: Int)
{

    // Método de clase
    def Display()
    {
        println("Make of the Car : " + make);
        println("Model of the Car : " + model);
        println("Fuel capacity of the Car : " + fuel);
    }
}

object Main

{

    // Método principal
    def main(args: Array[String])  
    {

        // Múltiples objetos de clase
        var obj1 = new Car("BMW", "X7", 40);
        var obj2 = new Car("Mercedes Benz", "S350D", 50);
        obj1.Display();
        obj2.Display();
    }
}

Vamos a ver rápidamente la salida:

Well, isn’t this great? With the help of a constructor, you were able to generate more effective results.

Declaring Objects in Scala

La declaración de objetos en Scala también se puede considerar como la instanciación de una clase o la invocación de una clase. Similar a las clases, los objetos también son una unidad fundamental del programación orientada a objetos.

Un objeto puede consistir en tres características (Fuente: GeeksforGeeks:

• Estado: Los atributos de un objeto lo representan. También refleja las propiedades de un objeto.
• Comportamiento: Los métodos de un objeto lo representan. También refleja la respuesta de un objeto con otros objetos.
• Identidad: Le da un nombre único a un objeto y permite que un objeto interactúe con otros objetos.

Considere a un perro como un objeto y vea el diagrama de abajo para su identidad, estado y comportamiento.

Todas las instancias o objetos comparten las propiedades y métodos de la clase. Una sola clase puede tener múltiples objetos, como aprendió aquí. Sin embargo, el estado o valores de cada objeto son únicos.

Finalmente, escribirá un código que tendrá constructores primarios, variables de clase, atributos y métodos combinados en un solo código.

A continuación, se representa pictóricamente los componentes juntos en la clase Motorcycle.

El código de abajo es bastante explicativo; a nivel alto, sin embargo, verifica si el motor de la motocicleta está encendido o apagado. Inicialmente, el motor se pone en estado apagado y le notificará de su estado y lo cambiará a encendido.

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();
    }
}

¡Felicitaciones!

Felicitaciones por finalizar este tutorial.

Ahora sabe cómo declarar clases y métodos, instanciar objetos, establecer sus atributos y llamar métodos de instancia en Scala. Estos conceptos serán útiles para él no solo en Scala sino incluso en otros lenguajes de programación.

Los conceptos de programación orientada a objetos son interesantes y, a la vez, muy potentes. Agrega una nueva dimensión a tu código, lo hace reutilizable. A medida que tu programa se hace más grande, tu código crecerá en complejidad. Existen muchos conceptos importantes en la programación orientada a objetos, como la herencia, la polimorfía, los métodos de instancia. Otra característica poderosa es el Singleton. Los principios de diseño ayudan a mantener tu código más estructurado y legible. Para más información sobre patrones de diseño, considera leer este libro.

Por favor, no dude en preguntar cualquier duda relacionada con este tutorial en la sección de comentarios de abajo.

Finalmente, no olvides tomar el nuevo curso de Scala en DataCamp, Introducción a Scala.