Introducción a Scala

Introducción a Scala
Colombia JUG JavaDay 2012

Contenido

• Introducción
• Estructuras de control
• Programación orientada a objetos
• Programación funcional

Mario Arias
@dh44t
http://cobaltolabs.com
http://neuronica.wordpress.com

¿Que es Scala?

Scala (Scalable Language).
Scala es un lenguaje diseñado para la JVM,
que combina los paradigmas de la
programación orientada a objetos con la
programación funcional

¿Quien lo diseño?

Martin Odersky (@odersky) en la EPFL.
TypeSafe es la empresa que desarrolla y da
soporte a Scala y otras tecnologías
relacionadas

Características
• Orientado a objetos
• Funcional
• Escalable
• Tipeado estático*
• Extensible
• Productivo
• Open Source
http://typesafe.com/technology/scala

Hola Mundo!

object HelloWorld {
def main(args: Array[String]) {
println("Hello World")
}
}

Hola Mundo! (II)

object HelloWorldApp extends App {
}

Hola Mundo! (III)


REPL
Read Evaluation Print Loop

Welcome to Scala version 2.9.2 (Java HotSpot(TM) 64-Bit Server VM, Java 1.7.0_04).

Type in expressions to have them evaluated.

Type :help for more information.

scala> println("Hello World!")

Hello World!

Sentencias y
Expresiones

• Sentencias son bloques de código que se
ejecutan
• Expresiones son bloques de código que se
ejecutan y que retornan un valor

Variables

var i:Int = 1
var name:String = “Bonifacio”
var age:Int = _

Variables (II)

//Inferencia de tipos
var i = 1
var name = “Bonifacio”
var age = _ //Error

Variables (III)
//JavaScript
var i = 1;
i = “Bonifacio”;

//Scala
var i = 1
i = “Bonifacio” //Error

Valores
//Scala
val i:Int = 1
val name:String = “Bonifacio”

//Java
final int i = 1;
final String name = “Bonifacio”;

Valores (II)

//inferencia de tipos
val i = 1
val name = “Bonifacio”

Métodos

def duplicar(i:Int):Int = {
return i*2
}

Métodos (II)

def duplicar(i:Int) = {
return i*2
}

Métodos (III)

def duplicar(i:Int) = {
i*2
}

Métodos (IV)

def duplicar(i:Int) = i*2

Métodos (V)

def imprimir(i:Int):Unit = {
println(i*2)
}

Métodos (V)

def imprimir(i:Int){
println(i*2)
}

Invocación
duplicar(1)
duplicar{1}
duplicar{
val i = 5
val j = i - 3
j * i
}

Invocación (II)
multiplicar(2, 3)
multiplicar{2, 3}// Error
toString()
toString

if

if (1 > 2) {
println("Uno es mayor a dos")
} else {
println("Dos es mayor a uno")
}

if (II)
val resultado:String = if (1 > 2) {
"Uno es mayor a dos"
} else {
"Dos es mayor a uno"
}
println(resultado)

match

def desc(i: Int): String = i match {
case 1 => "Uno"
case 2 => "Dos"
case _ => "Otro"
}

match (II)

def desc2(n: String): Int = n match {
case "Uno" => 1
case "Dos" => 2
case _ => -1
}

match (III)

def desc3(i: Int): String = i match {
case 1 => "Uno"
case 2 => "Dos"
case z => z + " ?"
}

match (IV)
def desc4(i: Int): String = i match {
case 1 => "Uno"
case 2 => "Dos"
case z if z % 2 == 0 => "Par"
case _ => "Impar"
}

match (V)

def desc5(a: Any): String = a match {
case i: Int => desc4(i)
case i: String => i
case i => i.toString
}

while

var i = 0
while (i < 5) {
println("i = " + i)
i += 1
}

do while

var i = 0
do {
println("i = " + i)
i += 1
} while (i < 5)

for
for (i <- 0 to 9) {
println("i = " + i)
}

for (i <- 0 until 9) {
println("i = " + i)
}

for (II)

val langs = Array("Java", "Scala", "Python", "Groovy")

for (lang <- langs) {

println("lang = " + lang)

}

for (III)

for (lang <- langs if lang.size > 4) {
}

for (IV)
for {
lang <- langs
if lang.size > 4
upper = lang.toUpperCase
} {
println("upper = " + upper)
}

for yield

val upperLanguages =
for (lang <- langs)
yield lang.toUpperCase

try catch

try{
//operaciones peligrosas
} catch{
case e:NumberFormatException => //
case e:Exception => //
}

Programación orientada
a objetos

¿Java es un lenguaje
orientado a objetos
puro?

¿Que es un lenguaje
orientado a objetos
puro?

• Todo es un objeto
• Todas las operaciones son métodos de
dichos objetos

¿Por qué Java no lo es?

• Primitivos
• Miembros estáticos
• Operaciones matemáticas
• y otras operaciones

Primitivos
Java Scala
byte Byte
short Short
int Int
long Long
char Char
ﬂoat Float
double Double
boolean Boolean

Miembros Estaticos
//Java

public class Helper{

public static void metodo(){}

}

//Scala

object Helper{

def metodo(){}

}

Operaciones
matemáticas

val i = 2 + 3
val j = 2.+(3)

instanceof
//Java
if(i instanceof String) {//}

//Scala
if(i.isInstanceOf[String]){//}

cast
//Java
(String)x
((String)x).toUpperCase()

//Scala
x.asInstanceOf[String]
x.asInstanceOf[String].toUpperCase

clases

class Perro{
var nombre:String = _
def hablar(){
println(nombre + “ dice: Gua”)
}
}

modiﬁcadores de
alcance
Java Scala
public “por defecto”
protected protected
private private
“por defecto” private[paquete]
N.D. private[this]

constructor

class Perro(val nombre:String) {

println("Acaba de nacer el perrito " + nombre)

}

constructor (II)

class Perro(val nombre:String) {

println("Acaba de nacer el perrito " + nombre)

def this() = this(“Sin nombre”)

}

trait
trait Cuadrupedo{

def caminar()

}

class Perro extends Cuadrupedo {

def caminar(){

println(“Caminando...”)

}

}

trait (II)

trait Cuadrupedo{

def caminar(){

println(“Caminando...”)

}

}

class Perro extends Cuadrupedo {

}

trait (III)

class Perro extends Cuadrupedo with Mamifero {

}

class Gato extends Cuadrupedo with Mamifero {

}

class Tortuga extends Cuadrupedo with Reptil {

}

trait (IV)

trait UserServiceAware{

@Inject var userService:UserService = _

}

class UserController extends UserServiceAware{}

class UserEndPoint extends UserServiceAware{}

trait (V)

val robot = new Robot with Cuadrupedo
robot.caminar()

duck typing

Si camina como pato y nada como pato es un pato

duck typing (II)
#Python

class Perro:

def hablar(self):

print "Gua"

class Persona:

def hablar(self):

print "Hola"

duck typing (III)
#Python
def hacer_hablar(hablador):
hablador.hablar()

hacer_hablar(Perro())
hacer_hablar(Persona())
hacer_hablar(1) #Error de ejecución

Tipos estructurales
class Perro{
def hablar(){println(“Guau”)}
}

class Persona{
def hablar(){println(“Hola”)}
}

Tipos estructurales(II)

def hacerHablar(hablador:{def hablar()}){

hablador.hablar()

}

hacerHablar(new Perro)

hacerHablar(new Persona)

hacerhablar(1) //Error de compilación

Tipos estructurales(III)

def isHablarDefinido(x:Any):Boolean = {

x.isInstanceOf[{def hablar()}]

}

apply
val langs = Array("Java", "Scala", "Python", "Groovy")

langs(0)

langs.apply(0)

Genéricos

trait Listener[T]{
def action(event:T)
}

Genéricos (II)

trait Listener[T <: MiClase]{
def action(event:T)
}

Funciones implícitas

Funciones implícitas son funciones que usan para
convertir de un tipo a otro en forma transparente

Funciones implícitas (II)

println("Desde el segundo JavaDay".andTheMusic())

Funciones implícitas (III)

class CarolinaCruzLike(val s: String) {
def andTheMusic(): String = {
s + " and the music"
}
}

Funciones implícitas (IV)

implicit def stringToCaroCruz(s: String) = {

new CarolinaCruzLike(s)

}

Funciones implícitas (V)

println("Desde el segundo JavaDay".andTheMusic())

println{

stringToCaroCruz("Desde el segundo JavaDay")

.andTheMusic()

}

¿Que es?
Programación funcional es un paradigma de
programación que trata todo operación como una
evaluación de una función aritmética y tiene sus raíces
en el calculo lambda

Función
val duplicar = {i: Int => i * 2}

val duplicar: (Int) => Int =
{i => i * 2}

duplicar(2)

Composición
val duplicar = {i: Int => i * 2}
val mas5 = {i: Int => i + 5}
val duplicarMas5 = duplicar andThen mas5
duplicarMas5(2)
val mas5duplicar = duplicar compose mas5
mas5duplicar(2)

Colecciones

val numeros = Array(1, 2, 3, 4, 5, 6, 7, 8, 9)

numeros.foreach((i: Int) => {

println("i = " + i)

})

numeros.foreach(i => println("i = " + i))

Colecciones (II)

//Java

List<String> langs = Arrays.asList("Java", "Scala", "Python", "Groovy");

List<String> upperLangs = new ArrayList<String>();

for (String lang : langs) {

upperLangs.add(lang.toUpperCase());

}

Colecciones (III)

val langs = List("Java", "Scala", "Python", "Groovy")

val upperLangs = langs.map(lang => lang.toUpperCase)

Colecciones (IV)
Método Descripción

Ejecuta una función en todos los
foreach
elementos
Colección nueva aplicando una
map
función a todos los elementos
Colección nueva con todos los
ﬁlter elementos que cumplen una función
T => Boolean
Colección nueva con todos los
ﬁlterNot elementos que no cumplen una
función T => Boolean

Colecciones (V)
Método Descripción

Valida que todos los elementos
forall
cumplen una función T => Boolean

Valida que al menos un elemento
exists
cumpla una función T => Boolean

Retorna cuantos elementos cumplen
count
una función T => Boolean

Función como
parámetro
def operar(f: (Int, Int) => Int): Int = {
f(5, 8)
}

operar((a, b) => {a + b})
operar((a, b) => {a * b})

Bloque como
parámetro
def cronometrar(block: => Unit) {

val start = System.currentTimeMillis()

block

println(System.currentTimeMillis() - start)

}

cronometrar{

unMetodoMuyDemorado()

}

Introducción a Scala

Más contenido relacionado

La actualidad más candente (20)

Destacado (13)

Similar a Introducción a Scala (20)

Introducción a Scala

Notas del editor