Escala | Clase de caso y objeto de caso

Una clase de caso es como una clase normal, que tiene una función para modelar datos inalterables. También es constructivo en la coincidencia de patrones. Se ha definido con un modificador case , debido a esta palabra clave case, podemos obtener algunos beneficios para evitar hacer secciones de códigos que deben incluirse en muchos lugares con poca o ninguna alteración. Como podemos ver a continuación, una clase de caso mínima necesita la clase de caso de palabra clave , un identificador y una lista de parámetros que pueden estar vacantes.
Sintaxis:

Case class className(parameters)

Nota: La clase Case tiene un método apply() predeterminado que gestiona la construcción del objeto.

Un objeto de caso también es como un objeto, que tiene más atributos que un objeto normal. Es una combinación de clases de casos y objetos. Un objeto de caso tiene algunas características más que un objeto regular.
A continuación, dos son características importantes del objeto de caso:

• Es serializable.
• Tiene una implementación de hashCode por defecto.

Ejemplo :

// Scala program of case class and case Object
case class employee (name:String, age:Int)
object Main 
{ 
    // Main method
    def main(args: Array[String]) 
    { 
        var c = employee("Nidhi", 23)
          
        // Display both Parameter 
        println("Name of the employee is " + c.name); 
        println("Age of the employee is " + c.age); 
    } 
} 

Name of the employee is Nidhi
Age of the employee is 23

• Uno de los principales beneficios de Case Class es que Scala Compiler agrega un método con el nombre de la clase que tiene un número idéntico de parámetros como se define en la definición de clase, por lo que puede crear objetos de Case Class incluso en ausencia de la palabra clave nuevo .
  Ejemplo:

  // Scala program of case class and case Object // affix a method with the name of the class case class Book (name:String, author:String) object Main {     // Main method     def main(args: Array[String])     {         var Book1 = Book("Data Structure and Algorithm", "cormen")         var Book2 = Book("Computer Networking", "Tanenbaum")                    // Display strings         println("Name of the Book1 is " + Book1.name);         println("Author of the Book1 is " + Book1.author);         println("Name of the Book2 is " + Book2.name);         println("Author of the Book2 is " + Book2.author);     } }

  Producción:

  Name of the Book1 is Data Structure and Algorithm
  Author of the Book1 is cormen
  Name of the Book2 is Computer Networking
  Author of the Book2 is Tanenbaum
  

• La segunda conveniencia es que, de forma predeterminada, el compilador de Scala agrega val o var para todos los parámetros del constructor, por lo que no podremos reasignarles un nuevo valor una vez que se construya el objeto de clase, por eso, incluso en ausencia de val o var, los parámetros del constructor de la clase case resultarán ser miembros de la clase, lo que no es factible para las clases normales.
  Ejemplo:
  
  Por lo tanto, la reasignación no es factible.
• El compilador de Scala también agrega un método copy() a la clase case que se utiliza para crear un duplicado del mismo objeto cambiando algunos parámetros o sin alterarlos.
  Ejemplo: Para crear un duplicado de la misma instancia sin alterar los parámetros.

  // Scala program of case class To create  // a duplicate of same instance case class Student (name:String, age:Int) object Main {     // Main method     def main(args: Array[String])     {         val s1 = Student("Nidhi", 23)                    // Display parameter         println("Name is " + s1.name);         println("Age is " + s1.age);         val s2 = s1.copy()                    // Display copied data         println("Copy Name " + s2.name);         println("Copy Age " + s2.age);     } }

  Producción:

  Name is Nidhi
  Age is 23
  Copy Name Nidhi
  Copy Age 23
  

  Aquí, hemos creado un nuevo objeto s2 usando el método de copia en el objeto s1 sin alterar los atributos del objeto s1.
  Ejemplo: para crear un duplicado del mismo objeto con atributos cambiantes.

  // Scala program of case class same object  // with changing attributes case class Student (name:String, age:Int)    object Main {     // Main method     def main(args: Array[String])     {         val s1 = Student("Nidhi", 23)                    // Display parameter         println("Name is " + s1.name);         println("Age is " + s1.age);         val s2 = s1.copy(age = 24)                    // Display copied and changed attributes         println("Copy Name is " + s2.name);         println("Change Age is " + s2.age);     } }

  Producción:

  Name is Nidhi
  Age is 23
  Copy Name is Nidhi
  Change Age is 24
  

  Aquí, debe pasar el valor en el método de copia.

• De forma predeterminada, Scala Compiler agrega toString, métodos de igualdad, objeto complementario con métodos de aplicación y desuso, por esa razón no necesita una nueva palabra clave para construir el objeto de una clase de caso.

Nota: No era factible usar más de 22 parámetros en las clases de casos de Scala, pero ahora puede usar cualquier número de parámetros en las clases de casos usando la versión 2.11.1 de Scala. Esta limitación se eliminó de esta versión de scala.