手把手带你学习Scala(二)-变量和数据类型

第2章 变量和数据类型

2.1 注释

Scala注释使用和Java完全一样。注释是一个程序员必须要具有的良好编程习惯。将自己的思想通过注释先整理出来，再用代码去体现。

2.1.1 单行注释

2.1.2 多行注释

2.1.3 文档注释

package com.dt.bigdata.scala.chapter02
object Scala01_Comment {
    def main(args: Array[String]): Unit = {
        // TODO 注释
        // 单行注释

        /*
           多行注释
         */

        /**
         * 文档注释
         */
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

2.2 变量

变量是一种使用方便的占位符，用于引用计算机内存地址，变量创建后会占用一定的内存空间。基于变量的数据类型，操作系统会进行内存分配并且决定什么将被储存在保留内存中。因此，通过给变量分配不同的数据类型，你可以在这些变量中存储整数，小数或者字母。

2.2.1 语法声明

变量的类型在变量名之后等号之前声明。
PS:特殊说明：var指的是给它起个名字的意思，
“zhaoliu”.var回车之后默认自动生成是val zhaoliu = “zhaoliu”
这是IDEA默认代码，默认给赋val

package com.dt.bigdata.scala.chapter02
object Scala02_Var {
    def main(args: Array[String]): Unit = {
        // TODO 变量
        // java中变量声明  => String name = "zhangsan";
       // scala中变量声明方式(1) => var 变量名 : 变量的类型 = 变量的值
        var name1 : String = "zhangsan"
        name1 = "lisi"   //var的变量可以重新赋值

        // 一个变量在某些场合中，一旦初始化后就不能重新赋值
       // scala中变量声明方式(2) => val 变量名 : 变量的类型 = 变量的值
        val name2 : String = "lisi"
        //name2 = "wangwu"
        //println(name)
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

变量的类型如果能够通过变量值推断出来，那么可以省略类型声明，这里的省略，并不是不声明，而是由Scala编译器在编译时自动声明编译的。

package com.dt.bigdata.scala.chapter02
object Scala02_Var_1 {
    def main(args: Array[String]): Unit = {
        // TODO 变量
        // 强类型的语言中，类型的声明应该前后统一，如果我明确的知道变量的取值是什么，那么变量的类型就确定了。
        // 能够通过取值推断变量的类型，那么变量类型可以省略(比如此处String可以取消)
        var name : String = "zhangsan"
        // 如果使用多态，那么类型不能省略，Scala创始人只能根据list推断出来这里数据类型是String,要用多态的话，需要自己写数据类型object
        var name1 : Object = "lisi"
        println(name1)
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

2.2.2 变量初始化

Java语法中变量在使用前进行初始化就可以，但是Scala语法中是不允许的，必须显示进行初始化操作。

package com.dt.bigdata.scala.chapter02
object Scala02_Var_2 {
    def main(args: Array[String]): Unit = {
        // TODO 变量
        // scala中声明变量一定要初始化
        val name : String = "123"
    }
}
1
2
3
4
5
6
7
8

2.2.3 可变变量

值可以改变的变量，称之为可变变量，但是变量类型无法发生改变, Scala中可变变量使用关键字var进行声明

2.2.4 不可变变量

值一旦初始化后无法改变的变量，称之为不可变变量。Scala中不可变变量使用关键字val进行声明, 类似于Java语言中的final关键字

package com.dt.bigdata.scala.chapter02
object Scala02_Var {
    def main(args: Array[String]): Unit = {
        // TODO 变量
        // java中变量声明  => String name = "zhangsan";
       // scala中变量声明方式(1) => var 变量名 : 变量的类型 = 变量的值
        var name1 : String = "zhangsan"
        name1 = "lisi"   //var的变量可以重新赋值

        // 一个变量在某些场合中，一旦初始化后就不能重新赋值
       // scala中变量声明方式(2) => val 变量名 : 变量的类型 = 变量的值
        val name2 : String = "lisi"
        //name2 = "wangwu"
        //println(name)
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

package com.atguigu.bigdata.scala.test;
public class TestString {
    public static void main(String[] args) {
        // String字符串是不可变
        // String类没有提供任何改变内容的方法,所以是不可变的字符串类型。
        // 所有的字符串操作的方法都会产生新的字符串

        // trim方法用于去掉字符串的首尾半角空格。
        // !,!     这里是半角逗号
        // !，!    这里是全角逗号
        String s = " a b ";
        s = s.trim();
        System.out.println("!"+s+"!");
        // !a b!
        // ! a b ! (OK)
        // !ab!
    }
}
/*
  运行结果为：
  !a b!
*/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

2.3 标识符

Scala 可以使用两种形式的标志符，字符数字和符号。
字符数字使用字母或是下划线开头，后面可以接字母或是数字，符号"$"在Scala中也看作为字母。然而以"$“开头的标识符为保留的 Scala 编译器产生的标志符使用，应用程序应该避免使用”$"开始的标识符，以免造成冲突。
Scala 的命名规范采用和 Java 类似的 camel 命名规范，首字符小写，比如 toString。类名的首字符还是使用大写。此外也应该避免使用以下划线结尾的标志符以避免冲突。
Scala 内部实现时会使用转义的标志符，比如:-> 使用 $colon$minus$greater 来表示这个符号。

package com.dt.bigdata.scala.chapter02
object Scala03_Name {
    def main(args: Array[String]): Unit = {
        // TODO 标识符
        // scala的标识符和java的标识符基本一致
        /*
          1. 数字，字母，下划线，$
          2. 数字不能开头
          3. 不能使用关键字或保留字
          4. 区分大小写
          5. 长度没有限制
             _name(70~80)
             name
         */
        val name = "zhangsan"
        val name1 = "zhangsan"
        val name$ = "zhangsan"
        val name_ = "zhangsan"
        val Private = "zhangsan"
        //val private = "zhangsan"(X)
        //val 1name_ = "zhangsan"(X)
        // 计算规则（运算符）
    }
}
//PS:需要注意的地方：
package com.dt.bigdata.scala.chapter02
object Scala03_Name_2 {
    def test(): Unit = {
        println("test..")
    }
    def main(args: Array[String]): Unit = {
        // TODO 标识符
     // 马丁在编译时，将特殊符号编译为转换的变量名，这个变量名以$开头的。
        // 一般情况下，标识符起名时不能使用$开头

        // 颜文字
        //val :-> = "lisi"
        //val > = "lisi"
        //val $greater = "lisi"
        //println(:->)

        // TODO 下划线在scala中的作用非常丰富
        //val _ = "wangwu"
        //println(_)
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

Scala 中的标识符也不能是关键字或保留字，那么Scala中有多少关键字或保留字呢？

2.4 字符串

在 Scala 中，字符串的类型实际上就是 Java中的 String类，它本身是没有 String 类的。
在 Scala 中，String 是一个不可变的字符串对象，所以该对象不可被修改。这就意味着你如果修改字符串就会产生一个新的字符串对象。

package com.atguigu.bigdata.scala.chapter02
object Scala04_String {
    def main(args: Array[String]): Unit = {
        // TODO 字符串的拼接
        // select 'name' + num from user

        //val name = "zhangsan"
        //println("Hello" + name)

        // JSON => JavaScript Object Notation
        // JSON字符串 => 符合JSON格式的字符串

        // 网络中传递的数据是什么？
        val name = "zhangsan"
        val password = "123123"

        //val json = "{\"username\":\""+name+"\", \"password\":\""+password+"\"}"
        //println(json)

        // 传值字符串，但是这个不是很方便，一般不用这种。
        //printf("username : %s\n", name)
        //printf("password : %s", password)

        // 插值字符串，需要注意的是最前面加s，是指此处$是有用途的。
        //println(s"username : $name")

        // 官方无法使用插值字符串封装JSON，执行的话会报错
        //val json1 = s"{\"username\":\"${name}\", \"password\":\"${password}\"}"
        //println(json1)

        // 为了解决官方无法使用插值字符串封装JSON的问题，设计了多行字符串
        // 竖线表示顶格符(顶格符默认是|，按住Ctrl点击stripMargin进去可以换顶格符)
        val s =
            """
              | Hello
                Scala
              |""".stripMargin('#')
        val json =
            s"""
              | { "username":"${name}", "password":"${password}" }
              |""".stripMargin
        val sql = "select id from (select * from t_user where id = 1 order by id desc) a group by id"
        val sql1 =
            """
              | select
              |    id
              | from
              |    (
              |        select
              |           *
              |        from t_user
              |        where id = 1
              |        order by id desc
              |
              |    ) a
              | group by id
              |
              |""".stripMargin
        println(json)
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

2.5 输入输出

2.5.1 输入

从屏幕（控制台）中获取输入 和 从文件中获取输入

package com.dt.bigdata.scala.chapter02
import scala.io.{BufferedSource, Source, StdIn}
object Scala05_IO {
    def main(args: Array[String]): Unit = {
        // TODO IO
        // read - 控制台
        //val line: String = StdIn.readLine()
        //println(line)

        // 从文件中获取输入
        // 数据源
        // TODO 文件路径
        // 绝对路径：不可改变的路径
        //计算机里面如何分绝对？主要有两种情况：
        //① 本地路径：
        //② 网络路径：
        //     本地路径：file:///c:/test/test.txt
        //     网络路径：http://www.xxx.com
        // 相对路径：可以改变的路径,一定存在一个基准路径
        //     ./ => 当前路径（可以省略）
        //    ../ => 当前路径的上一级路径
        // IDEA中基准路径为项目的根路径
        val source: BufferedSource = Source.fromFile("data/word.txt") //此处需要注意的是需要去IDEA根目录下去创建一个名为data的Directory和名为word.txt的File,并写入内容
        val strings: Iterator[String] = source.getLines()
        while ( strings.hasNext ) {
            println(strings.next())
        }
        source.close()
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

2.5.2 输出

Scala进行文件写操作，用的都是 java中的I/O类

package com.dt.bigdata.scala.chapter02
import java.io.{File, PrintWriter}
object Scala05_IO_1 {
    def main(args: Array[String]): Unit = {
        val writer = new PrintWriter(new File("output/test.txt" ))  //此处需要注意的是需要去IDEA根目录下去创建一个名为output的Directory和名为test.txt的File
        writer.write("Hello Scala")
        writer.close()
    }
}
1
2
3
4
5
6
7
8
9

2.5.3 网络

Scala进行网络数据交互时，采用的也依然是Java中的I/O类。
传字节码

//输入
package com.dt.bigdata.scala.chapter02
import java.io.InputStream
import java.net.{ServerSocket, Socket}
object Scala06_Slaver {
    def main(args: Array[String]): Unit = {
        // TODO 启动服务器
        val server = new ServerSocket(9999)  //Socket是网络流服务器，所以需要加端口号port，端口为了区分服务使用
        println("服务器已经启动，等待客户端的连接。。。")
        val client: Socket = server.accept()
        val in: InputStream = client.getInputStream
        val i: Int = in.read()
        println("从客户端接收的数据为 " + i)
        in.close()
        client.close()
        server.close()
    }
}
//输出
package com.dt.bigdata.scala.chapter02
import java.io.OutputStream
import java.net.Socket
object Scala06_Master {
    def main(args: Array[String]): Unit = {
        // TODO 连接服务器
        val client = new Socket("localhost", 9999)
        val out: OutputStream = client.getOutputStream
        out.write(300)    //这里传的是ASCII码
        out.flush()
        out.close()
        println("客户端向服务器发送数据 ：1")
        client.close
    }
}
//PS:先启动Scala06_Slaver，再启动Scala06_Master，即可在Scala06_Slaver控制台看到客户端向服务器发送数据
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

传对象

//输入
package com.dt.bigdata.scala.chapter02
import java.io.ObjectInputStream
import java.net.{ServerSocket, Socket}
object Scala06_Slaver_Object {
    def main(args: Array[String]): Unit = {
        // TODO 启动服务器
        val server = new ServerSocket(9999)
        println("服务器已经启动，等待客户端的连接。。。")
        val client: Socket = server.accept()
        val objIn = new ObjectInputStream(client.getInputStream)
        val user = objIn.readObject()
        println("从客户端接收的数据为 " + user)
        objIn.close()
        client.close()
        server.close()
    }
}
//输出
package com.dt.bigdata.scala.chapter02
import java.io.{ObjectOutputStream}
import java.net.Socket
import com.dt.bigdata.scala.test.User
object Scala06_Master_Object {
    def main(args: Array[String]): Unit = {
        // TODO 连接服务器
        val client = new Socket("localhost", 9999)
        val user = new User()
        val objOut = new ObjectOutputStream(client.getOutputStream)
        objOut.writeObject(user)
        objOut.flush()
        objOut.close()
        println("客户端向服务器发送数据 ：1")
        client.close
    }
}
//User对象
package com.dt.bigdata.scala.test;
import java.io.Serializable;
public class User implements Serializable {
    public static int age;
    static {
        age = 30;
        System.out.println("user static init...");
    }
    @Override
    public String toString() {
        return "User["+age+"]";
    }
    public static String test() {
        int i = 10 / 0;
        return "abc";
    }
}
//PS:先启动Scala06_Slaver_Object，再启动Scala06_Master_Object，即可在Scala06_Slaver_Object控制台看到客户端向服务器发送数据
//输出结果为：
服务器已经启动，等待客户端的连接。。。
user static init...
从客户端接收的数据为 User[30]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

2.6 数据类型

Scala与Java有着相同的数据类型，但是又有不一样的地方

2.6.1 Java数据类型

Java的数据类型包含基本类型和引用类型
基本类型：byte,short,char,int,long,float,double,boolean
引用类型：Object，数组，字符串，包装类，集合，POJO对象等

2.6.2 Scala数据类型

Scala是完全面向对象的语言，所以不存在基本数据类型的概念，有的只是任意值对象类型**（AnyVal）和任意引用对象类型(AnyRef)**

package com.dt.bigdata.scala.chapter02
object Scala07_DataType {
    def main(args: Array[String]): Unit = {
        // TODO 数据类型
        // 任意值类型
        val b : Byte = 20
        val s : Short = 20
        val c : Char = 'a'
        val i : Int = 20
        val lon : Long = 20
        val f : Float = 20.0F
        val d : Double = 20.0
        val flg : Boolean = true
        val u : Unit = test() // Unit是一个类型，这个类型只有一个对象，打印就是小括号
        println(u)
    }
    def test(): Unit = {
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

AnyRef

package com.dt.bigdata.scala.chapter02
import com.dt.bigdata.scala.test.User
object Scala07_DataType_1 {
    def main(args: Array[String]): Unit = {
        // TODO 数据类型
        val list : AnyRef = List(1,2,3,4)
        val obj : AnyRef = new User()
        val obj1 : AnyRef = Scala07_DataType_1
        println(list)
        println(obj)
        println(obj1)
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

Null

package com.dt.bigdata.scala.chapter02
import com.dt.bigdata.scala.test.User
object Scala07_DataType_2 {
    def main(args: Array[String]): Unit = {
        // TODO 数据类型
        // User user = new User();
        // User user = null;
        //val i : Int = null
        // Null在scala中是一个类型，只有一个对象，就是null
        val n = null
        val user : User = null
        //val i : Int = null
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

一个变量既想让数据是string类型又想是int类型

package com.dt.bigdata.scala.chapter02
object Scala07_DataType_3 {
    def main(args: Array[String]): Unit = {
        // TODO 数据类型
        //Object obj = new User()
        //obj = new Emp()
        var a : Any = "123"
        a = 1
    }
}
1
2
3
4
5
6
7
8
9
10

Nothing

package com.dt.bigdata.scala.chapter02
object Scala07_DataType_4 {
    def main(args: Array[String]): Unit = {
        // Nothing是scala语言中特殊的类型，用于统一方法的异常和正常的返回
    }
    def test(): Nothing = {
        throw new Exception()
    }
    def test1(): String = {
        throw new Exception()
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

2.7 类型转换

2.7.1 自动类型转化（隐式转换）

package com.dt.bigdata.scala.chapter02
object Scala07_DataType_5 {
    def main(args: Array[String]): Unit = {
        // 编译器将类型进行了转换，所以可以编译通过
        // 这个转换开发人员看不见，将这样的转换称之为隐式转换
        //val b : Byte = 20
        //val i : Int = b
        //val b : Byte = 'A'
        //val c : Char = b + 1
        //println(c)
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

2.7.2 强制类型转化

Java语言
int a = 10
byte b = (byte)a
Scala语言
var a : Int = 10
Var b : Byte = a.toByte
// 基本上Scala的AnyVal类型之间都提供了相应转换的方法。
1
2
3
4
5
6
7

2.7.3 字符串类型转化

scala是完全面向对象的语言，所有的类型都提供了toString方法，可以直接转换为字符串

package com.dt.bigdata.scala.chapter02
object Scala07_DataType_6 {
    def main(args: Array[String]): Unit = {
        // 所有的类型都可以转换为字符串
        val b : Byte = 20
        //b.toString
        //b.to
        // 字符串也可以转换为数值
        val s = "123a"
        val i = s.toInt
        println(i)
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

手把手带你学习Scala(二)-变量和数据类型到这里就介绍完了，小伙伴们点赞、收藏、评论，一键三连走起呀，下期见~~
最后感谢尚硅谷的资料分享，本文仅用于交流学习，不用于商业性使用