1. Clases, setters y getters
En Java:
public class Javesco{
private String nombre="";
public Javesco(){}
public Javesco(String nombre){
this.nombre=nombre;
}
//setter y getter
public void setNombre(){ this.nombre=nombre; }
public String getNombre(){ return nombre; }
}
En Scala:
class Simple(){
var nombre:String=""
}
Obviamente escribimos menos código, sin embargo esto también puede parecernos confuso (al menos al principio),¿donde queda el private, protected o el public?. La razón es que Scala es un lenguaje más flexible, nos permite hacer muchas cosas, cambiar la manera en que planteas las soluciones.
Creando una clase "compleja":
class Compleja(val _nombrex:String=null){
private var _nombre:String=_nombrex
//setter y getter
def nombre=_nombre
def nombre_=(value:String):Unit=_nombre=value
}
Este código es más parecido a la clase hecha en Java.En esta definimos los setters y getters. Aunque la de arriba es más legible y sencilla de entender(Simple).
Ahora creamos un archivo llamado Codemonkey.scala y escribimos:
object Codemonkey{
def main(args: Array[String]): Unit = {
val simple=new Simple
simple.nombre="Scala Johansson"
Console.println("Hola "+simple.nombre)
val compleja=new Compleja("Jonh Worth")
Console.println("Hola "+compleja.nombre)
simple.nombre="Maria Java"
compleja.nombre="Tom Groovy"
Console.println("Hola "+simple.nombre)
Console.println("Hola "+compleja.nombre)
}
}
Sigue siendo un código legible, no cambia mucho. Scala nos permite hacer las cosas de diferentes maneras.
2. Los import
En Java es necesario definir las clases y/o librerías externas desde la cabecera del código.
import javax.swing.JOptionPane;
public class Codemonkey{
public static void main(String ... args){
JOptionPane.showMessageDialog(null,"Hola desde codemonkey");
}
}
Con Scala no es necesario, podemos definir los import desde cualquier parte del código.
object Codemonkey{
def main(args: Array[String]): Unit = {
import javax.swing.JOptionPane
JOptionPane.showMessageDialog(null,"Hola desde codemonkey")
}
}
3. Conservar los proyectos ya hechos.
Scala al ser dependiende de la JVM permite interoperabilidad con proyectos Java.
Creamos una clase Java llamada Prueba.java y la compilamos, nos generará un *.class
public class Prueba{
public void verMensaje(){
System.out.println("Hola Scala soy un método creado desde una clase Java");
}
}
Ahora creamos el código en Scala, instanciamos la clase Prueba
object Codemonkey{
def main(args: Array[String]): Unit = {
val prueba=new Prueba
prueba.verMensaje
}
}
Java sigue siendo un buen lenguaje y bastante usado, aunque la verdad al crecer tanto la complejidad para aprenderlo también lo hizo.
¿Qué más tiene Scala?
Concurrencia, pattern matching,traits, etc. Un mundo de posiblidades se presenta, tal vez en próximos post ponga más ejemplos.
Por lo pronto no sé si convenga aprender Scala (algunos les parecerá perdida de tiempo, a otros no tanto), pero vaya que si es interesante.
