Autor: Magic Good Fuente: Hang Seng LIGHT Cloud Community
Serie Scala:
2 horas para aprender trucos del lenguaje de programación de big data Scala
prefacio
Para aprender profundamente los principios subyacentes de los marcos de código abierto de big data, como el marco de big data Spark y Fink, debe aprender el lenguaje de programación Scala. Este artículo resumirá la sintaxis avanzada de Scala, lo ayudará a aprender rápidamente la sintaxis de Scala con ejemplos y aprenderá a comprender el código fuente de los marcos de código abierto relacionados.
Programación Orientada a Objetos en Scala
Scala orientado a objetos y Java son similares en el sentido de que ambos son de herencia única. Una clase está decorada con Class, un objeto está decorado con Object, una clase es una abstracción de un objeto y un objeto es una instancia de una clase.
modificador de acceso
Los modificadores de acceso de Scala son básicamente los mismos que los de Java, respectivamente: public, protected, privatey por defecto, los niveles de acceso a objetos no especificados son todos public.
público
publicLos miembros modificados se pueden usar directamente en cualquier lugar, solo comprenda los siguientes ejemplos
class Outer {
class Inner {
// 默认就是 public 修饰
def fun() {
println("fun do") }
class InnerMore {
fun() // 可以调用
}
}
}
protegido
protectedSolo permita acceder a los miembros protegidos en las subclases de la clase en la que se define el miembro, comprenda los siguientes ejemplos:
class Outer {
protected def fun() {println("fun do")}
}
class Inner extends Outer {
fun() // 只能子类访问
}
privado
privateSolo visible dentro de la clase u objeto que contiene la definición del miembro, comprenda los siguientes ejemplos:
class Outer{
class Inner{
private def fun(){
println("fun do")
}
class InnerMost{
fun() // 可以调用
}
}
}
clase
Una clase en Scala es un modelo para crear un objeto, que contiene métodos, constantes, variables, tipos, objetos, rasgos, clases, que se denominan colectivamente miembros . Una definición de clase más simple es palabra clave class+ identificador, la primera letra del nombre de la clase debe estar en mayúscula:
// 定义类
class Person
// 通过类创建一个对象
val jack = new Person
Por supuesto, en el desarrollo real, una clase tan simple generalmente no está definida, generalmente hay constructores, miembros, etc.:
// 类的构造器是在传参就定义，数据类型不能省略
class Point(var _x : Int = 0, var _y : Int = 0) {
private val bound = 100
// getter 方法
def x = _x
// setter 方法，后面加上了 _=
def x_=(newValue: Int): Unit = {
if (newValue < bound) _x = newValue else printOutBoundWarn
}
def y = _y
def y_=(newValue: Int): Unit = {
if (newValue < bound) _y = newValue else printOutBoundWarn
}
private def printOutBoundWarn = println("Warning: Out of bound")
// toString覆盖了AnyRef中的toString方法，所以用了override关键字标记
override def toString: String =
s"($x, $y)"
}
object ObjectClass {
def main(args : Array[String]): Unit = {
// 关键字new被用于创建类的实例
var point : Point = new Point
point.x = 100
println(point.toString)
}
}
Tenga en cuenta la sintaxis especial para el método setter: este método agrega _= después del método getter, seguido de los parámetros.
rasgo
Los rasgos se utilizan para compartir interfaces de programa y campos entre clases.
Los rasgos son similares a las interfaces de Java 8, las clases y los objetos (objetos) pueden extender los rasgos, pero los rasgos no se pueden instanciar, por lo que los rasgos no tienen parámetros.
Definición simple de rasgo, palabra clave trait+ identificador:
trait HairColor
Para una comprensión más profunda trait, tome el iterador como Iteratorejemplo :
// 定义 Iterator 特质，A 为泛型
trait Iterator[A] {
def hasNext: Boolean
def next(): A
}
La extensión
trait Iterator [A]requiere un tipo A y métodos de implementaciónhasNextynext.
// 定义一个类继承 Iterator 特质，并扩展其成员方法
class IntIterator(to: Int) extends Iterator[Int] {
private var current = 0
override def hasNext: Boolean = current < to
override def next(): Int = {
if (hasNext) {
val t = current
current += 1
t
} else 0
}
}
val iterator = new IntIterator(10)
iterator.next() // returns 0
iterator.next() // returns 1
// 定义 Iterator 特质类型集合，但实现需要其子类
val list = List.empty[Iterator]
objeto único
Un objeto singleton en Scala es una clase especial que tiene exactamente una instancia. Es una variable perezosa, el objeto singleton se crea de forma perezosa, cuando se usa por primera vez.
Cuando el objeto se define en una clase o método, un objeto singleton se comporta como una variable perezosa.
La sintaxis para definir un singleton es similar a la de definir una clase:
object User
La definición de un objeto singleton se puede reutilizar en cualquier otro lugar, se puede entender como un objeto estático en Java
object Logger {
def info(message: String): Unit = println(s"INFO: $message")
}
class Test {
info("Created projects")
}
var test = new Test // Prints "INFO: Created projects"
objeto compañero
Un objeto complementario en Scala es cuando un objeto singleton comparte un nombre con una clase. Por la misma razón, se dice que esta clase es la clase compañera del objeto singleton . Una clase y sus objetos complementarios pueden acceder a los miembros privados de los demás .
Utilice objetos complementarios para definir variables miembro o métodos que existen en la clase complementaria independientemente del objeto instanciado.
staticLos miembros en Java corresponden a miembros ordinarios de objetos complementarios en Scala.
Un ejemplo de la definición de un objeto complementario:
import scala.math._
class Circle(radius: Double) {
def area: Double = calculateArea(radius)
}
// 对象可以直接访问类的私有成员 radius
object Circle {
private def calculateArea(radius: Double): Double = Pi * pow(radius, 2.0)
}
val circle = Circle(5.0)
circle.area
Nota: la clase y su objeto complementario deben definirse en el mismo archivo de origen. Si necesita definir una clase y su objeto complementario en el REPL, debe definirlos en la misma línea o ingresar al modo: pegar.
clase genérica
Cuando se define una clase y no se puede confirmar el tipo del parámetro de entrada, se necesita una clase genérica para representar temporalmente el tipo de parámetro, y este tipo es el tipo genérico. Las clases genéricas usan corchetes []para aceptar parámetros de tipo. Una convención es usar letras Acomo identificadores de parámetros, aunque se puede usar cualquier nombre de parámetro.
class Car[A] {
private var passager: List[A] = Nil
}
// 实例后传入参数只能为实例的入参
var car = new Carp[Int]
Los subtipos de tipos genéricos no son conductores .
Coincidencia de patrones Scala
El patrón de coincidencia en Scala, para la switchdeclaración devuelve el resultado correspondiente según la coincidencia de parámetros. Comprende los siguientes casos:
object ModeMatch {
def main(args: Array[String]): Unit = {
// 模式匹配案例
val x = 2;
println(mode(x)); // b
}
// 定义匹配规制，可以理解策略匹配
def mode(t: Int): String = t match {
case 1 => "a" // 如果输入参数为 1， 则匹配本条件
case 2 => "b"
case _ => "c" // 如果以上条件都不匹配，则返回本条
}
}
E/S de archivo Scala
Para la lectura y escritura de archivos en Scala se suelen utilizar clases de E/S en Java:java.io.File
leer entrada
Si necesita leer la entrada del usuario desde el teclado, vea los siguientes ejemplos:
import scala.io.Source
object FileIo {
def main(args : Array[String]): Unit = {
// 读取文件写入的内容
var reader = StdIn.readLine();
println("输入的内容为:" + reader)
}
}
archivo de escritura
Si necesita simplemente escribir en el archivo, puede consultar los siguientes casos:
import java.io._
object FileIo {
def main(args : Array[String]): Unit = {
// 新建一个文件流写入对象
val writer = new PrintWriter(new File("scala.txt" ))
// 向文件中写入内容
writer.write("文件IO")
writer.close()
}
}
Después de ejecutar el programa, puede ver el archivo recién creado:
lectura de archivos
A través de la scala.io.Sourceclase , puede leer directamente el contenido del archivo y puede comprender los siguientes ejemplos:
import scala.io.Source
object FileIo {
def main(args : Array[String]): Unit = {
// 读取文件写入的内容
Source.fromFile("scala.txt" ).foreach{
print
}
}
}
manejo de excepciones
El manejo de excepciones en Scala es básicamente lo mismo que Java, para returninterrumpir directamente la ejecución del programa para no pasar. Comprende los siguientes casos:
import java.io.{FileNotFoundException, FileReader, IOException}
object OutException {
def main(args: Array[String]): Unit = {
try {
val file = new FileReader("scala.txt")
println("file :" + file)
} catch { // 如果 try 中语句块执行异常，则会进行捕捉进行以下操作
// case 用来匹配异常错误类型
case ex: FileNotFoundException => {
println("文件未找到异常")
}
case ex: IOException => {
println("IO 异常")
}
} finally { // finally 不管 try 中的程序是否异常，都会执行
println("程序执行结束")
}
}
}
Resumir
Este artículo resume la introducción de conocimientos avanzados, como el conocimiento orientado a objetos de Scala. Después de comprender, puede comenzar el aprendizaje introductorio del marco de big data. Si está muy interesado en Scala, puede visitar el sitio web oficial de Scala para conocer sus API Finalmente, se compartirán los conocimientos relevantes de Scala.