Diapositivas de la charla introducción a Scala del JavaDay 2012 del Colombia JUG

1. Introducción a Scala
Colombia JUG JavaDay 2012

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

3. Introducción

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

5. ¿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

6. ¿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

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

8. Hola Mundo!
object HelloWorld {
def main(args: Array[String]) {
println("Hello World")
}
}

9. Hola Mundo! (II)
object HelloWorldApp extends App {
println("Hello World")
}

10. Hola Mundo! (III)
println("Hello World")

11. 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!

12. Estructuras de control

13. 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

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

15. Variables (II)
//Inferencia de tipos
var i = 1
var name = “Bonifacio”
var age = _ //Error

16. Variables (III)
//JavaScript
var i = 1;
i = “Bonifacio”;
//Scala
var i = 1
i = “Bonifacio” //Error

17. Valores
//Scala
val i:Int = 1
val name:String = “Bonifacio”
//Java
final int i = 1;
final String name = “Bonifacio”;

18. Valores (II)
//inferencia de tipos
val i = 1
val name = “Bonifacio”

19. Métodos
def duplicar(i:Int):Int = {
return i*2
}

20. Métodos (II)
def duplicar(i:Int) = {
return i*2
}

21. Métodos (III)
def duplicar(i:Int) = {
i*2
}

22. Métodos (IV)
def duplicar(i:Int) = i*2

23. Métodos (V)
def imprimir(i:Int):Unit = {
println(i*2)
}

24. Métodos (V)
def imprimir(i:Int){
println(i*2)
}

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

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

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

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

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

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

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

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

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

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

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

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

37. for (II)
val langs = Array("Java", "Scala", "Python", "Groovy")
for (lang <- langs) {
println("lang = " + lang)
}

38. for (III)
for (lang <- langs if lang.size > 4) {
println("lang = " + lang)
}

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

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

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

42. Programación orientada
a objetos

43. ¿Java es un lenguaje
orientado a objetos
puro?

45. NO

46. ¿Que es un lenguaje
orientado a objetos
puro?
• Todo es un objeto
• Todas las operaciones son métodos de
dichos objetos

47. ¿Por qué Java no lo es?
• Primitivos
• Miembros estáticos
• Operaciones matemáticas
• y otras operaciones

48. Primitivos
Java Scala
byte Byte
short Short
int Int
long Long
char Char
float Float
double Double
boolean Boolean

49. Miembros Estaticos
//Java
public class Helper{
public static void metodo(){}
}
//Scala
object Helper{
def metodo(){}
}

50. Operaciones
matemáticas
val i = 2 + 3
val j = 2.+(3)

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

52. cast
//Java
(String)x
((String)x).toUpperCase()
//Scala
x.asInstanceOf[String]
x.asInstanceOf[String].toUpperCase

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

54. modificadores de
alcance
Java Scala
public “por defecto”
protected protected
private private
“por defecto” private[paquete]
N.D. private[this]

55. constructor
class Perro(val nombre:String) {
println("Acaba de nacer el perrito " + nombre)
}

56. constructor (II)
class Perro(val nombre:String) {
println("Acaba de nacer el perrito " + nombre)
def this() = this(“Sin nombre”)
}

57. trait
trait Cuadrupedo{
def caminar()
}
class Perro extends Cuadrupedo {
def caminar(){
println(“Caminando...”)
}
}

58. trait (II)
trait Cuadrupedo{
def caminar(){
println(“Caminando...”)
}
}
class Perro extends Cuadrupedo {
}

59. trait (III)
class Perro extends Cuadrupedo with Mamifero {
}
class Gato extends Cuadrupedo with Mamifero {
}
class Tortuga extends Cuadrupedo with Reptil {
}

60. trait (IV)
trait UserServiceAware{
@Inject var userService:UserService = _
}
class UserController extends UserServiceAware{}
class UserEndPoint extends UserServiceAware{}

61. trait (V)
val robot = new Robot with Cuadrupedo
robot.caminar()

62. duck typing
Si camina como pato y nada como pato es un pato

63. duck typing (II)
#Python
class Perro:
def hablar(self):
print "Gua"
class Persona:
def hablar(self):
print "Hola"

64. duck typing (III)
#Python
def hacer_hablar(hablador):
hablador.hablar()
hacer_hablar(Perro())
hacer_hablar(Persona())
hacer_hablar(1) #Error de ejecución

65. Tipos estructurales
class Perro{
def hablar(){println(“Guau”)}
}
class Persona{
def hablar(){println(“Hola”)}
}

66. Tipos estructurales(II)
def hacerHablar(hablador:{def hablar()}){
hablador.hablar()
}
hacerHablar(new Perro)
hacerHablar(new Persona)
hacerhablar(1) //Error de compilación

67. Tipos estructurales(III)
def isHablarDefinido(x:Any):Boolean = {
x.isInstanceOf[{def hablar()}]
}

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

69. Genéricos
trait Listener[T]{
def action(event:T)
}

70. Genéricos (II)
trait Listener[T <: MiClase]{
def action(event:T)
}

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

72. Funciones implícitas (II)
println("Desde el segundo JavaDay".andTheMusic())

73. Funciones implícitas (III)
class CarolinaCruzLike(val s: String) {
def andTheMusic(): String = {
s + " and the music"
}
}

74. Funciones implícitas (IV)
implicit def stringToCaroCruz(s: String) = {
new CarolinaCruzLike(s)
}

75. Funciones implícitas (V)
println("Desde el segundo JavaDay".andTheMusic())
println{
stringToCaroCruz("Desde el segundo JavaDay")
.andTheMusic()
}

76. Programación Funcional

77. ¿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

78. Función
val duplicar = {i: Int => i * 2}
val duplicar: (Int) => Int =
{i => i * 2}
duplicar(2)

79. 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)

80. 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))

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

82. Colecciones (III)
val langs = List("Java", "Scala", "Python", "Groovy")
val upperLangs = langs.map(lang => lang.toUpperCase)

83. 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
filter elementos que cumplen una función
T => Boolean
Colección nueva con todos los
filterNot elementos que no cumplen una
función T => Boolean

84. 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

85. 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})

86. Bloque como
parámetro
def cronometrar(block: => Unit) {
val start = System.currentTimeMillis()
block
println(System.currentTimeMillis() - start)
}
cronometrar{
unMetodoMuyDemorado()
}

87. ¿Como quedaron?
or