Scala基础知识(个人总结)

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

变量和数据类型:

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

  变量命名规则:

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

字符串:

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

•   // 格式化模板字符串 f %2.2f
    println(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 10
    j = 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 RuntimeException
      println(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 + b
	case '-' => a - b
	case '*' => a * b
	case '/' => a / b
	case _ => "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")
	}
}

泛型:

1. 泛型上限为Person

   Class PersonList[T <: Person]{ }

2. 泛型下限为Person

   Class PersonList[T >: Person]{ }