Scala自学--基础

一、第一个scala案例与java不同的语法点

1、参数声明方式: scala--> 参数名 :类型，java--> 类型 参数名

2、public关键字：scala中没有public关键字，默认是公共的。

3、unit类型：相当于Java中的void，表示没有返回值

4、scala中声明方法使用def关键字

5、static关键字：scala中无static关键字，由object实现静态方法的功能

object hello {
  def main(args: Array[String]): Unit = {
    println("hello scala")
  }
}

二、变量和数据类型

2.1注释

• 单行注释：//
• 多行注释：/**/
• 文档注释：

object test1 {
  def main(args: Array[String]): Unit = {
    //单行注释
    
    /*
    多行注释
     */

    /**
     * @author
     * 
     */
  }

}

2.2变量和常量

能用常量的地方不用变量

变量：var 变量名 [: 变量类型]=初始值     

var a:Int=10

常量：val 常量名 [: 常量类型]=初始值

val b:Char='b'

 2.2.1案例实践

1、声明变量时，类型可以省略，编译器自动推导，即类型推导

2、类型确定后，就不能修改

3、变量声明时，必须要有初始值

4、在声明/定义一个变量时，可以使用 var 或者 val 来修饰，var 修饰的变量可改变，val 修饰的变          量不可改。

5、var 修饰的对象引用可以改变，val 修饰的对象则不可改变，但对象的状态（值） 却是可以改变的。（比如：自定义对象、数组、集合等等）

2.3标识符

1、命名规则

1. 以字母或者下划线开头，后接字母、数字、下划线
2. 以操作符开头，且只包含操作符（+ - * / # !等）
3. 用反引号` `包括的任意字符串，即使是 Scala 关键字（39 个）也可以

• package, import, class, object, trait, extends, with, type, for
• private, protected, abstract, sealed, final, implicit, lazy, override
• try, catch, finally, throw
• if, else, match, case, do, while, for, return, yield
• def, val, var
• this, super
• new
• true, false, null

 2.4字符串输出

1）字符串，通过+号连接

2）printf 用法：字符串，通过%传值

3)  多行字符串，在Scala 中，利用三个双引号 包围的 stripMargin方法就可以实现

2.4.1案例实践

//（1）字符串，通过+号连接
    println("菱形"+"展示"+":")
    //(3)多行字符串，在Scala 中，利用三个双引号
    //   包围的 stripMargin方法就可以实现。
     val s=
       """
         |    *
         |  * * *
         |* * * * *
         |  * * *
         |    *
         |""".stripMargin
    println(s)
    //（2）printf 用法：字符串，通过%传值。
    printf("%s","展示结束")

 

2.5 键盘输入

2.5.1、基本语法

1、引入import scala.io.StdIn包

2、使用StdIn.readLine()、StdIn.readShort()、StdIn.readDouble()

2.5.2案例实践

import scala.io.StdIn
object test1 {
  def main(args: Array[String]): Unit = {
    // 1 输入姓名
    println("input name:")
    var name = StdIn.readLine()

    // 2 输入年龄
    println("input age:")
    var age = StdIn.readShort()

    // 3 输入薪水
    println("input sal:")
    var sal = StdIn.readDouble()

    // 4 打 印
    println("name=" + name)
    println("age=" + age)
    println("sal=" + sal)
  }
}

2.6数据类型

1）Scala中一切数据都是对象，都是Any的子类。
2）Scala中数据类型分为两大类：数值类型（AnyVal）、 引用类型（AnyRef），不管是值类型还是引用类型都是对象。
3）Scala数据类型仍然遵守，低精度的值类型向高精度值类型，自动转换（隐式转换）
4）Scala中的StringOps是对Java中的String增强
5）Unit：对应Java中的void，用于方法返回值的位置，表 示方法没有返回值。Unit是一个数据类型，只有一个对象 就是()。Void不是数据类型，只是一个关键字
6）Null是一个类型，只有一个对象就是null。它是所有引用类型（AnyRef）的子类。
7）Nothing，是所有数据类型的子类，主要用在一个函数没有明确返回值时使 用，因为这样我们可以把抛出的返回值，返回给任何的变量或者函数。

2.7整数类型（Byte、Short、Int、Long）

数据类型	描述
Byte [1]	8 位有符号补码整数。数值区间为 -128 到 127
Short [2]	16 位有符号补码整数。数值区间为 -32768 到 32767
Int [4]	32 位有符号补码整数。数值区间为 -2147483648 到 2147483647
Long [8]	64 位有符号补码整数。数值区间为 -9223372036854775808 到 9223372036854775807 = 2 的(64-1)次方-1

2.7.1案例实践

object test1 {
  def main(args: Array[String]): Unit = {
    //Byte类型
    var a:Byte=127
    //Short类型
    var aa:Short=32767
    //Int类型
    var aaa:Int=2147483647
    //Long类型,声明Long型，须后加‘l’或‘L’，默认是Int
    var aaaa:Long=9223372036854775807L
  }
}

2.8浮点类型

数据类型	描述
Float [4]	32 位, 标准的单精度浮点数
Double [8]	64 位 ,标准的双精度浮点数

 

object test1 {
  def main(args: Array[String]): Unit = {
    //Double
    var a:Double=3.12
    //Float,Scala 的浮点型常量默认为Double型
    //声明 Float 型常量，须后加‘f’或‘F’。
    var aa:Float=3.12F
  }
}

2.9字符类型

1、基本说明

字符类型可以表示单个字符，字符类型是 Char。

2.10 布尔类型

1、基本说明

      1）布尔类型也叫Boolean 类型，Booolean 类型数据只允许取值 true 和 false 

      2）占一个字节

2.11Unit 类型、Null 类型和Nothing 类型

1、基本说明

数据类型	描述
Unit	表示无值，和其他语言中 void 等同。用作不返回任何结果的方法的结果 类型。Unit 只有一个实例值，写成()。
Null	null , Null 类型只有一个实例值 null，Null 可以赋值给任意引用类型（AnyRef），但是不能赋值给值类型（AnyVal）
Nothing	Nothing 类型在 Scala 的类层级最低端；它是任何其他类型的子类型。当一个函数，我们确定没有正常的返回值，可以用 Nothing 来指定返回类型，这样有一个好处，就是我们可以把返回的值（异常）赋给其它的函数 或者变量（兼容性）

2.12类型转换

1）自动提升原则：有多种类型的数据混合运算时，系统首先自动将所有数据转换成精度大的那种数据类型，然后再进行计算。

2）把精度大的数值类型赋值给精度小的数值类型时，就会报错，反之就会进行自动类型转换。

          3)（byte，short）和 char 之间不会相互自动转换。

          4）byte，short，char 他们三者可以计算，在计算时首先转换为 int 类型。

object test1 {
def main(args: Array[String]): Unit = {

//（1）自动提升原则：有多种类型的数据混合运算时，
// 系统首先自动将所有数据转换成精度大的那种数值类型，然后再进行计算。
var n = 1 + 2.0
println(n)	// n 就 是 Double
//（2）把精度大的数值类型赋值给精度小的数值类型时，就会报错，反之就会进行自动类型转换。
var n2 : Double= 1.0
var n3 : Int = n2 //错误，原因不能把高精度的数据直接赋值和低
精度。
//（3）（byte，short）和 char 之间不会相互自动转换。
var n4 : Byte = 1
var c1 : Char = n4	//错误var n5:Int = n4

//（4）byte，short，char 他们三者可以计算，在计算时首先转换为 int
类型。
var n6 : Byte = 1 var c2 : Char = 1
var n : Short = n6 + c2 //当 n6 + c2 结果类型就是int
var n7 : Short = 10 + 90 //错误
}
}