• 方法和函数的作用几乎是一样的,但是函数在使用的过程中更加灵活和多样化
• scala中函数是头等公民 . 可以作为方法的返回值和参数使用
• scala是一个集面向对象和面向函数于一身的编程语言 , 灵活的函数是函数式编程的一种体现
• 函数的使用使代码更加简洁和灵活

函数

scala中一种函数式编程语言 ,函数是scala中的头等公民,建议优先使用函数 , 函数实现的功能和方法一样 ,但是我们可以把函数理解成一种特殊的业务逻辑对象 ,所以函数可以作为参数和返回值.... 函数也是用来处理数据的代码封装

函数的定义

方式一：

val / var 函数名称=（函数的参数列表） => 函数体

举例：

val add = (x: Int, y: Int) => {
 x + y
}
val parseStr = (str: String) => {
 str.toUpperCase()
}
// 函数体中的内容只有一行代码可以省略大括号
 var product = (x:Double) => x*x

方式二：

val / var 函数名称：（输入参数类型）=> 返回值类型 = （参数的引用）=> 函数体
val add2:(Int,Int)=>Int=(x,y)=>{
 x+y
}
add2 函数名
(Int ,Int) 要处理的参数类型列表
=>Int 函数处理完数据的返回值类型
=(x,y) 传入实际参数的接收变量名
{x+y} 函数体 运算求和
注意: 代码块的最后一行是函数的返回值 ,需要和=>(Int)类型保持一致

分类

1. 函数 1：无参，无返回值
2. 函数 2：无参，有返回值
3. 函数 3：有参，无返回值
4. 函数 4：有参，有返回值
5. 函数 5：多参，无返回值
6. 函数 6：多参，有返回值

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
 }
 } 

函数的本质

函数的本质其实就是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"

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的接口也写一遍，了解下函数的本质

//接口
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的连接

//定义一个函数，功能是获取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")
}

方法

方法是逻辑片段的封装 ,可以处理一个或者多个数据 , 可以有返回值也可以没有没有返回值 ,提高了代码的复用性

方法的定义

def functionName ([参数列表]) : [return type] = {
 function body
 return [expr]
}

没有等号和方法体的方法称为抽象方法,抽象方法定义在抽象类和特质中
代码示例：

// 定义一个方法 有两个参数 有返回值
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

方法的调用

方法的调用和java中的调用方式不太一样，如果方法定义在object中 在本类直接方法名调用 在其他类中调用 object 对象名调用，如果方法定义在普通的class 类中 , 本类之间直接调用! 其他类中new 类 .方法调用

方法总结

注意方法的参数和返回值可以是函数 ,这样的方法称为高阶函数 ,高阶函数中详细讲解

1. 定义方法的关键字，def
2. 方法的返回值，最后一行的内容，如果是循环,打印，那么返回值是 Unit
3. 如果空参方法，定义的时候有()，调用的时候可以省略()，但是如果定义的时候没有(),调用方法的时候，不能加()
4. 方法的返回值类型，可以省略，但是特殊情况下，必须加上：
   ￮ 方法有 return 关键字
   ￮ 递归调用的方法。

代码示例：

val f = (x:String)=>{x}
f
def show(x:String) :Unit ={
 x
}
show

练一练：

需求一：定义一个方法，传入一个1-9中任意的整数，如果这个整数是在1-9内，那么就打印九九乘法表中到第几行，如果传进去的不是一个1-9的数，打印：干啥呢，不好好听课，要传1-9的整数

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()
 }
 }
 }
}

需求二：写一个二分查找的方法,传入一个数组，再传入一个整数，去查找这个整数是不是在这个数组中，如果在，就返回他的索引位置，如果不在，就返回：对不起，你查找的数不存在

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
 }
 }
}

函数和方法

相互转换

def add(x: Int, y: Int) = {
 x + y
}
// 将方法转换成函数
val f = add _

当我们将方法作为参传递的时候 ,其实底层是将方法自动转换成函数

区别

在函数式编程语言中，函数是“头等公民”，它可以像任何其他数据类型一样被传递,函数可以当成值来进行传递，方法的参数和返回值都可以是函数。 函数和变量，类，对象， 是一个级别的。
区别和联系：
• 方法用 def 关键字定义，函数的标识 =>
• 方法不能作为最终的表达式存在，但是函数可以，返回函数的签名信息
• 方法和函数调用的时候都需要显示的传入参数
• 函数可以作为方法的参数，和返回值类型。