 |
En este articulo sobre informatica se detectaron varios problemas.
Por favor,
editalo
y/o discute los problemas en la
discusion
para mejorarlo:
Este aviso fue puesto el 14 de abril de 2010.
|
Scala
es un
lenguaje de programacion
multi-paradigma disenado para expresar patrones comunes de programacion en forma concisa, elegante y con tipos seguros. Integra sutilmente caracteristicas de
lenguajes funcionales
y
orientados a objetos
. La implementacion actual se ejecuta en la
maquina virtual de Java
y es compatible con las aplicaciones
Java
existentes.
[
1
]
Caracteristicas
[
editar
]
Orientacion a objetos
[
editar
]
Scala es un lenguaje de
programacion puro orientado a objetos
, en el sentido de que cada valor es un objeto. El tipo y comportamiento de los objetos se describe por medio de clases y
traits
. La abstraccion de clases se realiza extendiendo otras clases y usando un mecanismo de composicion basado en
mixins
como un reemplazo limpio de la
herencia multiple
.
[
2
]
Lenguaje funcional
[
editar
]
Scala tambien posee caracteristicas propias de los
lenguajes funcionales
. Por ejemplo, las funciones son valores de primera clase, soportando funciones anonimas, orden superior, funciones anidadas y
currificacion
. Viene integrado de fabrica con la tecnica de pattern matching para modelar tipos algebraicos usados en muchos lenguajes funcionales.
Tipificado estatico
[
editar
]
Scala esta equipado con un sistema de tipos expresivo que refuerza a que las abstracciones de tipos se usen en forma coherente y segura.
Extensibilidad
[
editar
]
Scala se diseno teniendo en mente el hecho de que en la practica el desarrollo de aplicaciones requiere a menudo de extensiones especificas del lenguaje. Para ello, se proporcionan una combinacion unica de mecanismos que facilitan agregar construcciones nuevas al lenguaje en forma de bibliotecas.
Ejemplos
[
editar
]
Hola Mundo escrito en Scala 3
[
editar
]
@main
def
main
()
=
println
(
"Hello, World!"
)
A diferencia de la tipica aplicacion Hello World para Java, no hay declaracion de clase y nada se declara como estatico.
[
3
]
Cuando el programa se almacena en el archivo HelloWorld.scala, el usuario lo compila con el comando:
$ scalac HelloWorld.scala
Y se ejecuta con:
Esto es analogo al proceso de compilacion y ejecucion de codigo Java. De hecho, el proceso de compilacion y ejecucion de Scala es identico al de Java, haciendolo compatible con herramientas como
Apache Ant
.
Una version mas corta del "Hola mundo" en Scala es:
println
(
"Hello, world!"
)
Scala incluye un shell interactivo y soporte de scripting incorporado. Guardado en un archivo llamado HelloWorld2.scala, el cual puede ser ejecutado como script sin prioridad de compilacion usando:
$ scala HelloWorld2.scala
Los comandos tambien pueden ser ingresados en el interprete de Scala, usando la opcion
-e
:
$ scala -e 'println("Hello, World!")'
Las expresiones pueden ser ingresadas en el REPL:
$ scala
Welcome to Scala 2.12.2 (Java HotSpot(TM) 64-Bit Server VM, Java 1.8.0_131).
Type in expressions for evaluation. Or try :help.
scala> List(1, 2, 3).map(x => x * x)
res0: List[Int] = List(1, 4, 9)
scala>
Ejemplo Basico
[
editar
]
El siguiente ejemplo muestra las diferencias entre la sintaxis de Java y Scala.
// Java:
int
mathFunction
(
int
num
)
{
int
numSquare
=
num
*
num
;
return
(
int
)
(
Math
.
cbrt
(
numSquare
)
+
Math
.
log
(
numSquare
));
}
// Scala: Direct conversion from Java
// no import needed; scala.math
// already imported as `math`
def
mathFunction
(
num
:
Int
):
Int
=
{
var
numSquare
:
Int
=
num
*
num
return
(
math
.
cbrt
(
numSquare
)
+
math
.
log
(
numSquare
)).
asInstanceOf
[
Int
]
}
// Scala: More idiomatic
// Uses type inference, omits `return` statement,
// uses `toInt` method, declares numSquare immutable
import
math
.
_
def
mathFunction
(
num
:
Int
)
=
{
val
numSquare
=
num
*
num
(
cbrt
(
numSquare
)
+
log
(
numSquare
)).
toInt
}
Algunas diferencias sintacticas en este codigo son:
- Scala no requiere punto y coma al final de las sentencias.
- Los tipos estan capitalizados:
Int, Double, Boolean
en vez de
int, double, boolean
.
- Parametros y tipos de retorno continuan, como en
Pascal
, en vez de preceder como en
C
.
- Los metodos deben ser precedidos por
def
.
- Variables locales y de clase deben ser precedidos por
val
(indica una variable inmutable) o
var
(indica una variable mutable).
- El operador
return
es innecesario en una funcion (a pesar de estar permitido); el valor de la ultima sentencia o expresion ejecutada es normalmente el valor de la funcion.
- En vez del operador cast
(Type) foo
, Scala usa
foo.asInstanceOf[type]
, o una funcion especializada como
toDouble
o
toInt
.
- En vez de la importacion de paquetes de Java
import foo.*;
, Scala usa
import foo._
.
- Una funcion o metodo
foo()
tambien puede ser llamado solo
foo
; el metodo
thread.send(signo)
tambien puede ser llamado solamente como
thread send signo
; y el metodo
foo.toString()
tambien puede ser llamado solo como
foo toString
.
Ejemplo con Clases
[
editar
]
El siguiente ejemplo contrasta la definicion de clases en Java y en Scala.
// Java:
public
class
Point
{
private
final
double
x
,
y
;
public
Point
(
final
double
x
,
final
double
y
)
{
this
.
x
=
x
;
this
.
y
=
y
;
}
public
Point
(
final
double
x
,
final
double
y
,
final
boolean
addToGrid
)
{
this
(
x
,
y
);
if
(
addToGrid
)
grid
.
add
(
this
);
}
public
Point
()
{
this
(
0.0
,
0.0
);
}
public
double
getX
()
{
return
x
;
}
public
double
getY
()
{
return
y
;
}
double
distanceToPoint
(
final
Point
other
)
{
return
distanceBetweenPoints
(
x
,
y
,
other
.
x
,
other
.
y
);
}
private
static
Grid
grid
=
new
Grid
();
static
double
distanceBetweenPoints
(
final
double
x1
,
final
double
y1
,
final
double
x2
,
final
double
y2
)
{
return
Math
.
hypot
(
x1
-
x2
,
y1
-
y2
);
}
}
|
// Scala
class
Point
(
val
x
:
Double
,
val
y
:
Double
,
addToGrid
:
Boolean
=
false
)
{
import
Point
.
_
if
(
addToGrid
)
grid
.
add
(
this
)
def
this
()
=
this
(
0.0
,
0.0
)
def
distanceToPoint
(
other
:
Point
)
=
distanceBetweenPoints
(
x
,
y
,
other
.
x
,
other
.
y
)
}
object
Point
{
private
val
grid
=
new
Grid
()
def
distanceBetweenPoints
(
x1
:
Double
,
y1
:
Double
,
x2
:
Double
,
y2
:
Double
)
=
{
math
.
hypot
(
x1
-
x2
,
y1
-
y2
)
}
}
|
Referencias
[
editar
]
Enlaces externos
[
editar
]