大数据技术之_16_Scala学习_04_函数式编程-基础+面向对象编程-基础

第五章 函数式编程-基础5.1 函数式编程内容说明5.1.1 函数式编程内容5.1.2 函数式编程授课顺序5.2 函数式编程介绍5.2.1 几个概念的说明5.2.2 方法、函数、函数式编程和面向对象编程关系分析图5.2.3 函数式编程小结5.3 为什么需要函数5.4 函数的定义5.4.1 函数的定义5.4.2 快速入门案例5.5 函数的调用机制5.5.1 函数的调用过程5.5.2 函数的递归调用5.5.3 递归练习题5.6 函数注意事项和细节讨论5.7 函数练习题5.8 过程5.8.1 基本概念5.8.2 注意事项和细节说明5.9 惰性函数5.9.1 看一个应用场景5.9.2 画图说明（大数据推荐系统）5.9.3 Java 实现懒加载的代码5.9.4 惰性函数介绍5.9.5 案例演示5.9.6 注意事项和细节5.10 异常5.10.1 介绍5.10.2 Java 异常处理回顾5.10.3 Java 异常处理的注意点5.10.4 Scala 异常处理举例5.10.5 Scala 异常处理小结5.11 函数的练习题第六章 面向对象编程-基础6.1 类与对象6.1.1 Scala 语言是面向对象的6.1.2 快速入门-面向对象的方式解决养猫问题6.1.3 类和对象的区别和联系6.1.4 如何定义类6.1.5 属性6.1.6 属性/成员变量6.1.7 属性的高级部分6.1.8 如何创建对象6.1.9 类和对象的内存分配机制（重要）6.2 方法6.2.1 基本说明和基本语法6.2.2 方法的调用机制原理6.2.3 方法练习题6.3 类与对象应用实例6.4 构造器6.4.1 看一个需求6.4.2 回顾-Java 构造器的介绍+基本语法+特点+案例6.4.3 Scala 构造器的介绍+基本语法+快速入门6.4.4 Scala 构造器注意事项和细节6.5 属性高级6.5.1 构造器参数6.5.2 Bean 属性6.6 Scala 对象创建的流程分析6.7 作业03

---

第五章 函数式编程-基础

5.1 函数式编程内容说明

5.1.1 函数式编程内容

函数式编程-基础
  1、函数定义/声明
  2、函数运行机制
  3、递归【难点：最短路径，邮差问题，背包问题，迷宫问题，回溯】
  4、过程
  5、惰性函数和异常

函数式编程-高级
  6、值函数(函数字面量)
  7、高阶函数
  8、闭包
  9、应用函数
  10、柯里化函数，抽象控制…

5.1.2 函数式编程授课顺序

  1、在 scala 中，函数式编程和面向对象编程融合在一起，学习函数式编程式需要 oop 的知识，同样学习 oop 需要函数式编程的基础。[矛盾]
  2、二者关系如下图:
  

  3、授课顺序：函数式编程基础 -> 面向对象编程 -> 函数式编程高级

5.2 函数式编程介绍

5.2.1 几个概念的说明

  在学习 Scala 中将方法、函数、函数式编程和面向对象编程明确一下：
  1、在 scala 中，方法和函数几乎可以等同(比如他们的定义、使用、运行机制都一样的)，只是函数的使用方式更加的灵活多样。
  2、函数式编程是从编程方式(范式)的角度来谈的，可以这样理解：函数式编程把函数当做一等公民，充分利用函数、支持的函数的多种使用方式。
  比如：在 Scala 当中，函数是一等公民，像变量一样，既可以作为函数的参数使用，也可以将函数赋值给一个变量，函数的创建不用依赖于类或者对象，而在 Java 当中，函数的创建则要依赖于类、抽象类或者接口。
  3、面向对象编程是以对象为基础的编程方式。
  4、在 scala 中函数式编程和面向对象编程融合在一起了。
示例代码如下：

package com.atguigu.chapter05

object Method2Function {
  def main(args: Array[String]): Unit = {
    // 传统的方式使用方法
    // 先创建一个对象
    val dog = new Dog
    println(dog.sum(10, 20))

    // 方法转成函数后使用函数
    val f1 = dog.sum _
    println("f1=" + f1) // f1=<function2>
    println("f1=" + f1(50, 60))

    // 直接写一个函数并使用函数
    // 格式：val f2 = (Int, Int) => {}
    val f2 = (n1: Int, n2: Int) => {
      n1 + n2 // 函数体
    }
    println("f2=" + f2) // f2=<function2>
    println("f2=" + f2(80, 90))
  }
}

class Dog {
  // 方法
  def sum(n1: Int, n2: Int): Int = {
    n1 + n2 // 方法体
  }
}

输出结果如下：

30
f1=<function2>
f1=110
f2=<function2>
f2=170

5.2.2 方法、函数、函数式编程和面向对象编程关系分析图

在学习 Scala 中将方法、函数、函数式编程和面向对象编程关系分析图如下：

5.2.3 函数式编程小结

  1、“函数式编程”是一种“编程范式”（programming paradigm）。
  2、它属于“结构化编程”的一种，主要思想是把运算过程尽量写成一系列嵌套的函数调用。
  3、函数式编程中，将函数也当做数据类型，因此可以接受函数当作输入（参数）和输出（返回值）。
  4、函数式编程中，最重要的就是函数。

5.3 为什么需要函数

学习一个技术或者知识点的流程：

5.4 函数的定义

5.4.1 函数的定义

5.4.2 快速入门案例

使用函数完全前面的案例。
示例代码如下：

package com.atguigu.chapter05

object FunDemo01 {
  def main(args: Array[String]): Unit = {
    println("" + getRes(10, 20, '+'))
  }

  // 定义一个函数/方法
  def getRes(n1: Int, n2: Int, oper: Char) = { // 返回值形式2: = 表示返回值类型不确定，使用类型推导完成。
    if (oper == '+') {
      // return n1 + n2 // return 关键字可以写可以不写
      n1 + n2
    } else if (oper == '-') {
      n1 - n2
    } else {
      // 返回 null
      null
    }
  }
}

5.5 函数的调用机制

5.5.1 函数的调用过程

  为了让大家更好的理解函数调用机制，看1个案例，并画出示意图，这个很重要，比如 getSum 计算两个数的和，并返回结果。

5.5.2 函数的递归调用

注意：Struts2 中的拦截器的底层实现机制就是把一个对象放到堆中，然后不停的开栈去指向该对象的内存地址，每一个栈都有机会去修改该对象的值。

函数递归需要遵守的重要原则（总结）
  1、程序执行一个函数时，就创建一个新的受保护的独立空间(新函数栈)。
  2、函数的局部变量是独立的，不会相互影响。
  3、递归必须向退出递归的条件逼近，否则就是无限递归，死龟了:)
  4、当一个函数执行完毕，或者遇到 return，就会返回，遵守谁调用，就将结果返回给谁。

5.5.3 递归练习题

题1：斐波那契数，请使用递归的方式，求出斐波那契数1,1,2,3,5,8,13…给你一个整数n，求出它的斐波那契数是多少？
示例代码如下：

package com.atguigu.chapter05.recursive

import scala.io.StdIn

/**
  * 题1：斐波那契数，请使用递归的方式，求出斐波那契数1,1,2,3,5,8,13... 给你一个整数n，求出它的斐波那契数是多少？
  * 思路：f(1)=1, f(2)=1, f(3)=f(2)+f(1)=1+1=2, f(4)=f(2)+f(3)=1+2=3, ..., f(n)=f(n-1)+f(n-2)
  */
object Exercise01 {
  def main(args: Array[String]): Unit = {

    println("请输入一个正整数：")
    val n = StdIn.readInt()
    printf("%d的斐波那契数是：%d", n, fbn(n))
  }

  def fbn(n: Int): Int = {
    if (n == 1 || n == 2) {
      1
    } else {
      fbn(n - 1) + fbn(n - 2)
    }
  }
}

题2：求函数值，已知 f(1)=3; f(n) = 2*f(n-1)+1; 请使用递归的思想编程，求出 f(n) 的值？
示例代码如下：

package com.atguigu.chapter05.recursive

import scala.io.StdIn

/**
  * 题2：求函数值，已知 f(1)=3; f(n) = 2*f(n-1)+1; 请使用递归的思想编程，求出 f(n) 的值？
  * n=1, f(1)=3
  * n=2, f(2)=2*f(1)+1=7
  * n=3, f(3)=2*f(2)+1=15
  *
  */
object Exercise02 {
  def main(args: Array[String]): Unit = {
    println("请输入一个正整数：")
    val n = StdIn.readInt()
    printf("f(%d) 的值是：%d", n, f(n))
  }

  def f(n: Int): Int = {
    if (n == 1) {
      3
    } else {
      2 * f(n - 1) + 1
    }
  }
}

题3：猴子吃桃子问题：有一堆桃子，猴子第一天吃了其中的一半，并再多吃了一个！以后每天猴子都吃其中的一半，然后再多吃一个。当到第十天时，想再吃时（还没吃），发现只有1个桃子了。问题：最初共多少个桃子？
示例代码如下：

package com.atguigu.chapter05.recursive

import com.atguigu.chapter05.recursive.Exercise02.f

import scala.io.StdIn

/**
  * 题3：猴子吃桃子问题：有一堆桃子，猴子第一天吃了其中的一半，并再多吃了一个！
  * 以后每天猴子都吃其中的一半，然后再多吃一个。当到第十天时，想再吃时（还没吃），发现只有1个桃子了。问题：最初共多少个桃子？
  *
  * day = 10 桃子有 1
  * day =  9 桃子有 (day10的桃子 + 1) *2
  * day =  8 桃子有 (day9 的桃子 + 1) *2
  *
  */
object Exercise03 {
  def main(args: Array[String]): Unit = {
    println("最初共有:" + f(1) + "个桃子")
  }

  def f(n: Int): Int = {
    if (n == 10) {
      1
    } else {
      (f(n + 1) + 1) * 2
    }
  }
}

5.6 函数注意事项和细节讨论

  1、函数的形参列表可以是多个，如果函数没有形参，调用时可以不带()。

  2、函数的形参列表和返回值列表的数据类型可以是值类型和引用类型。【案例演示】
示例代码如下：

package com.atguigu.chapter05.fundetails

object Details01 {
  def main(args: Array[String]): Unit = {
    val tiger = new Tiger
    val tiger2 = test01(10, tiger)
    println(tiger2.name) // tom
    println(tiger.name)  // tom
    println(tiger.hashCode() + " " + tiger2.hashCode()) // 2101440631 2101440631
  }

  // 2、函数的形参列表和返回值列表的数据类型可以是值类型和引用类型。
  def test01(n: Int, tiger: Tiger): Tiger = {
    println("n=" + n)
    tiger.name = "tom"
    tiger
    // return tiger // 3、Scala 中的函数可以根据函数体最后一行代码自行推断函数返回值类型。那么在这种情况下，return 关键字可以省略。
  }
}

class Tiger {
  var name = ""
}

  3、Scala 中的函数可以根据函数体最后一行代码自行推断函数返回值类型。那么在这种情况下，return 关键字可以省略。【案例同上】
  4、因为 Scala 可以自行推断，所以在省略 return 关键字的场合，返回值类型也可以省略。
  

  5、如果函数明确使用 return 关键字，那么函数返回就不能使用自行推断了，这时要明确写成 : 返回值类型 = ，当然如果你什么都不写，即使有 return，那么返回值为()，即这时 return 无效。
  6、如果函数明确声明无返回值（声明 Unit），那么函数体中即使使用 return 关键字也不会有返回值。
示例代码如下：

package com.atguigu.chapter05.fundetails

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

    println(getSum2(10, 30))  // ()

    println(getSum3(9, 9))    // ()

  }

  // 如果写了 return，那么返回值类型就不能省略。
  def getSum(n1: Int, n2: Int): Int = {
    return n1 + n2
  }

  // 如果返回值这里什么什么都没有写，即表示该函数没有返回值。
  // 这时 return 无效
  def getSum2(n1: Int, n2: Int) {
    return n1 + n2
  }

  // 如果函数明确声明无返回值（声明Unit），那么函数体中即使使用 return 关键字也不会有返回值。
  def getSum3(n1: Int, n2: Int): Unit = {
    return n1 + n2
  }
}

  7、如果明确函数无返回值或不确定返回值类型，那么返回值类型可以省略（或声明为 Any）。
示例代码如下：

package com.atguigu.chapter05.fundetails

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

  }

  // 7、如果明确函数无返回值或不确定返回值类型，那么返回值类型可以省略（或声明为 Any）。
  def f3(s: String) = {
    if (s.length >= 3)
      s + "123"
    else
      3
  }

  def f4(s: String): Any = {
    if (s.length >= 3)
      s + "123"
    else
      3
  }
}

  8、Scala 语法中任何的语法结构都可以嵌套其他语法结构(很灵活)，即：函数中可以再声明/定义函数，类中可以再声明类，方法中可以再声明/定义方法。
示例代码如下：

package com.atguigu.chapter05.fundetails

object Details04 {
  def main(args: Array[String]): Unit = { // public void main(String[] args)

    def f1():Unit = { // private final void f1$1
      println("f1")
    }

    def sayok(): Unit = { // private final void sayok$1
      println("sayok~")
      def sayok(): Unit = { // private final void sayok$2
        println("sayok~~")
      }
    }

    println("ok")
  }

  def sayok(): Unit = { // public void sayok()
    println("sayok")
  }
}

  9、Scala 函数的形参，在声明参数时，直接赋初始值(默认值)，这时调用函数时，如果没有指定实参，则会使用默认值。如果指定了实参，则实参会覆盖默认值。
示例代码如下：

package com.atguigu.chapter05.fundetails

object Details05 {
  def main(args: Array[String]): Unit = {
    println(sayOk())      // jack ok!
    println(sayOk("tom")) // tom ok!
  }

  def sayOk(name: String = "jack"): String = {
    return name + " ok! "
  }
}

  10、如果函数存在多个参数，每一个参数都可以设定默认值，那么这个时候，传递的参数到底是覆盖默认值，还是赋值给没有默认值的参数，就不确定了(默认按照声明顺序[从左到右])。在这种情况下，可以采用带名参数。
示例代码如下：

package com.atguigu.chapter05.fundetails

object Details06 {
  def main(args: Array[String]): Unit = {
    mysqlCon()
    mysqlCon("127.0.0.1", 7777) // 从左到右覆盖

    // 如果我们希望指定覆盖某一个默认值，则使用带名参数即可，比如只想修改用户名和密码，其他的不改
    mysqlCon(user = "tom", pwd = "1234")

    // 练习
    // f6("v2") // 报错，p2的值没有指定
    f6(p2 = "v2") // v1v2
  }

  def mysqlCon(add: String = "localhost", port: Int = 3306,
               user: String = "root", pwd: String = "root"): Unit = {
    println("add=" + add)
    println("port=" + port)
    println("user=" + user)
    println("pwd=" + pwd)
  }

  def f6(p1: String = "v1", p2: String) {
    println(p1 + p2);
  }
}

  11、scala 函数的形参默认是 val 的，因此不能在函数中进行修改。

  12、递归函数未执行之前是无法推断出来结果类型，在使用时必须有明确的返回值类型。
示例代码如下：

  def f(n: Int) = { // 错误，递归不能使用类型推断，必须指定返回的数据类型。
    if (n <= 0)
      1
    else
      n * f(n - 1)
  }

  13、Scala 函数支持可变参数。
示例代码如下：

  // 支持0到多个参数
  def sum(args: Int*): Int = {
  }

  // 支持1到多个参数
  def sum(n1: Int, args: Int*): Int = {
  }

  说明:
  1、args 是集合, 通过 for 循环 可以访问到各个值。【args 是参数名，可以任意起】
  2、案例演示： 编写一个函数 sum，可以求出 1 到多个 int 的和。
  3、可变参数需要写在形参列表的最后。
示例代码如下：

package com.atguigu.chapter05.fundetails

object VarParameters {
  def main(args: Array[String]): Unit = {
    println(sum(10, 20, 30)) // 这里可变参数为2个
  }

  // 支持1到多个参数
  def sum(n1: Int, args: Int*): Int = {
    println("args.length=" + args.length)
    var sum = n1
    for (item <- args) {
      sum += item
    }
    sum
  }
}

5.7 函数练习题

判断下面的代码是否正确：
示例代码如下：

  object Hello01 {
    def main(args: Array[String]): Unit = {
      def f1 = "venassa"
      println(f1) // 输出 venassa
    }
  }

  // 上面代码 def f1 = "venassa" 等价于
  def f1() = {
    "venassa"
  }
  // 说明：
  // 1、函数的形参列表可以是多个，如果函数没有形参，函数可以不带()。
  // 2、函数的函数体只有一行代码时，可以省略{}。

5.8 过程

5.8.1 基本概念

基本介绍：
  将函数的返回类型为 Unit 的函数称之为过程(procedure)，如果明确函数没有返回值，那么等号可以省略。

案例说明：

  // f10 没有返回值，可以使用 Unit 来说明
  // 这时，这个函数我们也叫过程（procedure）
  def f10(name: String): Unit = { // 如果明确函数没有返回值，那么等号可以省略。
    println(name+ "hello")
  }

5.8.2 注意事项和细节说明

  1、注意区分: 如果函数声明时没有返回值类型，但是有 = 号，可以进行类型推断最后一行代码。这时这个函数实际是有返回值的，该函数并不是过程。(这点在讲解函数细节的时候讲过的)
  2、开发工具的自动代码补全功能，虽然会自动加上 Unit，但是考虑到 Scala 语言的简单，灵活，最好不加。

5.9 惰性函数

5.9.1 看一个应用场景

  惰性计算（尽可能延迟表达式求值）是许多函数式编程语言的特性。惰性集合在需要时提供其元素，无需预先计算它们，这带来了一些好处。首先，您可以将耗时的计算推迟到绝对需要的时候。其次，您可以创造无限个集合，只要它们继续收到请求，就会继续提供元素。函数的惰性使用让您能够得到更高效的代码。Java 并没有为惰性提供原生支持，Scala 提供了。

5.9.2 画图说明（大数据推荐系统）

5.9.3 Java 实现懒加载的代码

示例代码如下：

package com.atguigu.chapter05;

public class LazyDemo {

    private String property; // 属性也可能是一个数据库连接，文件等资源

    public String getProperty() {
        if (property == null) { // 如果没有初始化过，那么就进行初始化
            property = initProperty();
        }
        return property;
    }

    private String initProperty() {
        return "property";
    }
}
// 比如常用的【单例模式懒汉式】实现时就使用了上面类似的思路实现

5.9.4 惰性函数介绍

  当函数返回值被声明为 lazy 时，函数的执行将被推迟，直到我们首次对此取值，该函数才会执行，这种函数我们称之为惰性函数。在 Java 的某些框架代码中称之为懒加载(延迟加载)。

5.9.5 案例演示

示例代码如下：

package com.atguigu.chapter05.mylazy

object LazyDemo01 {
  def main(args: Array[String]): Unit = {
    lazy val res = sum(10, 20)
    println("----------")
    println("res=" + res) // 在要使用 res 前，才执行
  }

  def sum(n1: Int, n2: Int): Int = {
    println("sum() 执行了..")
    return n1 + n2
  }
}

输出结果如下：

----------
sum() 执行了..
res=30

5.9.6 注意事项和细节

  1、lazy 不能修饰 var 类型的变量。
  2、不但是在调用函数时，加了 lazy，会导致函数的执行被推迟，我们在声明一个变量时，如果声明了 lazy，那么变量值的分配也会推迟。 比如 lazy val i = 10。

5.10 异常

5.10.1 介绍

  Scala 提供 try 块和 catch 块来处理异常。try 块用于包含可能出错的代码。catch 块用于处理 try 块中发生的异常。可以根据需要在程序中有任意数量的 try…catch 块。
  语法处理上和 Java 类似，但是又不尽相同。

5.10.2 Java 异常处理回顾

示例代码如下：

package com.atguigu.chapter05.exception;

public class JavaExceptionDemo {
    public static void main(String[] args) {
        try {
            // 可疑代码
            int i = 0;
            int b = 10;
            int c = b / i; // 执行代码时，会抛出 ArithmeticException 异常
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 最终要执行的代码
            System.out.println("java finally");
        }

        System.out.println("继续执行");
    }
}

输出结果如下：

java finally
继续执行
java.lang.ArithmeticException: / by zero
    at com.atguigu.chapter05.exception.JavaExceptionDemo.main(JavaExceptionDemo.java:9)

5.10.3 Java 异常处理的注意点

  1、java 语言按照 try-catch-catch…-finally 的方式来处理异常。
  2、不管有没有异常捕获，都会执行 finally，因此通常可以在 finally 代码块中释放资源。
  3、可以有多个 catch，分别捕获对应的异常，这时需要把范围小的异常类写在前面，把范围大的异常类写在后面，否则编译错误。会提示 "Exception 'java.lang.xxxxxx' has already been caught"。

5.10.4 Scala 异常处理举例

示例代码如下：

package com.atguigu.chapter05.exception

object ScalaExceptionDemo {
  def main(args: Array[String]): Unit = {
    try {
      val r = 10 / 0
    } catch {
      // 说明
      // 1. 在 scala 中只有一个 catch
      // 2. 在 catch 中有多个 case, 每个 case 可以匹配一种异常
      // 3. => 关键符号，表示后面是对该异常的处理代码块
      // 4. finally 最终要执行的代码
      case ex: ArithmeticException => { println("捕获了除数为零的算数异常") } // 当对该异常的处理代码块为一行时，{}可以省略
      case ex: Exception => println("捕获了异常")
    } finally {
      // 最终要执行的代码
      println("scala finally")
    }

    System.out.println("继续执行")
  }
}

输出结果如下：

捕获了除数为零的算数异常
scala finally
继续执行

5.10.5 Scala 异常处理小结

  1、我们将可疑代码封装在 try 块中。在 try 块之后使用了一个 catch 处理程序来捕获异常。如果发生任何异常，catch 处理程序将处理它，异常处理了程序将不会异常终止。
  2、Scala 的异常的工作机制和 Java 一样，但是 Scala 没有“checked(编译期)” 异常，即 Scala 没有编译异常这个概念，异常都是在运行的时候捕获处理。
  3、Scala 用 throw 关键字，抛出一个异常对象。所有异常都是 Throwable 的子类型。throw 表达式是有类型的，就是 Nothing，因为 Nothing 是所有类型的子类型，所以 throw 表达式可以用在需要类型的地方。
示例代码如下：

package com.atguigu.chapter05.exception

object ThrowDemo {
  def main(args: Array[String]): Unit = {
    // val res = test()
    // println(res.toString)
    // println("继续执行002") // 异常抛出了，但是没有被处理，后续程序不能执行

    // 如果我们希望在 test() 抛出异常后，后续代码可以继续执行，则我们需要如下处理
    try {
      test()
    } catch {
      case ex: Exception => {
        println("捕获到异常是：" + ex.getMessage)
        println("继续执行001")
      }
      case ex: ArithmeticException => println("得到一个算术异常（小范围异常）")
    } finally {
      // 写上对 try{} 中的资源的分配
    }

    println("继续执行002")
  }

  def test(): Nothing = {
    // Exception("异常出现")
    throw new ArithmeticException("算术异常")
  }
}

输出结果如下：

捕获到异常是：算术异常
继续执行001
继续执行002

  4、在 Scala 里，借用了模式匹配的思想来做异常的匹配，因此，在 catch 的代码里，是一系列 case 子句来匹配异常。【前面案例可以看出这个特点，模式匹配我们后面详解】，当匹配上后 => 有多条语句可以换行写，类似 java 的 switch case x: 代码块…
  5、异常捕捉的机制与其他语言中一样，如果有异常发生，catch 子句是按次序捕捉的。因此，在 catch 子句中，越具体的异常越要靠前，越普遍的异常越靠后，如果把越普遍的异常写在前，把具体的异常写在后，在 scala 中也不会报错，但这样是非常不好的编程风格。
  6、finally 子句用于执行不管是正常处理还是有异常发生时都需要执行的步骤，一般用于对象的清理工作，这点和 Java 一样。
  7、Scala 提供了 throws 关键字来声明异常。可以使用方法定义声明异常。它向调用者函数提供了此方法可能引发此异常的信息。它有助于调用函数处理并将该代码包含在 try-catch 块中，以避免程序异常终止。在 scala 中，可以使用 throws 注释来声明异常。
示例代码如下：

package com.atguigu.chapter05.exception

object ThrowsComment {
  def main(args: Array[String]): Unit = {
    f()
  }

  @throws(classOf[NumberFormatException]) // 等同于 Java 中 NumberFormatException.class
  def f() = {
    "abc".toInt
  }
}

输出结果如下：

Exception in thread "main" java.lang.NumberFormatException: For input string: "abc"
    at java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)
    at java.lang.Integer.parseInt(Integer.java:580)
    at java.lang.Integer.parseInt(Integer.java:615)
    at scala.collection.immutable.StringLike$class.toInt(StringLike.scala:272)
    at scala.collection.immutable.StringOps.toInt(StringOps.scala:29)
    at com.atguigu.chapter05.exception.ThrowsComment$.f(ThrowsComment.scala:10)
    at com.atguigu.chapter05.exception.ThrowsComment$.main(ThrowsComment.scala:5)
    at com.atguigu.chapter05.exception.ThrowsComment.main(ThrowsComment.scala)

5.11 函数的练习题

1、函数可以没有返回值案例，编写一个函数，从终端输入一个整数打印出对应的金子塔。
示例代码如下：

package com.atguigu.chapter05.exercises

import scala.io.StdIn

/**
  * 1、函数可以没有返回值案例，编写一个函数，从终端输入一个整数打印出对应的金子塔。
  * 思路：本质是打印出所有的 n行m列 数据。 分别循环即可！
  */
object Exercise01 {
  def main(args: Array[String]): Unit = {
    println("请输入一个整数n(n>=1)：")
    val n = StdIn.readInt()
    printJin(n)
  }

  def printJin(n: Int): Unit = {
    for (i <- 1 to n) { // 行数
      for (j <- 1 to (n - i)) {
        printf("-")
      }
      for (j <- 1 to (2 * i - 1)) { // 列数
        printf("*")
      }
      for (j <- 1 to (n - i)) {
        printf("-")
      }
      println()
    }
  }
}

输出结果如下：

请输入一个整数n(n>=1)：
5
----*----
---***---
--*****--
-*******-
*********

2、编写一个函数，从终端输入一个整数(1—9)，打印出对应的乘法表。
示例代码如下：

package com.atguigu.chapter05.exercises

import scala.io.StdIn

/**
  * 2、编写一个函数，从终端输入一个整数(1—9)，打印出对应的乘法表。
  */
object Exercise01 {
  def main(args: Array[String]): Unit = {
    println("请输入数字（1-9）之间：")
    val n = StdIn.readInt()
    print99(n)
  }

  def print99(n: Int): Unit = {
    for (i <- 1 to n) {
      for (j <- 1 to i) {
        printf("%d * %d = %d\t", j, i, j * i)
      }
      println()
    }
  }
}

3、编写函数，对给定的一个二维数组 (3×3) 转置，这个题讲数组的时候再完成。

    1 2 3       1 4 7            
    4 5 6       2 5 8               
    7 8 9       3 6 9

第六章 面向对象编程-基础

6.1 类与对象

看一个养猫猫问题：
  张老太养了只猫猫：一只名字叫小白，今年3岁，白色。还有一只叫小花，今年10岁，花色。请编写一个程序，当用户输入小猫的名字时，就显示该猫的名字，年龄，颜色。如果用户输入的小猫名错误，则显示张老太没有这只猫猫。

问题：
  1、猫有三个属性，类型不一样。
  2、如果使用普通的变量就不好管理。
  3、使用一种新的数据类型：
    (1) 可以管理多个不同类型的数据 [属性]。
    (2) 可以对属性进行操作 => 方法。

类与对象的关系示意图

6.1.1 Scala 语言是面向对象的

  1、Java 是面向对象的编程语言，由于历史原因，Java 中还存在着非面向对象的内容：基本类型，null，静态方法等。
  2、Scala 语言来自于 Java，所以天生就是面向对象的语言，而且 Scala 是纯粹的面向对象的语言，即在 Scala 中，一切皆为对象。
  3、在面向对象的学习过程中可以对比着 Java 语言学习。

6.1.2 快速入门-面向对象的方式解决养猫问题

示例代码如下：

package com.atguigu.chapter06.oop

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

    // 创建一只猫
    val cat = new Cat

    // 给猫的属性赋值
    // 说明
    // 1. cat.name = "小白" 其实不是直接访问属性，而是等价于 cat.name_$eq("小白")
    // 2. cat.name 等价于 cat.name()
    cat.name = "小白"
    cat.age = 3
    cat.color = "白色"

    printf("\n小猫的信息如下：%s %d %s", cat.name, cat.age, cat.color)
  }
}

/* 反编译查看源码
public void main (String[] args) {
  Cat cat = new Cat ();

  cat.name_$eq ("小白");
  cat.age_$eq (3);
  cat.color_$eq ("白色");
}
*/

// 定义一个 Cat 类
// 一个 class Cat 对应的字节码文件只有一个 Cat.class ，默认是public
class Cat {
  // 定义/声明三个属性
  // 说明
  // 1. 当我们声明了 var name: String 时，同时在底层对应生成 private name
  // 2. 同时在底层会生成 两个 public 方法 public String name() 类似 => getter 和 public void name_$eq(String x$1) => setter
  var name: String = "" // Scala 中定义变量必须给初始值
  var age: Int = _ // 下划线表示给 age 一个默认值，如果是 Int 类型，默认就是 0
  var color: String = _ // 如果是 String 类型，默认值就是 null
}

/* 反编译查看源码
public class Cat {
  private String name = "";
  private int age;
  private String color;

  public String name() {
    return this.name;
  }
  public void name_$eq(String x$1) {
    this.name = x$1;
  }
  public int age() {
    return this.age;
  }
  public void age_$eq(int x$1) {
    this.age = x$1;
  }
  public String color() {
    return this.color;
  }
  public void color_$eq(String x$1) {
    this.color = x$1;
  }
}
*/

输出结果如下：

小猫的信息如下：小白 3 白色

6.1.3 类和对象的区别和联系

通过上面的案例和讲解我们可以看出：
  1、类是抽象的，概念的，代表一类事物，比如人类，猫类…
  2、对象是具体的，实际的，代表一个具体事物。
  3、类是对象的模板，对象是类的一个个体，对应一个实例。
  4、Scala 中类和对象的区别和联系 和 Java 是一样的。

6.1.4 如何定义类

我们可以通过反编译来看 scala 的类默认为 public 的特性。

6.1.5 属性

示例代码如下：

class Dog {
  var name = "jack"
  var lover = new Fish
}

class Fish {

}

6.1.6 属性/成员变量

示例代码如下：

package com.atguigu.chapter06.oop

object PropertyDemo {
  def main(args: Array[String]): Unit = {
    // val p1 = new Person
    // println(p1.Name)     // Null
    // println(p1.address)  // String 类型

    val a = new A
    println(a.var1) // null
    println(a.var2) // 0
    println(a.var3) // 0.0
    println(a.var4) // false

    // 不同对象的属性是独立，互不影响，一个对象对属性的更改，不影响另外一个
    // 创建两个对象
    var worker1 = new Worker
    worker1.name = "jack"
    var worker2 = new Worker
    worker2.name = "tom"
  }
}

class Person3 {
  var age: Int = 10   // 给属性赋初值，省略类型，会自动推导
  var sal = 8090.9
  var Name = null     // Name 是什么类型
  var address: String = null // ok
}

class A {
  var var1: String = _  // null   String 和 引用类型默认值是 null
  var var2: Byte = _    // 0
  var var3: Double = _  // 0.0
  var var4: Boolean = _ // false
}

class Worker {
  var name = ""
}

输出结果如下：

null
0
0.0
false

6.1.7 属性的高级部分

  说明：属性的高级部分和构造器(构造方法/函数) 相关，我们把属性高级部分放到构造器那里讲解。

6.1.8 如何创建对象

示例代码如下：

package com.atguigu.chapter06.oop

object CreateObjDemo {
  def main(args: Array[String]): Unit = {
    val emp = new Emp // 此时的 emp 类型就是 Emp

    // 如果我们希望将子类对象，交给父类引用，这时就需要写上类型，不能省略！
    val emp1: Person = new Emp
  }
}

class Person {

}

class Emp extends Person {

}

6.1.9 类和对象的内存分配机制（重要）

内存布局图：

示例代码如下：

package com.atguigu.chapter06.oop

object MemState {
  def main(args: Array[String]): Unit = {
    val p2 = new Person2
    p2.name = "jack"
    p2.age= 10

    val p1 = p2
    println(p1 == p2) // true
    println("p2.age=" + p2.age) // 10
    println("p1.age=" + p1.age) // 10
  }
}

class Person2 {
  var name = ""
  var age: Int = _ // 如果是用下划线的方式给默认值，则属性必须指定类型，因为这有这样，scala 底层才能够进行类型推断
}

6.2 方法

6.2.1 基本说明和基本语法

示例代码如下：

package com.atguigu.chapter06.method

object MethodDemo01 {
  def main(args: Array[String]): Unit = {
    // 使用一把
    val dog = new Dog
    println(dog.cal(10, 20))
  }
}

class Dog {
  private var sal: Double = _
  var food: String = _

  def cal(n1: Int, n2: Int): Int = {
    return n1 + n2
  }
}

6.2.2 方法的调用机制原理

6.2.3 方法练习题

1~3题的示例代码如下：

package com.atguigu.chapter06.method

/**
  * 1、编写类(MethodExec)，编写一个方法，方法不需要参数，在方法中打印一个10*8的矩形，在main方法中调用该方法。
  *
  * 2、修改上一个程序，编写一个方法中，方法不需要参数，计算该矩形的面积，并将其作为方法返回值。在main方法中调用该方法，接收返回的面积值并打印(结果保留小数点2位)。
  *
  * 3、修改上一个程序，编写一个方法，提供m和n两个参数，方法中打印一个m*n的矩形，再编写一个方法计算该矩形的面积(可以接收长len和宽width)， 将其作为方法返回值。在main方法中调用该方法，接收返回的面积值并打印。
  */
object MethodDemo02 {
  def main(args: Array[String]): Unit = {
    val m = new MethodExec
    m.printRect1()

    m.len = 1.2
    m.width = 3.4
    println("面积=" + m.area1())

    m.printRect2(5, 4)
    println("面积=" + m.area2(1.2, 3.4))
  }
}

class MethodExec {

  var len = 0.0
  var width = 0.0

  def printRect1(): Unit = {
    for (i <- 0 until 10) {
      for (j <- 0 until 8) {
        print("*")
      }
      println()
    }
  }

  def area1(): Double = {
    this.len * this.width.formatted("%.2f").toDouble
  }

  def printRect2(m: Int, n: Int): Unit = {
    for (i <- 0 until m) {
      for (j <- 0 until n) {
        printf("*")
      }
      println()
    }
  }

  def area2(len: Double, width: Double): Double = {
    len * width.formatted("%.2f").toDouble
  }
}

输出结果如下：

********
********
********
********
********
********
********
********
********
********
面积=4.08
****
****
****
****
****
面积=4.08

4~6题的示例代码原理同上1~3题，不在赘述！

6.3 类与对象应用实例

景区门票案例

小狗案列的示例代码如下：

package com.atguigu.chapter06.dogcase

/**
  * 小狗案例
  *
  * 编写一个Dog类，包含name(String)、age(Int)、weight(Double)属性。
  * 类中声明一个say方法，返回String类型，方法返回信息中包含所有属性值。
  * 在另一个DogCaseTest类中的main方法中，创建Dog对象，并访问say方法和所有属性，将调用结果打印输出。
  */
object DogCaseTest {
  def main(args: Array[String]): Unit = {
    val dog = new Dog
    dog.name = "泰斯特"
    dog.age = 2
    dog.weight = 50
    println(dog.say())
  }
}

class Dog {
  var name = ""
  var age = 0
  var weight = 0.0

  def say(): String = {
    "小狗的信息是：name=" + this.name + "\tage=" + this.age + "\tweight=" + this.weight
  }
}

输出结果如下：

小狗的信息是：name=泰斯特    age=2   weight=50.0

盒子案列、景区门票案例的示例代码原理同上小狗案例，不在赘述！

6.4 构造器

6.4.1 看一个需求

  前面我们在创建 Person 的对象时，是先把一个对象创建好后，再给他的年龄和姓名属性赋值，如果现在我要求，在创建人类的对象时，就直接指定这个对象的年龄和姓名，该怎么做? 这时就可以使用构造方法/构造器。

6.4.2 回顾-Java 构造器的介绍+基本语法+特点+案例

Java 构造器的介绍
  构造器(constructor)又叫构造方法，是类的一种特殊的方法，它的主要作用是完成对新对象的初始化。

Java 构造器的基本语法

Java 构造器的特点

Java 构造器的案例

6.4.3 Scala 构造器的介绍+基本语法+快速入门

Scala 构造器的介绍
  和 Java 一样，Scala 构造对象也需要调用构造方法，并且可以有任意多个构造方法（即 scala 中构造器也支持重载）。
  Scala 类的构造器包括： 主构造器 和 辅助构造器。

Scala 构造器的基本语法

Scala 构造器的快速入门
示例代码如下：

package com.atguigu.chapter06.constructor

/**
  * Scala构造器的快速入门：创建Person对象的同时初始化对象的age属性值和name属性值
  */
object ConstructorDemo01 {
  def main(args: Array[String]): Unit = {
    val p1 = new Person("bruce", 20)
    println(p1)
  }
}

class Person(inName: String, inAge: Int) {
  var name: String = inName
  var age: Int = inAge

  // 重写toString方法
  override def toString: String = {
    "name=" + this.name + "\tage=" + this.age
  }
}

输出结果如下：

name=bruce    age=20

6.4.4 Scala 构造器注意事项和细节

  1、Scala 构造器作用是完成对新对象的初始化，构造器没有返回值。
  2、主构造器的声明直接放置于类名之后。【可以反编译查看】
  3、主构造器会执行类定义中的所有语句(除掉函数部分)，这里可以体会到 Scala 的函数式编程和面向对象编程融合在一起，即：构造器也是方法（函数），传递参数和使用方法和前面的函数部分内容没有区别。【案例演示+反编译查看-语法糖】
  4、如果主构造器无参数，小括号可省略，构建对象时调用的构造方法的小括号也可以省略。
  5、辅助构造器名称为 this（这个和 Java 是不一样的），多个辅助构造器通过不同参数列表进行区分， 在底层就是f构造器重载。【案例演示+反编译查看】
示例代码如下：

package com.atguigu.chapter06.constructor

object ConstructorDemo02 {
  def main(args: Array[String]): Unit = {
    // val a = new A
    val aa = new A("jack")
    // 执行顺序：
    // 1、bbb  父类构造器
    // 2、A    子类主构造器
    // 3、aaa  子类辅助构造器
  }
}

class B {
  println("bbb")
}

class A extends B {
  println("A")
  def this(name: String) {
    this // 调用A的主构造器，其根本原因就是实现子类与父类之间的继承关系，不然继承关系就断了！！！
    println("aaa")
  }
}

输出结果如下：

bbb
A
aaa

示例代码如下：

package com.atguigu.chapter06.constructor

object ConstructorDemo03 {
  def main(args: Array[String]): Unit = {
    val p1 = new Person("scott")
    p1.showInfo()
  }
}

class Person() {
  var name: String = _
  var age: Int = _

  def this(name: String) {
    // 辅助构造器无论是直接或间接，最终都一定要调用主构造器，执行主构造器的逻辑
    // 而且需要放在辅助构造器的第一行[这点和 java 一样，java 中一个构造器要调用同类的其它构造器，也需要放在第一行]
    this() // 直接调用主构造器
    this.name = name
  }

  def this(name: String, age: Int) {
    this() // 直接调用主构造器
    this.name = name
    this.age = age
  }

  def this(age: Int) {
    this("匿名") // 间接调用主构造器，因为 def this(name: String) 中直接调用了主构造器
    this.age = age
  }

  def showInfo(): Unit = {
    println("person信息如下:")
    println("name=" + this.name)
    println("age=" + this.age)
  }
}

输出结果如下：

person信息如下:
name=scott
age=0

  6、如果想让主构造器变成私有的，可以在()之前加上 private，这样用户只能通过辅助构造器来构造对象了。【反编译查看】
  7、辅助构造器的声明不能和主构造器的声明(即形参列表)一致，会发生错误(即构造器名重复)。

6.5 属性高级

  前面我们讲过属性了，这里我们再对属性的内容做一个加强。

6.5.1 构造器参数

示例代码如下：

package com.atguigu.chapter06.constructor

object ConstructorDemo04 {
  def main(args: Array[String]): Unit = {
    val worker1 = new Worker1("smith1")
    worker1.name    // 不能访问 inName

    val worker2 = new Worker2("smith2")
    worker2.inName  // 可以访问 inName
    println("hello!")

    val worker3 = new Worker3("jack")
    worker3.inName = "mary"
    println(worker3.inName)
  }
}

// 1. 如果 主构造器是 Worker1(inName: String)，那么 inName 就是一个局部变量。
class Worker1(inName: String) {
  var name = inName
}
// 2. 如果 主构造器是 Worker2(val inName: String)，那么 inName 就是 Worker2 的一个 private 的只读属性。
class Worker2(val inName: String) {
  var name = inName
}

// 3. 如果 主构造器是 Worker3(var inName: String)，那么 inName 就是 Worker3 的一个 private 的可以读写属性。
class Worker3(var inName: String) {
  var name = inName
}

6.5.2 Bean 属性

示例代码如下：

package com.atguigu.chapter06.constructor

import scala.beans.BeanProperty

object BeanPropertyDemo {
  def main(args: Array[String]): Unit = {
    val car = new Car
    car.name = "宝马"
    println(car.name)

    // 使用 @BeanProperty 自动生成 getXxx() 和 setXxx()
    car.setName("奔驰")
    println(car.getName())
  }
}

class Car {
  @BeanProperty var name: String = null
}

6.6 Scala 对象创建的流程分析

6.7 作业03

1、一个数字如果为正数，则它的 signum 为1.0，如果是负数，则 signum 为-1.0，如果为0，则 signum 为0.0。编写一个函数来计算这个值。
示例代码如下：

package com.atguigu.chapter06.exercises

import scala.io.StdIn

/**
  * 1、一个数字如果为正数，则它的 signum 为1，如果是负数，则 signum 为-1，如果为0，则 signum 为0。编写一个函数来计算这个值。
  */
object Exercise01 {
  def main(args: Array[String]): Unit = {
    println("请输入一个数字：")
    val n = StdIn.readDouble()
    println("该数的 signum 为：" + signum(n))
  }

  def signum(n: Double): Double = {
    if (n > 0) {
      1
    } else if (n < 0) {
      -1
    } else {
      0
    }
  }
}

输出结果如下：

请输入一个数字：
0
该数的 signum 为：0.0

请输入一个数字：
5
该数的 signum 为：1.0

请输入一个数字：
-3
该数的 signum 为：-1.0

2、一个空的块表达式{}的值是什么？类型是什么？
示例代码如下：

package com.atguigu.chapter06.exercises

/**
  * 2、一个空的块表达式 {} 的值是什么？类型是什么？
  */
object Exercise02 {
  def main(args: Array[String]): Unit = {
    val t = {}
    println("t=" + t) // t=()
    println(t.isInstanceOf[Unit]) // true
  }
}

3、针对下列 Java 循环编写一个 Scala 版本：

    for (int i=10; i>=0; i–-) {
        System.out.println(i);
    }

示例代码如下：

package com.atguigu.chapter06.exercises

/**
  * 3、针对下列 Java 循环编写一个 Scala 版本：
  * for (int i=10; i>=0; i–-) {
  *   System.out.println(i);
  * }
  */
object Exercise03 {
  def main(args: Array[String]): Unit = {
    // 方式一：
    for (i <- 0 to 10) {
      println("i=" + (10 - i))
    }

    println("----------")

    // 方式二：
    for (i <- 0 to 10 reverse) { // 逆序
      println("i=" + i)
    }

    // 定义一个 List 集合
    val list = List(1, 2, 3)
    println(list) // List(1, 2, 3)
    println(list.reverse) // List(3, 2, 1)
  }
}

4、编写一个过程 countdown(n: Int)，打印从 n 到 0 的数字。
示例代码如下：

package com.atguigu.chapter06.exercises

import scala.io.StdIn

/**
  * 4、编写一个过程 countdown(n:Int)，打印从 n 到 0 的数字。
  */
object Exercise04 {
  def main(args: Array[String]): Unit = {

    val m=3
    val res1 = (0 to m).reverse
    println(res1) // Range(3, 2, 1, 0)

    // foreach
    // foreach 函数可以接收 (f: Int => U)，即接收一个输入参数为 Int，输出参数为 Unit 的函数
    // 下面这句代码的含义是：
    // 1、将 res1 的每个元素依次遍历出来，传递给 println(x)
    // 调用系统的 println 函数
    res1.foreach(println)

    // 调用自定义的 println 函数
    res1.foreach(myPrintln)

    println("----------")
    println("请输入一个数字：")
    val n = StdIn.readInt()
    println("----------")
    countdown(n)
    println("----------")
    countdown2(n)
    println("----------")
    countdown3(n)
  }

  // 自定义一个 println 函数
  def myPrintln(n: Int): Unit = {
    println(n)
  }

  // 方式一：
  def countdown(n: Int): Unit = {
    for (i <- 0 to n) {
      println(n-i)
    }
  }

  // 方式二：
  def countdown2(n: Int): Unit = {
    for (i <- 0 to n reverse) {
      println(i)
    }
  }

  // 方式三：
  def countdown3(n: Int): Unit = {
    // 说明
    // 这里使用到高阶函数的特性
    (0 to n).reverse.foreach(println)
  }
}

5、编写一个 for 循环，计算字符串中所有字母的 Unicode 代码（toLong 方法）的乘积。举例来说，"Hello" 中所有字符串的乘积为 9415087488L。
示例代码如下：

package com.atguigu.chapter06.exercises

import scala.io.StdIn

/**
  * 5、编写一个 for 循环，计算字符串中所有字母的 Unicode 代码（toLong 方法）的乘积。举例来说，"Hello" 中所有字符串的乘积为 9415087488L。
  */
object Exercise05 {
  def main(args: Array[String]): Unit = {
    println("请输入一行字符串：")
    val str = StdIn.readLine()
    println("该字符串中所有字母的 Unicode 代码的乘积为：" + unicode(str))

    unicode2()
  }

  // 方式一：
  def unicode(str: String): Long = {
    var res:Long = 1
    for (i <- 0 to str.length - 1) { // 索引从0开始
      var s = str.charAt(i).toLong
      res *= s
    }
    res
  }

  // 方式二：
  def unicode2() = {
    var res:Long = 1
    for (i <- "Hello") {
      res *= i.toLong
    }
    println("res=" + res)
  }
}

输出结果如下：

请输入一行字符串：
Hello
该字符串中所有字母的 Unicode 代码的乘积为：9415087488
res=9415087488

6、同样是解决前一个练习的问题，请用 StringOps 的 foreach 方式解决。
示例代码如下：

package com.atguigu.chapter06.exercises

import scala.io.StdIn

/**
  * 6、同样是解决前一个练习的问题，请用 StringOps 的 foreach 方式解决。
  */
object Exercise06 {
  def main(args: Array[String]): Unit = {
    var res1: Long = 1
    // 说明
    // 方式一：
    // "Hello".foreach((_) => {res *= _.toLong})
    "Hello".foreach(res1 *= _.toLong)
    println("res1=" + res1)

    // 方式二：
    var res2 = 1L
    "Hello".foreach(myCount)
    println("res1=" + res2)
    def myCount(char: Char): Unit = {
      res2 *= char.toLong
    }
  }
}

输出结果如下：

res1=9415087488
res1=9415087488

7、编写一个函数 product(str: String)，计算字符串中所有字母的 Unicode 代码（toLong 方法）的乘积。
示例代码如下：

package com.atguigu.chapter06.exercises

import scala.io.StdIn

/**
  * 7、编写一个函数 product(str: String)，计算字符串中所有字母的 Unicode 代码（toLong 方法）的乘积。
  */
object Exercise07 {
  def main(args: Array[String]): Unit = {
    println("请输入一行字符串：")
    val str = StdIn.readLine()
    println("该字符串中所有字母的 Unicode 代码的乘积为：" + product1(str))
    println("该字符串中所有字母的 Unicode 代码的乘积为：" + product2(str))
  }

  // 方式一：
  def product1(str: String): Long = {
    var multi = 1L
    for (i <- 0 to str.length - 1) { // 索引从0开始
      var s = str.charAt(i).toLong
      multi *= s
    }
    multi
  }

  // 方式二：
  def product2(str: String): Long = {
    var multi = 1L
    for (i <- str) {
      multi *= i.toLong
    }
    multi
  }
}

输出结果如下：

请输入一行字符串：
Hello
该字符串中所有字母的 Unicode 代码的乘积为：9415087488
该字符串中所有字母的 Unicode 代码的乘积为：9415087488

8、把7练习中的函数改成递归函数。
示例代码如下：

package com.atguigu.chapter06.exercises

/**
  * 8、把7练习中的函数改成递归函数。
  */
object Exercise08 {
  def main(args: Array[String]): Unit = {
    println("res=" + product("Hello")) // res=9415087488

    println("Hello".take(1)) // H     获取的是该字符串的第一个字符串
    println("Hello".drop(1)) // ello  获取的是该字符串的除第一个字符串之外的剩余字符串
  }

  def product(str: String): Long = {
    if (str.length == 1) return str.charAt(0).toLong
    else str.take(1).charAt(0).toLong * product(str.drop(1))
  }
}

输出结果如下：

res=9415087488
H
ello

9、编写函数计算，其中 n 是整数，使用如下的递归定义：

示例代码如下：

package com.atguigu.chapter06.exercises

/**
  * 9、编写函数计算，其中 n 是整数，使用如下的递归定义：
  */
object Exercise09 {
  def main(args: Array[String]): Unit = {
    println(mi(2.5, 3))
  }

  // 递归的妙用：求 x 的 n 次方，厉害啊！！！
  def mi(x: Double, n: Int): Double = {
    if (n == 0) 1   // x 的 0 次方等于 1
    else if (n > 0) x * mi(x, n - 1)
    else 1 / mi(x, -n)
  }
}

注意：本题可以用于好好理解“递归”的妙用！！！

Java 与 Scala 在函数层面上的不同体现：
// 在 Java 中
函数(接收参数)

// 在 Scala 中
集合.函数(函数)

如下图所示：