Scala学习笔记

2019-05-29 本文已影响0人董可伦

我的原创地址：https://dongkelun.com/2018/12/14/scalaLearningNotes/

前言

之前看Scala编程思想学习Scala，只看完了一半多，就没再继续深入学习，导致一些Scala基础知识还不知道，而且过去这么长时间了，之前学过的也遗忘了，所以这里主要记录自己学习Scala时容易遗忘的一些点，以备自己随时查看，增加记忆。这个主要给自己用，不定时更新添加~

1、在线文档

https://docs.scala-lang.org/zh-cn/tour/tour-of-scala.html

2、一些点

setter

setter方法是在getter方法的后面加上_=，后面跟着参数

构造方法的参数

主构造方法中带有val和var的参数时公有的。然而由于val是不可变的，所以不能像下面这样去使用。

class Point(val x: Int, val y: Int)
val point = new Point(1, 2)
point.x = 3  // <-- does not compile

不带val或var的参数是私有的，仅在类中可见。

class Point(x: Int, y: Int)
val point = new Point(1, 2)
point.x  // <-- does not compile

特质

之前只知道trait，Scala的接口用trait，而不知道Scala特质，其实特质就是trait...

特质 (Traits) 用于在类 (Class)之间共享程序接口 (Interface)和字段 (Fields)。它们类似于Java 8的接口。类和对象 (Objects)可以扩展特质，但是特质不能被实例化，因此特质没有参数。

使用特质：使用 extends 关键字来扩展特质。然后使用 override 关键字来实现trait里面的任何抽象成员

trait Iterator[A] {
  def hasNext: Boolean
  def next(): A
}

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

实现多个Traits用with关键字

extends Trait1 with Trait2 with Trait3

隐式参数

方法可以具有隐式参数列表，由参数列表开头的 implicit 关键字标记。如果参数列表中的参数没有像往常一样传递， Scala 将查看它是否可以获得正确类型的隐式值，如果可以，则自动传递。

简单的程序示例：

def fun(a:Int)(implicit b:Int = 0) = {
    println(a,b)
}

fun(1) 结果:(1,0)

添加隐式值：

implicit val implicitInt:Int = 10

结果变为：(1,10)

参数b为隐式参数，调用fun时不能传参数b，首先会找隐式定义类型为Int的值，如果找到（implicitInt），则传隐式值（implicitInt），找不到传默认值，没有默认值且没有隐式值，会报错:

◾could not find implicit value for parameter b: Int
◾not enough arguments for method fun: (implicit b: Int)Unit. Unspecified value parameter b.

不能有多个相同类型的隐式值，否则，调用fun函数时，会报冲突的异常：

◾ambiguous implicit values: both value implicitInt in object ImplicitTest of type ⇒ Int and value implicitInt2 in object ImplicitTest of type ⇒ Int match expected type Int...

@transient

这个注解一般用于序列化的时候，标识某个字段不用被序列化。

SerializationDemo.scala

package com.dkl.scalabasic

import java.io.FileOutputStream
import java.io.ObjectOutputStream

class Hippie(val name: String, @transient val age: Int) extends Serializable

/**
 * 序列化，测试@transient
 */
object SerializationDemo {

  def main(args: Array[String]): Unit = {
    val fos = new FileOutputStream("hippie.txt")
    val oos = new ObjectOutputStream(fos)

    val p1 = new Hippie("zml", 34)
    oos.writeObject(p1)
    oos.close()
  }

}

DeserializationDemo.scala

package com.dkl.scalabasic

import java.io.FileInputStream
import java.io.ObjectInputStream

/**
 * 反序列化，测试@transient
 */
object DeserializationDemo {
  def main(args: Array[String]): Unit = {
    val fis = new FileInputStream("hippie.txt")
    val ois = new ObjectInputStream(fis)

    val hippy = ois.readObject.asInstanceOf[Hippie]
    println(hippy.name)
    println(hippy.age)
    ois.close()

  }

}

运行结果：

zml
0

由于age被标记为@transient，在反序列化的时候，就获取不到原始值了所以被赋值为默认值。
出自：Scala基础之注解(annotation)