1、Scala的HelloWorld程序
代码实现:
package org.apache.scala
/**
* 时间: 2021/7/16 8:40
* 描述: Scala的HelloWorld程序
*
* 核心要点:
*
* 1、类名和文件名
* 2、main方法的定义(注意和java的main方法对比理解)
* 3、分号(可有可无)
* 4、编译和执行(scalac和scala)
* 5、类的声明(object和class)
*/
object Demo000_HelloWorld {
var name: String = "zhangsan"
def main(args: Array[String]): Unit = {
println("hello world")
println(name)
}
}
控制台打印输出
2、变量使用
-
val 相当于Java中的final关键字修饰的变量,一旦赋值便不能更改,当未指定类型时,Scala会根据实际类型进行类型推断,上面前三种方式结果相同。
- lazy关键字修饰的变量,定义时不赋值,真正使用时才赋值
- var关键字修饰的变量,可以被重新赋值
e也可以是大写E,0.1214e1 = 0.1314*10
e也可以是大写E,0.1214e2 = 0.1314*10*10
代码实现
package org.apache.scala.day01
object Demo001_Variable {
def main(args: Array[String]) {
//使用val定义的变量值是不可变的,相当于java里用final修饰的变量
val i = 1
//使用var定义的变量是可变得,在Scala中鼓励使用val
val s = "hello"
//Scala编译器会自动推断变量的类型,必要的时候可以指定类型
//变量名在前,类型在后
val str: String = "NXNX奈学教育"
println(i, s, str)
// 定义变量
val hello1 = "Hello Scala"
val hello2: String = "Hello Scala"
val hello3: java.lang.String = "Hello Scala"
lazy val hello4 = "Hello Scala"
// 使用val修饰的变量是不可更改变量。相当于java中的final关键字修饰的变量
// 这个赋值操作是不被允许的: hello5 = "hello spark"
val hello5 = "Hello Scala"
// 使用var修饰的变量可以修改为同类型的其他值, 但是使用val修饰的变量一定不能修改
var hello6 = "hello"
// 这个赋值操作是错误的: hello6 = 4
hello6 = "hi" // 这个操作是允许的
val x1 = 0x29 //十六进制定义整数
val x2 = 41 //十进制定义整数
val x3 = 51 //八进制数定义
println(x1, x2)
val doubleNumber = 3.14159 //Double类型定义,直接输入浮点数,编译器会将其自动推断为Double类型
val floatNumber1 = 3.14159F //定义Float类型浮点数,需要在浮点数后面加F或f
val floatNumber2 = 0.1314e-1 // 科学计数法
println(doubleNumber, floatNumber1, floatNumber2)
// 字符定义,用单引号(')将字符包裹
var letter = 'A'
// 如果需要原样输出字符串中的内容,则用三个双引号"""将字符串包裹起来
val hello = """Hello \n \t \b \\ Scala"""
// 定义布尔变量
var bool = true
println(letter, hello, bool)
}
}
打印输出
3、数据类型
- Any是所有类的父类,包括值类型AnyVal,和引用类型AnyRef
- AnyVal是所有值类型的父类,包括Int,Double,Boolean,Unit等等
- AnyRef是所有引用类型的父类,包括Null
- Null是所有引用类型的子类
- Nothing是所有类的子类
- Unit类型只有一个实例,是(),相当于java中的void,没有任何的实质意义
- Null也只有一个实例,是null,相当于java中的null,能赋值给任何引用类型变量,不能赋值给值类型变量
代码实现:
package org.apache.scala.day01
/**
* 描述: 数据类型
*/
object Demo002_Type {
def main(args: Array[String]): Unit = {
val var_int = 1
val var_double = 3.33
val var_float = 2.4F
val var_char = 'A'
val var_bool = true
println(var_int, var_double, var_float, var_char, var_bool)
val var_16 = 0x29
val var_string = "aa"
val var_string1 = "\"huangbo\""
val var_string2 = """hello\thello\na\t\\"""
println(var_16)
println(var_string)
println(var_string1)
println(var_string2)
}
}
打印输出:
4、操作运算符
- 算术操作:+ - * / %
- 关系运算:> >= < <= == !=
- 逻辑运算:&& || !
- 位运算: & | ^ >> << >>>
- 对象比较:1==1 1==1.0 "huangbo" == "huangbo"
代码实现:
package org.apache.scala.day01
/**
* 描述: 操作运算符
*/
object Demo003_Operator {
def main(args: Array[String]): Unit = {
println(7 + 3)
println(7 - 3)
println(7 * 3)
println(7 / 3)
println(7 % 3)
println(7 > 3)
println(7 >= 3)
println(7 < 3)
println(7 <= 3)
println(7 == 3)
println(7 != 3)
println(true && false)
println(true || false)
println(!false)
println(7 & 3) // 0111 & 011
println(7 | 3) // 0111 & 011
println(7 ^ 3) // 0111 & 011
println(7 >> 1)
println(7 << 1)
println(-7 >>> 1)
println(-7 >> 1)
println(1 == 1)
println(1 == 1.0)
println("huangbo" == "huangbo")
println("huangbo" equals "huangbo")
}
}
控制台打印输出:
5、流程控制 if
代码实现:
package org.apache.scala.day01
/**
* 描述: 流程控制 if
*/
object Demo004_If {
def main(args: Array[String]) {
// if条件分支是可以拥有返回值的。!!返回值为代码段中的最后一个局代码的返回结果
var aa = 1
var result = if (aa > 0) {
println(">")
} else {
println("<")
}
println(result)
val x = 1
//判断x的值,将结果赋给y
val y = if (x > 0) 1 else -1
//打印y的值
println(y)
//支持混合类型表达式
val z = if (x > 1) 1 else "error"
//打印z的值
println(z)
//如果缺失else,相当于if (x > 2) 1 else ()
val m = if (x > 2) 1
println(m)
//在scala中每个表达式都有值,scala中有个Unit类,写做(),相当于Java中的void
val n = if (x > 2) 1 else ()
println(n)
//if和else if
val k = if (x < 0) -1 else if (x > 0) 1 else 0
println(k)
}
}
打印输出
6、块表达式
代码实现:
package org.apache.scala.day01
/**
* 描述: 块表达式
*/
object Demo005_BlockExpresstion {
def main(args: Array[String]) {
val x = 0
//在scala中{}中课包含一系列表达式,块中最后一个表达式的值就是块的值
//下面就是一个块表达式
val result = {
if (x < 0) {
-1
} else if (x >= 1) {
1
} else {
"error"
}
}
//result的值就是块表达式的结果
println(result)
//返回块中的最后一个表达式的值
val aa = {
1 to 10; if (3 > 2) 3 else 2
}
println(aa)
val bb = {
1 to 10; if (3 > 2) 3 else 2; val cc = 2
}
println(bb)
}
}
打印输出:
7、流程控制 for
代码实现:
package org.apache.scala.day01
/**
* 描述: 流程控制 for
*/
object Demo006_For {
def main(args: Array[String]) {
//for(i <- 表达式),表达式1 to 10返回一个Range(区间)
//每次循环将区间中的一个值赋给i
for (i <- 1 to 10)
println(i)
//for(i <- 数组)
val arr = Array("a", "b", "c")
for (i <- arr)
println(i)
// 倒序打印
for (str <- arr.reverse) {
println(str)
}
// 使用数组下标的方式进行打印
for (i <- 0 to arr.length - 1) {
println(arr(i))
}
for (i <- 0 until arr.length)
println(arr(i))
println("-----------------")
for (i <- 0 until(arr.length, 2))
println(arr(i))
//高级for循环
//每个生成器都可以带一个条件,注意:if前面没有分号
for (i <- 1 to 3; j <- 1 to 3 if i != j)
println((10 * i + j) + " ")
println()
//for推导式:如果for循环的循环体以yield开始,则该循环会构建出一个集合
//每次迭代生成集合中的一个值
val v = for (i <- 1 to 10) yield i * 10
println(v)
}
}
打印输出:
1
2
3
4
5
6
7
8
9
10
a
b
c
c
b
a
a
b
c
a
b
c
-----------------
a
c
12
13
21
23
31
32
Vector(10, 20, 30, 40, 50, 60, 70, 80, 90, 100)
8、流程控制 break 和 continue
代码实现:
package org.apache.scala.day01
import util.control.Breaks._
/**
* 描述: 流程控制 break 和 continue
*/
object Demo007_Break_Continue {
def main(args: Array[String]): Unit = {
// break 举例
breakable(
for (i <- 1 to 5) {
if (i == 3) {
break()
}
println(i)
}
)
// continue 举例
for (i <- 1 to 5) {
breakable {
if (i == 3) {
break
}
println(i)
}
}
}
}
打印输出:
9、流程控制 while
代码实现:
package org.apache.scala.day01
/**
* 描述: 流程控制 while
*/
object Demo007_While {
def main(args: Array[String]) {
// Scala中的while的语法和java中的一样
var n = 10;
while (n > 0) {
println(n)
n -= 1
}
}
}
打印输出: