第 4 章 流程控制 （和java一样）
4.1 分支控制 if-else
让程序有选择的的执行，分支控制有三种：单分支、双分支、多分支
4.1.1 单分支
基本语法
| Scala
//说明：当条件表达式为 ture 时，就会执行{ }的代码。
if (条件表达式) {
执行代码块
} |
需求：现在hadoop的课程是199元，如果说今天是程序员节(10月24号)，那么今天购买商品打6折，并将订单金额打印在控制台上
| Scala
package com.doitedu
object Demo02 {
/**
* 需求：现在hadoop的课程是199元，如果说今天是程序员节(10月24号)，那么今天购买商品打6折，并将订单金额打印在控制台上
*/
def main(args: Array[String]): Unit = {
//课程名称：java基础,mysql,hadoop.....
var subjectName = "hadoop"
//课程的价格：199,299,399,99
val subjectPrice = 199.00
val activeType = "程序员节"
//活动折扣力度
val activeDiscount = 0.6
//订单金额
var orderAmount = 0.0
if(activeType == "程序员节"){
orderAmount = subjectPrice * activeDiscount
println(orderAmount)
}
}
} |
4.1.2 双分支
基本语法
| Scala
if (条件表达式) {
执行代码块 1
} else {
执行代码块 2
} |
需求：现在hadoop的课程是199元，如果说今天是程序员节(10月24号)，那么今天购买商品打6折，如果不是，就需要按照原价购买，最后将订单金额打印在控制台上
| Scala
package com.doitedu
object Demo02 {
/**
* 需求：现在hadoop的课程是199元，如果说今天是程序员节(10月24号)，那么就给这个价格打6折
*/
def main(args: Array[String]): Unit = {
//课程名称：java基础,mysql,hadoop.....
var subjectName = "hadoop"
//课程的价格：199,299,399,99
val subjectPrice = 199.00
val activeType = "程序员节"
//活动折扣力度
val activeDiscount = 0.6
//订单金额
var orderAmount = 0.0
if(activeType =="程序员节"){
orderAmount = subjectPrice * activeDiscount
println(orderAmount)
}else{
orderAmount = subjectPrice
println(orderAmount)
}
if(activeType =="不是程序员节"){
orderAmount = subjectPrice * activeDiscount
}else{
orderAmount = subjectPrice
}
println(orderAmount)
}
} |
4.1.3 多分支
基本语法
| Scala
if (条件表达式 1) {
执行代码块 1
}
else if (条件表达式 2) {
执行代码块 2
}
……
else {
执行代码块 n
} |
需求：猜数字小游戏
| Scala
package com.doitedu
object Demo02 {
def main(args: Array[String]): Unit = {
//猜数字小游戏
/**
* 1.生成一个目标数字
* 2.我输入一个数字开始猜，如果猜的数字比原来的数字大，就打印猜大了
* 如果猜的数字比原来的数字小，就打印猜小了
* 如果猜的数字和原来的数字相等，就打印，猜对了
*/
val random: Random = new Random()
val res: Int = random.nextInt(100) + 1
println(
"""
|在一个月黑风高的夜晚，
|多易教育发行了一个比较low的猜数字游戏。
|听说猜对了连奖励都没有，哎，还是开始吧！！！
|""".stripMargin)
Thread.sleep(1000)
println("3")
Thread.sleep(1000)
println("2")
Thread.sleep(1000)
println("1")
Thread.sleep(1000)
println("开始！！！")
val sc: Scanner = new Scanner(System.in)
var i = 5
while (i > 0 && i <= 5) {
println(s"请输入你要猜的数字！你还有${i}次机会！！")
i -= 1
val num: Int = sc.nextInt()
if (res > num) {
if(i > 0 && i <= 5){
println("你不行啊，猜小了，下次猜大一点")
}else{
println(s"没机会了，你挂了：${i}")
}
} else if (res < num) {
if(i > 0 && i <= 5){
println("你不行啊，猜大了，下次猜小一点")
}else{
println(s"没机会了，你挂了，正确的结果是：${i}")
}
} else {
println("恭喜你，猜对了，但是没得奖励")
return
}
}
}
} |
4.2 嵌套分支
在一个分支结构中又完整的嵌套了另一个完整的分支结构，里面的分支的结构称为内层。分支外面的分支结构称为外层分支。嵌套分支不要超过 3 层。
基本语法：
| Scala
if(条件表达式1){
if(条件表达式2){
执行代码块 1
}else{
执行代码块 2
}
} |
需求：如果该用户参加的活动类型双十一光棍节，并且他是单身的话，就给他打5折，不是单身就给他打8折，最后订单金额打印在控制台上
| Scala
package com.doitedu
object Demo02 {
/**
* 需求：如果该用户参加的活动类型双十一光棍节，并且他是单身的话，就给他打5折，不是单身就给他打8折，最后订单金额打印在控制台上
*/
def main(args: Array[String]): Unit = {
//课程的价格：199,299,399,99
val subjectPrice = 199.00
val isMarry = "yes"
//活动类型
val activeType = "光棍节"
//订单金额
var orderAmount = 0.0
if (activeType == "光棍节") {
if (isMarry == "yes") {
orderAmount = subjectPrice * 0.8
}else{
orderAmount = subjectPrice * 0.5
}
}
println(orderAmount)
}
} |
4.3 Switch 分支结构
在 Scala 中没有 Switch，而是使用模式匹配来处理。
模式匹配涉及到的知识点较为综合，因此我们放在后面讲解。
4.4 For 循环控制
Scala 也为 for 循环这一常见的控制结构提供了非常多的特性，这些 for 循环的特性被称为 for 推导式或 for 表达式。
4.4.1 范围数据循环（To）
基本语法
| Scala
for(i <- 1 to 10){
println(i)
} |
| （1）i 表示循环的变量，<- 规定 to （2）i 将会从 1-3 循环，前后闭合 |
练习：
需求：输出 5 句 "hello world"
| Scala
object TestFor {
def main(args: Array[String]): Unit = {
for(i <- 1 to 5){
println("hello world"+i)
}
}
} |
4.4.2 范围数据循环（Until）
基本语法：
| Scala
for(i <- 1 until 5) {
println(i)
} |
| （1）这种方式和前面的区别在于 i 是从 1 到 5-1 即[0,5) （2）即使前闭合后开的范围 |
练习：
需求：用until输出 5 句 "hello world"
| Scala
object TestFor {
def main(args: Array[String]): Unit = {
for(i <- 1 until 5+1){
println("hello world"+i)
}
}
} |
4.4.3 循环守卫
基本语法
| Scala
for(i <- 1 to 3 if i != 2) {
println(i)
} |
| 循环守卫，即循环保护式（也称条件判断式，守卫）。保护式为 true 则进入循环体内部，为 false 则跳过，类似于 continue。 |
代码等价：
| Scala
for (i <- 1 to 3){
if (i != 2) {
print(i + " ")
}
} |
案例：
需求：输出 1 到 5 中，不等于 3 的值
| Scala
object TestFor {
def main(args: Array[String]): Unit = {
for (i <- 1 to 5 if i != 3) {
println(i + "doit")
}
}
} |
4.4.4 循环步长
基本语法:
说明：by 表示步长
| Scala
for (i <- 1 to 10 by 2) {
println("i=" + i)
} |
案例：
需求：输出 1 到 10 以内的所有奇数
| Scala
for (i <- 1 to 10 by 2) {
println("i=" + i)
}
结果：
i=1
i=3
i=5
i=7
i=9 |
4.4.5 嵌套循环
基本语法：
说明：没有关键字，所以范围后一定要加；来隔断逻辑
| Scala
for(i <- 1 to 3; j <- 1 to 3) {
println(" i =" + i + " j = " + j)
} |
等价得代码：
| Scala
for (i <- 1 to 3) {
for (j <- 1 to 3) {
println("i =" + i + " j=" + j)
}
} |
需求：
打印九九乘法表
| Scala
object TestWhile {
def main(args: Array[String]): Unit = {
//需求，打印一个九九乘法表
for (i <- 1 to 9){
for (j <- 1 to i){
print(s"$i * $j = ${i*j} \t" )
}
println()
}
}
}
for(i <- 1 to 9;j <- 1 to i){
print(s"$i * $j = ${i*j} \t" )
if(i == j) println()
}
|
4.4.6 引入变量：
基本语法：
| Scala
for(i <- 1 to 3; j = 4 - i) {
println("i=" + i + " j=" + j)
} |
说明：
（1）for 推导式一行中有多个表达式时，所以要加 ; 来隔断逻辑
（2）for 推导式有一个不成文的约定：当 for 推导式仅包含单一表达式时使用圆括号，当包含多个表达式时，一般每行一个表达式，并用花括号代替圆括号，如下
举例：
| Scala
for {
i <- 1 to 3
j = 4 - i
} {
println("i=" + i + " j=" + j)
} |
等价得代码：
| Scala
for (i <- 1 to 3) {
var j = 4 - i
println("i=" + i + " j=" + j)
} |
4.4.7 循环返回值
基本语法：
| Scala
val res = for(i <- 1 to 10) yield i
println(res) |
说明：将遍历过程中处理的结果返回到一个新 Vector 集合中，使用 yield 关键字。
练习：需求：将原数据中所有值乘以 2，并把数据返回到一个新的集合中。
| Scala
object TestFor {
def main(args: Array[String]): Unit = {
var res = for(i <-1 to 10) yield {
i * 2
}
println(res)
}
}
输出结果：
Vector(2, 4, 6, 8, 10, 12, 14, 16, 18, 20) |
4.4.8 倒序打印
说明：如果想倒序打印一组数据，可以用 reverse。
案例：需求：倒序打印 10 到 1
| Scala
for(i <- 1 to 10 reverse){
println(i)
} |
练一练：
需求：倒序打印100-1000里面所有的水仙花数
水仙花数：指一个 3 位数，它的每个位上的数字的 3次幂之和等于它本身
| Scala
def main(args: Array[String]): Unit = {
for (elem:Int <- 100 until 1000 reverse ;if pow(elem % 10,3)+pow(elem / 10 % 10,3)+pow(elem / 100 % 10,3) == elem ) {
println("水仙花数是： "+elem)
}
} |
4.5 While 和 do..While 循环控制 和java里面一样
一句话：While 和 do..While 的使用和 Java 语言中用法相同。
4.5.1 While 循环控制
基本语法：
| Scala
循环变量初始化
while (循环条件) {
循环体(语句)
循环变量迭代
} |
| 说明： （1）循环条件是返回一个布尔值的表达式 （2）while 循环是先判断再执行语句 （3）与 for 语句不同，while 语句没有返回值，即整个 while 语句的结果是 Unit 类型() （4）因为 while 中没有返回值，所以当要用该语句来计算并返回结果时，就不可避免 的使用变量，而变量需要声明在 while 循环的外部，那么就等同于循环的内部对外部的变量 造成了影响，所以不推荐使用，而是推荐使用 for 循环。 |
案例：
需求：输出 10 句 "hello world"
| Scala
object Demo_while {
def main(args: Array[String]): Unit = {
var num = 1
while (num < 10) {
println(num + ":hello")
num += 1
}
}
} |
4.5.2 do..while 循环控制
基本语法：
| Scala
循环变量初始化;
do{
循环体(语句)
循环变量迭代
} while(循环条件) |
| 说明 （1）循环条件是返回一个布尔值的表达式 （2）do..while 循环是先执行，再判断 |
案例：
需求：输出 10 句 "hello world"
| Scala
object Demo_while {
def main(args: Array[String]): Unit = {
var num = 1
do {
println(num + ": hello")
num += 1
} while (num == -1)
}
} |
4.6 循环中断
基本说明:
Scala 内置控制结构特地去掉了 break 和 continue，是为了更好的适应函数式编程，推荐使用函数式的风格解决break和continue的功能，而不是一个关键字。Scala中使用breakable控制结构来实现 break 和 continue 功能。
案例:
方式 1：采用异常的方式退出循环
| Scala
object Demo_while {
def main(args: Array[String]): Unit = {
try {
for (emel <- 1 to 10) {
println(emel)
if (emel == 5) {
throw new RuntimeException
}
}
} catch {
case e: Exception =>
}
println("hello")
}
} |
方式 2：采用 Scala 自带的函数，退出循环
| Scala
import scala.util.control.Breaks
object Demo_while {
def main(args: Array[String]): Unit = {
Breaks.breakable(
for (emel <- 1 to 10) {
println(emel)
if (emel == 5) {
Breaks.break()
}
}
)
println("正常结束循环")
}
} |
对breaks进行省略
| Scala
object Demo_while {
def main(args: Array[String]): Unit = {
breakable(
for (emel <- 1 to 10) {
println(emel)
if (emel == 5) {
break()
}
}
)
println("正常结束循环")
}
} |
第 5 章 方法和函数
- 方法和函数的作用几乎是一样的,但是函数在使用的过程中更加灵活和多样化
- scala中函数是头等公民 . 可以作为方法的返回值和参数使用
- scala是一个集面向对象和面向函数于一身的编程语言 , 灵活的函数是函数式编程的一种体现
5.1函数
scala中一种函数式编程语言 ,函数是scala中的头等公民,建议优先使用函数 , 函数实现的功能和方法一样 ,但是我们可以把函数理解成一种特殊的业务逻辑对象 ,所以函数可以作为参数和返回值.... 函数也是用来处理数据的代码封装
5.1.1函数的定义
方式一：
| Scala
val / var 函数名称=（函数的参数列表） => 函数体 |
举例：
| Scala
val add = (x: Int, y: Int) => {
x + y
}
val parseStr = (str: String) => {
str.toUpperCase()
}
// 函数体中的内容只有一行代码可以省略大括号
var product = (x:Double) => x*x |
方式二：
| Scala
val / var 函数名称：（输入参数类型）=> 返回值类型 = （参数的引用）=> 函数体 |
举例：
| Scala
val add2:(Int,Int)=>Int=(x,y)=>{
x+y
}
add2 函数名
(Int ,Int) 要处理的参数类型列表
=>Int 函数处理完数据的返回值类型
=(x,y) 传入实际参数的接收变量名
{x+y} 函数体 运算求和
注意: 代码块的最后一行是函数的返回值 ,需要和=>(Int)类型保持一致 |
5.1.2分类
- 函数 1：无参，无返回值
- 函数 2：无参，有返回值
- 函数 3：有参，无返回值
- 函数 4：有参，有返回值
- 函数 5：多参，无返回值
- 函数 6：多参，有返回值
| Scala
def main(args: Array[String]): Unit = {
// 函数 1：无参，无返回值
val test1 ={
println("无参，无返回值")
}
test1()
// 函数 2：无参，有返回值
val test2={
"无参，有返回值"
}
println(test2())
// 函数 3：有参，无返回值
val test3 =(s:String)=>{
println(s)
}
test3("jinlian")
// 函数 4：有参，有返回值
val test4 = (s:String)=>{
return s+"有参，有返回值"
}
println(test4("hello "))
// 函数 5：多参，无返回值
val test5 = (name:String, age:Int)=>{
println(s"$name, $age")
}
test5("dalang",40)
// 函数 6：多参，有返回值
val test6 = (name:String, age:Int)=>{
"名字是:" + name + ",年龄是：" + age
}
} |
5.1.3函数的本质
函数的本质其实就是java中写了 一个接口，然后函数体就是这个接口的具体实现
代码示例:
| Java
//写一个接口
package com.doit;
public interface Function2<T,U> {
public U apply(T t,T t1);
}
// 接口的实现类
Function2<Integer, Integer> func = new Function2<Integer, Integer>() {
@Override
public Integer apply(Integer integer, Integer t1) {
return integer + t1;
}
}; |
练一练：
需求1：定义一个函数，传入一个值,如果这个值是三位数，则判断是不是水仙花数,返回布尔类型的值，如果这个值不是一个三位数，就返回一个字符串"输入的数字不合法,需要的数字范围是100-999"
| Scala
package com.doit.day01.day02
import scala.math.pow
/**
* 定义一个函数，传入一个值,如果这个值是三位数，
* 则判断是不是水仙花数,返回布尔类型的值，如果这个值不是一个三位数，
* 就返回一个字符串"输入的数字不合法,需要的数字范围是100-999"
*/
object Demo_Test {
def main(args: Array[String]): Unit = {
val value = flower(123)
println(value)
}
val flower = (num: Int) => {
if (num < 100 || num > 999) {
"输入的数字不合法,需要的数字范围是100-999"
} else {
val unit = num % 10
val tens = num / 10 % 10
val hundreds = num / 100 % 10
val res = (pow(unit, 3) + pow(tens, 3) + pow(hundreds, 3)).toInt
if (res == num) {
true
} else {
false
}
}
}
} |
需求二：将上面的函数，用java的接口也写一遍，了解下函数的本质
| Java
//接口
package com.doit;
public interface Function1<U,T> {
T apply(U u);
}
//实现
package com.doit;
import static java.lang.Math.pow;
public class Demo {
public static void main(String[] args) {
//实现接口
Function1<Integer, Object> res = new Function1<Integer, Object>() {
@Override
public Object apply(Integer num) {
if (num < 100 || num > 999) {
return "输入的数字不合法,需要的数字范围是100-999";
} else {
int unit = num % 10;
int tens = num / 10 % 10;
int hundreds = num / 100 % 10;
int res = (int) (pow(unit, 3) + pow(tens, 3) + pow(hundreds, 3));
if (res == num) {
return true;
} else {
return false;
}
}
}
};
//调用apply方法传入参数获取到最终结果
Object apply = res.apply(1);
System.out.println(apply);
}
} |
需求3：定义一个函数，功能是获取mysql的连接
| Scala
//定义一个函数，功能是获取mysql的连接
val getMysqlConn = (url:String,user:String,passWord:String)=>{
classOf[com.mysql.jdbc.Driver]
val connetcion = DriverManager.getConnection(url,user,passWord)
connetcion
}
val conn: Connection = getMysqlConn("jdbc:mysql://localhost:3306/test01", "root", "123456")
val pps: PreparedStatement = conn.prepareStatement("select * from resume_info")
val res: ResultSet = pps.executeQuery()
while (res.next()){
val id: Int = res.getInt(1)
val jobName: String = res.getString(2)
val date: String = res.getString(3)
val num: Int = res.getInt(4)
println(s"$id , $jobName ,$date ,$num")
} |
5.2方法
方法是逻辑片段的封装 ,可以处理一个或者多个数据 , 可以有返回值也可以没有没有返回值 ,提高了代码的复用性
5.2.1方法的定义
| Scala
def functionName ([参数列表]) : [return type] = {
function body
return [expr]
}
没有等号和方法体的方法称为抽象方法,抽象方法定义在抽象类和特质中 |
代码示例：
| Scala
// 定义一个方法 有两个参数 有返回值
def add(x:Int , y:Int):Int={
val sum = x + y
sum
// return 可以省略 , 代码块的最后一行就是这个方法的返回值
// return sum
}
/**
* 定义一个没有参数没有返回值的方法 Unit关键字代表没有返回值 类似于java中的void
*/
def show()={
println("show......")
}
/**
* 如果方法没有参数 方法后面的() 可以省略 ,注意在调用的时候也不要书写小括号
*/
def show2={
println("show......")
}
// 在抽象类或者特质中定义抽象方法
def m1 |
5.2.2方法的调用
方法的调用和java中的调用方式不太一样，如果方法定义在object中 在本类直接方法名调用 在其他类中调用 object 对象名调用，如果方法定义在普通的class 类中 , 本类之间直接调用! 其他类中new 类 .方法调用
5.2.3方法总结
注意方法的参数和返回值可以是函数 ,这样的方法称为高阶函数 ,高阶函数中详细讲解
- 定义方法的关键字，def
- 方法的返回值，最后一行的内容，如果是循环,打印，那么返回值是 Unit
- 如果空参方法，定义的时候有()，调用的时候可以省略()，但是如果定义的时候没有(),调用方法的时候，不能加()
- 方法的返回值类型，可以省略，但是特殊情况下，必须加上：
代码示例：
| Scala
val f = (x:String)=>{x}
f
def show(x:String) :Unit ={
x
}
show |
练一练：
需求一：定义一个方法，传入一个1-9中任意的整数，如果这个整数是在1-9内，那么就打印九九乘法表中到第几行，如果传进去的不是一个1-9的数，打印：干啥呢，不好好听课，要传1-9的整数
| Scala
package com.doit.day01.day02
import scala.math.pow
/**
* 需求一：定义一个方法，传入一个1-9中任意的整数，
* 如果这个整数是在1-9内，那么就打印九九乘法表中到第几行，
* 如果传进去的不是一个1-9的数，打印：干啥呢，不好好听课，要传1-9的整数
*/
object Demo_Test {
def main(args: Array[String]): Unit = {
multiplyTable(11)
}
def multiplyTable(num:Int)={
if(num<1 || num >9){
println("干啥呢，不好好听课，要传1-9的整数")
}else {
for(i <- 1 to num ;j <- 1 to i){
print(s"${i} * ${j} = ${i*j}\t")
if(i==j) println()
}
}
}
} |
需求二：写一个二分查找的方法,传入一个数组，再传入一个整数，去查找这个整数是不是在这个数组中，如果在，就返回他的索引位置，如果不在，就返回：对不起，你查找的数不存在
| Scala
package com.doit.day01.day02
import scala.util.control.Breaks
/**
* 需求二：写一个二分查找的方法,传入一个数组，再传入一个整数，
* 去查找这个整数是不是在这个数组中，
* 如果在，就返回他的索引位置，如果不在，就返回-1
*/
object Demo_Test {
def main(args: Array[String]): Unit = {
val arr: Array[Int] = Array(1,2,3,4,5,6,7,8,9)
val arr1: Array[Int] = Array()
println(binarySearch(arr, 9))
}
def binarySearch(arr: Array[Int], num: Int) = {
//二分查找的数必须是有序的,先给数组排个序
// arr.sortWith((i: Int, j: Int) => {i < j})
//这种方式也可以
// arr.sortWith(_ < _)
var res = -1
//首先判断这个数组的长度是不是0，如果是0，代表数组中没有元素，直接返回-1
if (arr.length == 0) {
res
} else {
// 起始位置索引
var start = 0
// 检索的最后一个元素
var end = arr.length - 1
//如果开始指针小于等于结束指针的时候，就要一直查找
Breaks.breakable(
while (start <= end) {
//二分找到中间的数
val midd = (start + end) / 2
//如果中间的那个数大于查询的数
if (arr(midd) > num) {
end = midd - 1
} else if (arr(midd) < num) {
start = midd + 1
} else {
res = midd
Breaks.break()
}
}
)
res
}
}
} |
5.3函数和方法
5.3.1相互转换
| Scala
def add(x: Int, y: Int) = {
x + y
}
// 将方法转换成函数
val f = add _ |
| 当我们将方法作为参传递的时候 ,其实底层是将方法自动转换成函数 |
5.3.2区别
在函数式编程语言中，函数是“头等公民”，它可以像任何其他数据类型一样被传递,函数可以当成值来进行传递，方法的参数和返回值都可以是函数。 函数和变量，类，对象， 是一个级别的。
区别和联系：
- 方法不能作为最终的表达式存在，但是函数可以，返回函数的签名信息
今天主要是第四章 , 第五章
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
