Scala基础知识(个人总结)

声明: 1. 本文为我的个人复习总结, 并非那种从零基础开始普及知识 内容详细全面, 言辞官方的文章
2. 由于是个人总结, 所以用最精简的话语来写文章
3. 若有错误不当之处, 请指出

变量和数据类型:

变量声明时, 无论是val还是var 都必须要有初始值

变量命名规则:
1. 字母、数字、下划线的组合, 且数字不能作为开头
2. 可以以操作符开头, 且只包含操作符(+ - * / # !等)
3. 用反引号包含任何字符串作为变量, 即使是Scala关键字（39个）也可以

字符串:

  // * 用于将一个字符串复制多次并拼接println(name * 3)

  // 格式化模板字符串 f %2.2fprintln(f"The num is ${num}%2.2f")

  // 三引号表示字符串, 保持多行字符串的原格式输出val sql =s"""|select *|from|  student|where|  name = 张三|and|  age > 20|""".stripMargin

标准输入:

StdIn.readLine( )

StdIn.readInt( )

文件IO:

// 1. 从文件中读取数据
Source.fromFile("src/main/resources/test.txt").foreach(print)// 2. 将数据写入文件
val writer = new PrintWriter(new File("src/main/resources/output.txt"))
writer.write("hello scala from java writer")
writer.close( )

Scala真正做到了万物皆对象, 没有基本数据类型

数据类型:

Any -> AnyVal AnyRef
AnyVal 的子类Unit有唯一对象是 ( )
AnyRef 的子类Null有唯一对象是 null
最低级类为Nothing, 当返回抛出的异常时就是返回Nothing类型, 可以被任何类型所接收

强制类型转换:

“123”.toByte, 123.toByte

运算符:

==就是equals( )
运算符的本质是一个方法, + 是 .+( )
Scala中没有++、–操作符
+=没有Java中的强转功能

流程控制:

if else:

// 没有三元运算符,但可以接收if else语句的返回值,{}加不加都行
// val res2 = if (age >= 18) "成年" else "未成年"

循环:

// 1. 范围遍历
for (i <- 1 to 10) {}
for (i: Int <- 1.to(10)) {}for (i <- Range(1, 10)) {}
for (i <- 1 until 10) {}// 2. 集合遍历
for (i <- Array(12, 34, 53)) {println(i)
}// 3. 循环守卫
for (i <- 1 to 10 if i != 5) {println(i)
}// 4. 循环步长
for (i <- 1 to 10 by 2) {println(i)
}
// 5. 反向打印
println("-------------------")
for (i <- 1 to 10 reverse) {println(i)
}// 5. 循环嵌套
for (i <- 1 to 4; j <- 1 to 5) {println("i = " + i + ", j = " + j)
}// 6. 循环引入变量for (i <- 1 to 10; j = 10 - i) {}for {i <- 1 to 10j = 10 - i
} {}// 7. 循环返回值
val b: immutable.IndexedSeq[Int] = for (i <- 1 to 10) yield i * i
// b = Vector(1, 4, 9, 16, 25, 36, 49, 64, 81, 100)
println("b = " + b)

跳出循环:

Scala没有break和continue, 想跳出循环, 需要:

  // 1. 使用Scala中的Breaks类的break方法, 实现异常的抛出和捕捉; Breaks类名可以省略Breaks.breakable(for (i <- 0 until 5) {if (i == 3)Breaks.break()println(i)})println("这是循环外的代码")// 2. 采用抛出异常的方式, 退出循环try {for (i <- 0 until 5) {if (i == 3)throw new RuntimeExceptionprintln(i)}} catch {case e: Exception =>             // 什么都不做, 只是退出循环}
}

面向对象:

伴生对象:

/*object: 单例对象（伴生对象, 即代替了static）。子类对非抽象类子类 的对非抽象属性重写, 父类非抽象属性只支持 val 类型, 而不支持 var。*/
object HelloWorld {/*def 方法名称(参数名称: 参数类型): 返回值类型 = { 方法体 }*/def main(args: Array[String]): Unit = {println("hello world")System.out.println("hello scala from java")}
}

Scala中属性也可以重写
Scala中属性和方法都是动态绑定, 而 Java 中只有方法为动态绑定
重写非抽象方法需要用 override 修饰, 重写抽象方法则可以不加 override
特质=抽象类+接口
导包:
- 通配符导入: import java.util._
- 可以局部导入, 不必非得写在最开头
- _root_是最顶级隐式的包
Bean属性（@BeanPropetry）, 可以自动生成规范的set/get方法
权限:
- Scala里没有public关键字, 因为默认就是public权限
- private为私有权限, 只在类的内部和伴生对象中可用
- protected 同类、子类可以访问, 同包无法访问
- private[包名]增加包访问权限, 包名下的其他类也可以使用
语法示例:
- 定义变量: private var name: String = “xxx”
- 定义方法: def main(args: Array[String]): Unit = { }
构造器:
1. 主构造器: class 类名(形参列表) { }
2. 辅助构造器: def this(形参列表) { }
辅助构造器必须通过主构造器来new 对象

构造器调用其他另外的构造器时要求被调用构造器必须提前声明
方法参数:
1. 未用任何修饰符修饰, 局部变量
2. var修饰, 作为类的成员属性使用
3. val修饰, 作为类的成员属性使用
创建对象的方式:
1. new 构造器
2. 伴生对象的apply方法
使用type关键字可以给数据数据类型起别名, 类似于C语言的typedef
isInstanceOf[T] 和 asInstanceOf[T]

函数式编程:

闭包: 一个函数访问到了它的外部的局部变量的值

函数柯里化: 把一个参数列表的多个参数, 变成多个参数列表

类中的函数称之方法

函数没有重载和重写的概念

函数可以作为值进行传递

函数可以作为参数进行传递

函数可以作为函数返回值返回

集合:

三大类: Seq, Set, Map

不可变集合：scala.collection.immutable(每次修改都会返回一个新的对象)
可变集合： scala.collection.mutable(对原对象进行修改)

不可变数组: Array

可变数组: ArrayBuffer

Nil是空集合的意思

元组: 即元素的组合, 数据类型可以不同; 元组比较大小时, 是从前到后依次比较

模式匹配:

类似于Java中的switch语法; 不需要使用break语句, 它自动中断case

var result = myChar match {case '+' => a + bcase '-' => a - bcase '*' => a * bcase '/' => a / bcase _ => "illegal"
}

模式守卫:

如果想要表达匹配某个范围的数据, 就需要用条件守卫

case i: Int if i >= 0 => i
case j: Int if j < 0 => -j

匹配类型:

case i: Int => "Int"
case s: String => "String hello"

匹配数组:

case Array(0, _*) => "以0开头的数组"

隐式转换:

当编译器第一次编译失败的时候, 会在当前的环境中查找能让代码编译通过的方法, 用于将类型进行转换, 实现二次编译

使用implicit关键字

异常:

def main(args: Array[String]): Unit = {try {var n= 10 / 0}catch {case ex: ArithmeticException=>{//发生算术异常println("发生了算术异常")}case ex: Exception=>{// 对异常处理println("发生了异常")}}finally {println("finally")}
}

泛型:

泛型上限为Person

Class PersonList[T <: Person]{ }
泛型下限为Person

Class PersonList[T >: Person]{ }