scala常见的操作

1. scala是什么

Scala是一门主要以Java虚拟机(JVM)为目标运行环境并将面向对象和函数式编程语言的最佳特性综合在一起的编程语言。

RERL: “读取-求值-打印”。解释器读取到一个表达式，对它求值，将它打印出来 ，然后再接着继续读取下一个表达式。

2. 语法糖

2.1 基础语法

2.2 函数

2.3 类和对象

类是对象的蓝图。定义了类，就可以通过new关键字进行对象的实例化操作。

面向对象的最主要的特征：责任分工

  • 任何一个业务系统，都是由多个对象交互而成
  • 任何一个对象不孤立存在，对象与对象之间一定存在交互

好处： 责任分工

什么是类？
什么是对象？
类与对象的区别？

单独拿出来说，不好说不清楚的。

  • 任何一个业务系统都是由多个对象交互而成。
  • 为了能使多个对象交互来完成整个业务系统， 所以我们需要使用类来定义不同对象的属性和行为。
  • 类是定义对象的模版，对象是实际完成业务系统功能的最小单元组成单元。

2.3.1 封装

  1. 封装的好处
    1. 保证每个对象的完整性
    2. 保证对象与对象之间的隔离性
class User {
    private var id = 1001
    private var name = "bob"
    private var age = 18
} // 通过 getter setter访问

class User {
    private var userId: Int = _
    private var userName: String = _
    private var userAge: Int = _
    
    def getUserId: Int = this.userId
	
    def setUserId(newValue: Int): Unit = {
        this.userId = userId
    }
}

  1. 主构造器

    class User (id: Int, name: String, age: Int) {
    private var userId = id
    private var userName = name
    private var userAge = age
       
    def show(): Unit = {
        println("UserId: " + this.userId + " userName: " + this. userName
               " userAge: " + this.userAge)
    }
}

  2. 方法重写

    override def toString: String = {
    "userId: " + this.userId +
    ", userName: " + this.userName +
    ", userAge:" + this.userAge
}

  3. 先决条件

    class User(id: Int, name: String, age: Int) {
    require (age > 18)
    require (!name.isEmpty)
       
    private var userId = id
    private var userName = name
    private var userAge = age
}

  4. 主构造器与辅助构造器

    class User (id: Int, name: String,) {
    private var userId = id
    private var userName = name
    private var userAge = age
       
    def this(id: Int, name:String, age: Int) {
        this(id, name, age)
        this.userId = id
        this.userName = name
    }
       
    def show(): Unit = {
        println("UserId: " + this.userId + " userName: " + this. userName
               " userAge: " + this.userAge)
    }
}

2.3.2 继承

  1. public 共有
  2. private 私有
  3. protected 同一个包下，以及其继承的子类
  4. friendly(default) 同一个包下​
abstarct class Father {
    def say(): Unit = {
        println(" I'm your daddy")
    }
    def eat(): Unit
}

class Son extends Father {
    override def say(): Unit = {
        println("hello baba")
    }
    override def eat(): Unit = {
        println("what fuck???")
    }
}

继承，它的缺点？

  • 只支持单继承

只能单继承，但可以多实现

2.3.3 多态

2.4 object对象

2.5 包的可见性

2.6 集合类型

2.7 映射

2.8 元组

2.9 样例类

3 泛型

如果不用泛型会怎么样？

  1. 无法预估以及约束人为操作
  2. JVM在每次加载这些没有指定泛型的集合时，会执行类型检查 ， 又会产生性能开销。

使用泛型的好处

  1. 解决人为误操作问题
  2. 在编译阶段就能对集合元素进行检查 ，减少开销

4. 隐式转换

当前程序在程序的过程中，如果出现需要类型转换的操作。

优先会在当前程序的作用域中寻找可用的implicit关键字的标准隐式转换函数

implicit def strToInt(s: String) : Int = s.toInt
implicit def add(s: Int, y: Int) : Int = x + y

def main(args: Array[String]): Unit = {
    val s: String = "100"
    val i: Int = 100
    println(add(s,i))
}

5. Actor并发编程