Scala_05 – Objetos

En Scala, todo es un objeto, incuso las funciones son objetos, por ejemplo la función anónima (x: Int) => x*x, puede utilizarse de la siguiente manera:

val f = (x: Int) => x * x //> f : Int => Int = <function1>

f(7) //> res1: Int = 49

Mismo resultado que se obtendría declarando explícitamente el objeto de la siguiente manera:

val f = new Function1[Int, Int] {

     def apply(x: Int) = x * x

} //> f : Int => Int = <function1>

f.apply(7) //> res0: Int = 49

TIPOS DE CLASES

Traits. Son usados para definir tipos de objetos al especificar el comportamiento mediante los métodos provistos. Un trait puede ser vista como una interfaz de Java, pero Scala permite a los traits ser parcialmente implementados, esto es, es posible definir implementaciones por defecto para algunos métodos.

trait Similarity {

     def isSimilar(x: Any): Boolean

     def isNotSimilar(x: Any): Boolean = !isSimilar(x)

}

Al igual que en Java, un trait se implementa en otra clase extendiéndolo:

class Point(xc: Int, yc: Int) extends Similarity {

     var x: Int = xc

     var y: Int = yc

     def isSimilar(obj: Any) =

          obj.isInstanceOf[Point] &&

               obj.asInstanceOf[Point].x == x

}

En este caso, la clase Point tiene la obligación de implementar la función isSimilar, pero no la función isNotSimilar, ya que esta última ya fue implementada en el trait.

Clases Case. un clase case son clases estándar con un modificador especial: case. Este modificador indica al compilador asumir ciertas cosas acerca de la clase, como:

• Los parámetros del constructor se convierten en campos público
• Los métodos toString(), equals() y hashCode() son definidos basados en los campos del constructor
• Un objeto acompañante conteniendo:
  • Un constructor apply basado en el constructor de la clase
  • Un extractor basado en los campos del constructor

Por ejemplo:

case class Persona(nombre: String, apellido: String)

Se pude utilizar:

val yo = Persona(«Ignacio», «Salas») //> yo : Persona = Persona(Ignacio,Salas)

val nom = yo.nombre //> nom : String = Ignacio

val app = yo.apellido //> app : String = Salas

LISTAS

Una lista es una estructura de datos fundamente en programación funcional. Por ejemplo:

val fruta = List(«manzana», «naranja», «pera») //> fruta : List[String] = List(manzana, naranja, pera)

val numeros = List(1, 2, 3, 4) //> numeros : List[Int] = List(1, 2, 3, 4)

val Calificaciones = List(List(10, 9, 8), List(9, 7, 9), List(10, 7, 7))

//> Calificaciones : List[List[Int]] = List(List(10, 9, 8), List(9, 7, 9), List

//| (10, 7, 7))

val listavacia = List() //> listavacia : List[Nothing] = List()

La diferencia entre una lista y un arreglo son las siguientes:

• Las listas son inmutables (nos elementos no pueden cambiar)
• Las listas son recursivas, los arreglos son planos
• Al igual que los arreglos, las listas son homogéneas

Existen 3 operaciones básicas en las listas que son:

• head. Primer elemento de la lista
• tail. Todos los elementos menos el primero
• isEmpty. true si está vacia

Por ejemplo:

fruta.head //> res0: String = manzana

fruta.tail //> res1: List[String] = List(naranja, pera)

fruta.tail.head //> res2: String = naranja