Scala - Clases y objetos
Este capítulo le explica cómo utilizar clases y objetos en la programación de Scala. Una clase es un plano de objetos. Una vez que defina una clase, puede crear objetos a partir del plano de la clase con la palabra clavenew. A través del objeto puede utilizar todas las funcionalidades de la clase definida.
El siguiente diagrama demuestra la clase y el objeto tomando un ejemplo de clase estudiante, que contiene las variables miembro (nombre y número de rollo) y métodos miembros (setName () y setRollNo ()). Finalmente todos son miembros de la clase. La clase es un plano y los objetos son reales aquí. En el siguiente diagrama, Student es una clase y Harini, John y Maria son los objetos de la clase Student, que tienen nombre y número de rollo.
Clase básica
A continuación se muestra una sintaxis simple para definir una clase básica en Scala. Esta clase define dos variablesx y y y un método: move, que no devuelve un valor. Las variables de clase se llaman, los campos de la clase y los métodos se denominan métodos de clase.
El nombre de la clase funciona como un constructor de clases que puede tomar varios parámetros. El código anterior define dos argumentos de constructor,xc y yc; ambos son visibles en todo el cuerpo de la clase.
Sintaxis
class Point(xc: Int, yc: Int) {
var x: Int = xc
var y: Int = yc
def move(dx: Int, dy: Int) {
x = x + dx
y = y + dy
println ("Point x location : " + x);
println ("Point y location : " + y);
}
}Como se mencionó anteriormente en este capítulo, puede crear objetos usando una palabra clave new y luego puede acceder a los campos y métodos de la clase como se muestra a continuación en el ejemplo:
Ejemplo
import java.io._
class Point(val xc: Int, val yc: Int) {
var x: Int = xc
var y: Int = yc
def move(dx: Int, dy: Int) {
x = x + dx
y = y + dy
println ("Point x location : " + x);
println ("Point y location : " + y);
}
}
object Demo {
def main(args: Array[String]) {
val pt = new Point(10, 20);
// Move to a new location
pt.move(10, 10);
}
}Guarde el programa anterior en Demo.scala. Los siguientes comandos se utilizan para compilar y ejecutar este programa.
Mando
\>scalac Demo.scala
\>scala DemoSalida
Point x location : 20
Point y location : 30Ampliando una clase
Puede extender una clase base de Scala y puede diseñar una clase heredada de la misma manera que lo hace en Java (use extends palabra clave), pero hay dos restricciones: la anulación del método requiere la override palabra clave, y solo la primaryEl constructor puede pasar parámetros al constructor base. Extendamos nuestra clase anterior y agreguemos un método de clase más.
Ejemplo
Tomemos un ejemplo de dos clases, la clase Point (como el mismo ejemplo anterior) y la clase Location es una clase heredada usando la palabra clave extendida. Tal 'extends'tiene dos efectos: hace que la clase Location herede todos los miembros no privados de la clase Point y hace que el tipo Location sea un subtipo del tipo clase Point . Entonces aquí la clase Point se llamasuperclassy la clase Location se llamasubclass. Extender una clase y heredar todas las características de una clase padre se llamainheritance pero Scala permite la herencia de una sola clase.
Note - Métodos método move () en la clase Point y move() method in Location class no anule las definiciones correspondientes de movimiento ya que son definiciones diferentes (por ejemplo, la primera toma dos argumentos mientras que la última toma tres argumentos).
Pruebe el siguiente programa de ejemplo para implementar la herencia.
import java.io._
class Point(val xc: Int, val yc: Int) {
var x: Int = xc
var y: Int = yc
def move(dx: Int, dy: Int) {
x = x + dx
y = y + dy
println ("Point x location : " + x);
println ("Point y location : " + y);
}
}
class Location(override val xc: Int, override val yc: Int,
val zc :Int) extends Point(xc, yc){
var z: Int = zc
def move(dx: Int, dy: Int, dz: Int) {
x = x + dx
y = y + dy
z = z + dz
println ("Point x location : " + x);
println ("Point y location : " + y);
println ("Point z location : " + z);
}
}
object Demo {
def main(args: Array[String]) {
val loc = new Location(10, 20, 15);
// Move to a new location
loc.move(10, 10, 5);
}
}Guarde el programa anterior en Demo.scala. Los siguientes comandos se utilizan para compilar y ejecutar este programa.
Mando
\>scalac Demo.scala
\>scala DemoSalida
Point x location : 20
Point y location : 30
Point z location : 20Clases implícitas
Las clases implícitas permiten conversaciones implícitas con el constructor principal de la clase cuando la clase está dentro del alcance. La clase implícita es una clase marcada con la palabra clave "implícita". Esta función se introduce en Scala 2.10.
Syntax- La siguiente es la sintaxis para clases implícitas. Aquí, la clase implícita siempre está en el alcance del objeto donde se permiten todas las definiciones de método porque la clase implícita no puede ser una clase de nivel superior.
Sintaxis
object <object name> {
implicit class <class name>(<Variable>: Data type) {
def <method>(): Unit =
}
}Ejemplo
Tomemos un ejemplo de una clase implícita llamada IntTimescon el método times (). Significa que times () contienen una transacción de bucle que ejecutará la declaración dada en el número de veces que damos. Supongamos que la declaración dada es “4 veces println (“ Hola ”)” significa que la declaración println (“” Hola ”) se ejecutará 4 veces.
El siguiente es el programa para el ejemplo dado. En este ejemplo se utilizan dos clases de objeto (Ejecutar y Demo) de modo que tenemos que guardar esas dos clases en archivos diferentes con sus respectivos nombres de la siguiente manera.
Run.scala - Guarde el siguiente programa en Run.scala.
object Run {
implicit class IntTimes(x: Int) {
def times [A](f: =>A): Unit = {
def loop(current: Int): Unit =
if(current > 0){
f
loop(current - 1)
}
loop(x)
}
}
}Demo.scala - Guarde el siguiente programa en Demo.scala.
import Run._
object Demo {
def main(args: Array[String]) {
4 times println("hello")
}
}Los siguientes comandos se utilizan para compilar y ejecutar estos dos programas.
Mando
\>scalac Run.scala
\>scalac Demo.scala
\>scala DemoSalida
Hello
Hello
Hello
HelloNote -
Las clases implícitas deben definirse dentro de otra clase / objeto / rasgo (no en el nivel superior).
Las clases implícitas solo pueden tomar un argumento no implícito en su constructor.
Las clases implícitas no pueden ser ningún método, miembro u objeto dentro del alcance con el mismo nombre que la clase implícita.
Objetos Singleton
Scala está más orientado a objetos que Java porque en Scala no podemos tener miembros estáticos. En cambio, Scala tienesingleton objects. Un singleton es una clase que solo puede tener una instancia, es decir, Object. Creas singleton usando la palabra claveobjecten lugar de la palabra clave de clase. Dado que no puede crear una instancia de un objeto singleton, no puede pasar parámetros al constructor principal. Ya ha visto todos los ejemplos usando objetos singleton donde llamó al método principal de Scala.
A continuación se muestra el mismo programa de ejemplo para implementar singleton.
Ejemplo
import java.io._
class Point(val xc: Int, val yc: Int) {
var x: Int = xc
var y: Int = yc
def move(dx: Int, dy: Int) {
x = x + dx
y = y + dy
}
}
object Demo {
def main(args: Array[String]) {
val point = new Point(10, 20)
printPoint
def printPoint{
println ("Point x location : " + point.x);
println ("Point y location : " + point.y);
}
}
}Guarde el programa anterior en Demo.scala. Los siguientes comandos se utilizan para compilar y ejecutar este programa.
Mando
\>scalac Demo.scala
\>scala DemoSalida
Point x location : 10
Point y location : 20