当前位置：首页 > 后端开发 > 正文内容

Scala办法和函数

邻居的猫1个月前 (12-09)后端开发476

办法和函数的效果几乎是相同的,可是函数在运用的过程中愈加灵敏和多样化
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：无参，无回来值
函数 2：无参，有回来值
函数 3：有参，无回来值
函数 4：有参，有回来值
函数 5：多参，无回来值
函数 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 类 .办法调用

办法总结

留意办法的参数和回来值能够是函数 ,这样的办法称为高阶函数 ,高阶函数中具体解说

界说办法的关键字，def
办法的回来值，终究一行的内容，假如是循环,打印，那么回来值是 Unit
假如空参办法，界说的时分有()，调用的时分能够省掉()，可是假如界说的时分没有(),调用办法的时分，不能加()
办法的回来值类型，能够省掉，可是特别情况下，有必要加上：
￮办法有 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 关键字界说，函数的标识 =>
• 办法不能作为终究的表达式存在，可是函数能够，回来函数的签名信息
• 办法和函数调用的时分都需求显现的传入参数
• 函数能够作为办法的参数，和回来值类型。