Scala从入门到精通01之基础介绍
1. scala overview
Diagram in Scala, Java and JVM
2. Scala install
based on the official website: https://www.scala-lang.org/
- install JDK1.8 first
- download the relevant scala install package
- unpackage the scala
- add the environment path
3. Write the first scripts in Scala
hello world
package com.michael.learn.day01
object HelloWorld {
/* compare with the main in java: public static void main(String[] args) {}
main method is the entry of the whole program
which in the parenthesis is parameter list
declare parameters in java: param_type param_name like String str
declare parameters in scala: param_name: param_type like args: Array[String]
modifier public: There is no public in scala, it means the method is public if access is not declared
modifier static: There is no static in scala, cause there is no static grammar
modifier void: There is no void in scala but Unit instead
declare a method in scala:
method_name(para_list): The_type_of_return
use def to declare if you need to define a method
* */
def main(args: Array[String]): Unit = {
println("Hello scala")
System.out.println("Hello scala with java grammar")
}
}
4. Scala grammar
4.1. Variables and data types in Scala
4.1.1. Variables & Constant
4.1.2. Data types
1）Scala中一切数据都是对象，都是Any的子类。
2）Scala中数据类型分为两大类：数值类型（AnyVal）、引用类型（AnyRef），不管是值类型还是引用类型都是对象。
3）Scala数据类型仍然遵守，低精度的值类型向高精度值类型，自动转换（隐式转换）
6）Null是一个类型，只 有一个对 象就 是null。它是所有引用类型（AnyRef）的子类。
7）Nothing，是所有数据类型的子类，主要用在一个函数没有明确返回值时使用，因为这样我们可以把抛出的返回值，返回给任何的变量或者函数。
4）Scala中的StringOps是对Java中的String增强
5）Unit：对应Java中的void，用于方法返回值的位置，表示方法没有返回值。Unit是 一个数据类型，只有一个对象就是()。Void不是数据类型，只是一个关键字
Unit 类型、Null 类型和 Nothing 类型
| 数据类型 | 描述 |
|---|---|
| Unit | 表示无值，和其他语言中 void 等同。用作不返回任何结果的方法的结果类型。Unit 只有一个实例值，写成()。 |
| Null | null , Null 类型只有一个实例值 null |
| Nothing | Nothing 类型在 Scala 的类层级最低端；它是任何其他类型的子类型。当一个函数，我们确定没有正常的返回值，可以用 Nothing 来指定返回类型，这样有一个好处，就是我们可以把返回的值（异常）赋给其它的函数或者变量（兼容性） |
package com.michael.learn.day01
import com.michael.learn.entity.Animal
object DatTypes {
def main(args: Array[String]): Unit = {
// Unit 类型用来标识过程，也就是没有明确返回值的函数
def unitTest: Unit = {
}
println(unitTest) // ()
}
// null 可以赋值给任意引用类型（AnyRef），但是不能赋值给值类型（AnyVal）
var cat = new Animal()
cat = null
// var n1:Int = null // Exception
// println("n1:" + n1)
// Nothing，可以作为没有正常返回值的方法的返回类型，非常直观的告诉你这个方法不会正常返回，而且由于 Nothing 是其他任意类型的子类，他还能跟要求返回值的方法兼容。
def test():Nothing = {
throw new Exception()
}
test
}
4.1.3. Date types transfer automatically
package com.michael.learn.day01
object DataTypeAutoTransfer {
def main(args: Array[String]): Unit = {
// 自动提升原则：有多种类型的数据混合运算时，系统首先自动将所有
// 数据转换成精度大的那种数值类型，然后再进行计算
var n = 1 + 2.0
println(n) // 3.0
// 把精度大的数值类型赋值给精度小的数值类型时，就会报错，反之就
// 会进行自动类型转换。
var n2:Double = 1.0
// var n3:Int = n2 // Error
// （byte，short）和 char 之间不会相互自动转换
var n4:Byte = 1
// var c1: Char = n4 // Error
var n5:Int = n4
println(n5)
//
var n6:Byte = 1
var c2:Char = 1
// var n7:Short = n6 + c2 // Error
// var n8:Short = 10+90 // Error
}
}
4.2 Process control
4.2.1. Basic
package com.michael.learn.day01
object ProcessControl {
def main(args: Array[String]): Unit = {
// if
var age = 19
if(age >= 18){
println("adult")
}
// if else
age = 15
if(age >= 18){
println("adult")
}else{
println("juvenile")
}
// if else with multiple else if
age = 5
if(age >= 18){
println("adult")
}else if(age > 10){
println("juvenile")
}else{
println("kid")
}
// Scala 中 if else 表达式其实是有返回值的，具体返回值取决于满足条件的
// 代码体的最后一行内容
age = 3
val result :String = if(age >= 18){
"adult"
}else if(age > 10){
"juvenile"
}else{
"kid"
}
println(result)
// Scala 中返回值类型不一致，取它们共同的祖先类型
age = 2
val result2 :Any = if(age >= 18){
"adult"
}else if(age > 10){
"juvenile"
}else{
100
}
println(result2)
// 如果大括号{}内的逻辑代码只有一行，大括号可以省略。如果省略大括号
// if只对最近的一行逻辑代码起作用。
val result3:Any = if ( age < 18) "juvenile" else "adult"
"no effect"
println(result3)
}
}
4.2.2. For loop
package com.michael.learn.day01
object ProcessControlForLoop {
def main(args: Array[String]): Unit = {
// 1. Range data loop (to) i 将会从 1-3 循环，前后闭合
for(i <- 1 to 3){
print(i + " ") // 1 2 3
}
println()
// 2. Range data loop (until) 前闭合后开的范围
for (i <- 1 until 3){
print(i + " ") // 1 2
}
println()
// 3. Loop guard 循环守卫，即循环保护式（也称条件判断式，守卫）。保护式为 true 则进入循环
// 体内部，为 false 则跳过，类似于 continue
for (i <- 1 to 3 if i != 2){
print(i + " ") // 1 3
}
println()
for (i <- 1 to 3){
if (i != 2) {
print(i + " ") // 1 3
}
}
println()
// 4. loop step
for (i <- 1 to 10 by 2) { // 2 is the step
print(i + " ") // 1 3 5 7 9
}
println()
// 5. Nested loop
for (i <- 1 to 3; j <- 1 to 4){ // 没有关键字，所以范围后一定要加；来隔断逻辑
print("ij:" + i + j + " ") // ij:11 ij:12 ij:13 ij:14 ij:21 ij:22 ij:23 ij:24 ij:31 ij:32 ij:33 ij:34
}
println()
// 6. Reference variable in loop statement
for(i <- 1 to 3; j = 4 - i){ // for 推导式一行中有多个表达式时，所以要加 ; 来隔断逻辑
print("ij:" + i + j + " ") // ij:13 ij:22 ij:31
}
println()
// for 推导式有一个不成文的约定：当 for 推导式仅包含单一表达式时使用圆括号，
// 当包含多个表达式时，一般每行一个表达式，并用花括号代替圆括号，如
for {
i <- 1 to 3
j = 4 - i
}{
print("ij:" + i + j + " ") // ij:13 ij:22 ij:31
}
println()
// 7. Return value in loop process
val result5 = for(i <- 1 to 10) yield i
println(result5) // Vector(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
// 8. Reverse print in loop
for (i <- 1 to 10 reverse){
print(i + " ") // 10 9 8 7 6 5 4 3 2 1
}
}
}
4.2.3. While loop
package com.michael.learn.day01
object ProcessControlWhileLoop {
def main(args: Array[String]): Unit = {
// 1. while 与 for 语句不同，while 语句没有返回值，即整个 while 语句的结果是 Unit 类型()
var i = 0
while (i < 10){
print(i + " ") // 0 1 2 3 4 5 6 7 8 9
i += 1
}
println()
// 2. do while
var j = 0
do {
print(j + " ") // 0 1 2 3 4 5 6 7 8 9
j += 1
}while(j < 10)
}
}
4.2.4. Loop Interrupt
package com.michael.learn.day01
import scala.util.control.Breaks
import scala.util.control.Breaks.{break, breakable}
object LoopInterrupt {
def main(args: Array[String]): Unit = {
// 1. Exit the loop with an exception
try {
for(i <- 1 to 10){
print(i + " ")
if (i == 5) throw new RuntimeException
}
}
catch {
case e =>
}
println()
println("The loop ends normally")
// 2. Exit the loop by the scala function
Breaks.breakable(
for(i <- 1 to 10){
print(i + " ")
if (i == 5) Breaks.break()
}
)
println()
println("The loop ends normally with breaks")
// break can be omitted
breakable {
for (i <- 1 to 10){
print(i + " ")
if (i == 5) break
}
}
println()
println("The loops ends normally with omitting break")
}
}
4.3. Operator
package com.michael.learn.day01
object Operator {
def main(args: Array[String]): Unit = {
// standard addition
val i:Int = 1.+(1)
// when calling methods on objects, . can be omitted
val j:Int = 1 + (1)
// When there is only one para, () can be omitted
val k:Int = 1 + 1
println(i)
println(j)
println(k)
println(1.toString())
println(1 toString())
println(1 toString)
}
}