Scala 之方法和函数总结

Scala 之方法和函数总结

1.背景

1. scala作为一门编程语言，语言设计就贯穿2个思想，面向对象和支持函数式编程
2. 在所有编程语言中，如何对代码进行不同粒度的管理都是一个值得深入思考的问题。
3. java中的代码管理，从项目、包、类、方法逐级细化。由于方法无法脱离对象存在，所以实际上java代码最小粒度是对象级别
4. scala中的代码管理，相比java更细化，因为支持函数式编程。项目、包、类（内部含方法）、函数。
5. scala在语言设计时，为了能够更好利用现有java和JavaScript广大生态体系下的第三方库，scala允许在代码中直接调用java和js的代码。同样的设计思想体现在方法转换为函数的便捷性上，稍后会演示方法如何显式和隐式转换为函数。
6. 所有函数式语言特性的编程语言都会将函数作为一等公民，也就是函数可以作为参数、返回值。

2. scala方法

2.1 概述

1. 方法跟函数一样，都是代码的封装。但方法无法脱离对象而存在。
2. scala中为了更好管理，设计了class存放非静态代码，设计了object存放静态代码。一个叫伴生类class修饰的就是，一个叫伴生对象object修饰的就是。
3. scala的方法和java一样，都区分了静态方法和对象方法。
4. scala的方法定义，需要以def起始来定义方法，方法可以定义在class或者object修饰的大括号内。
5. 其他约束和java一样，包括方法命名规范，参数列表，返回值等，都和java一致。

2.2 方法定义

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

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

package com.doit.method

// 这是伴生对象，用来放静态代码的，包括main入口方法
object MethodTest1 {

  // 这是定义在伴生类中方法，属于静态方法，调用时直接类名调用即可
  // 这是scala基于java中静态和非静态设计的升级，直接将静态代码和非静态代码剥离开
  def add(x:Int, y: Int): Int = {
    x+y
  }

  def minus(x:Int, y: Int): Int = {
    return x-y
  }


  def main(args: Array[String]): Unit = {
    // 定义在class中的都是对象方法和属性，需要创建对象来使用
    val test = new MethodTest1
    println(test.add(2, 4))

    test.show()

    // 静态方法调用
    println(add(4, 5))

    // 静态方法调用，和java一样，
    println(MethodTest1.minus(10, 9))
  }
}



// 这是伴生类，用来放对象方法和属性的，非静态代码放在这里
class MethodTest1 {

  // 有参数方法
  def add(x:Int, y: Int): Int = {
    x+y
  }

  // 有参数方法
  def minus(x:Int, y: Int): Int = {
    return x-y
  }

  // 无参数方法
  def show() = {
    println("展示一个寂寞，程序员的浪漫谁能懂？？？")
    println("举杯邀明月，对影成三人")
  }

  // 注意，无参方法定义时没有加小括号，调用时也不要加小括号，否则就会报错
  // 从代码可读性来说，加上小括号更有利于代码阅读，能够明确知道这是一个方法
  def show2 = {
    println("展示一个寂寞，程序员的浪漫谁能懂？？？")
    println("举杯邀明月，对影成三人")
  }
}

2.3 方法调用

上述代码案例已经演示

方法的调用和java中的调用方式不太一样

1. 如果方法定义在object中 在本类直接方法名调用 在其他类中调用 object 对象名调用
2. 如果方法定义在普通的class 类中 , 本类之间直接调用! 其他类中new 类 .方法调用

2.4嵌套方法

可以类比java的内部类，不过这个是内部方法。

def  factorial(x:Int):Int={
  def fact(x:Int ,y:Int):Int={
    if(x<=1) y
    else fact(x-1 , x*y)
  }
  fact(x,1)
}

嵌套的方法必须指定返回值类型 ,实际企业开发时，较少使用这个嵌套方法功能

2.5 方法特征

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

1，定义方法的关键字，def
2，方法的返回值，最后一行的内容，如果是循环，那么返回值是 Unit学大数据上多易教育
3，如果空参方法，定义的时候有（），调用的时候可以省略（），但是如果定义的时候没
有（），调用方法的时候，不能加（）
4，方法的返回值类型，可以省略，但是特殊情况下，必须加上：
4.1,方法有 return 关键字
4.2，递归调用的方法。
5，方法不能最为最终的表达式存在，（空参的方法调用除外）

2.6 案例演示

package com.doit.method

object MethodTest2 {

  def main(args: Array[String]): Unit = {
    val ints: Array[Int] = Array(2, 1, 4, 5, 0, 4)

    val i: Int = binarySearch(ints, 2)
    println(i)
  }

  // 传入数组，以及需要查找的数字，返回的是index
  def binarySearch(arr:Array[Int], find: Int) : Int = {
    if(arr.length == 0) {
      return -1
    }

    // 先将数组变成有序的数组
    val sorted: Array[Int] = arr.sorted

    // 起始index
    var  start = 0

    // 尾部index
    var end = arr.length -1

    while (start <= end) {
      val mid = (start+end)/2

      if(sorted(mid) > find) {
        end = mid -1
      } else if(sorted(mid) < find) {
        start = mid + 1
      } else {
        return mid
      }
    }

    return -1
  }
}

3. scala函数

3.1 函数定义

• 方式一
  val| var 函数名称=（函数的参数列表） => 函数体

package com.doit.function

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

    val add: (Int, Int) => Int = (x: Int, y: Int) => {
      x + y
    }

    val parseInt: String => Int = (str: String) => {
      str.toInt
    }

    println(add(9, 19))

    println(add(1, 3))

    println(square(10))
  }

  private val square: Double => Double = (x: Double) => {
    x * x
  }
}

注意，函数也是一种类型，例如代码中函数square，其类型就是Double => Double。
意思就是一个参数是一个Double类型，返回值也是一个Double类型的函数。
scala的语言设计，贯彻了面向对象的思想。

函数可以作为最终的表达式存在，返回的内容就是函数的签名 签名（函数的名称，函数的参数，函数的返回值类型） 这种定义方式不需要指定返回值类型，编译器会自动推断

• 方式二
  val | var 函数名称：（输入参数类型）=> 返回值类型 = （参数的引用）=> 函数体
  

val parseInt: String => Int = (str: String) => {
      str.toInt
}

注意，这里单个单数，所以没有使用括号括起来，如果多个参数，就需要使用括号将参数括起来，参数之间使用逗号隔离开。
默认函数最后一行就是返回值，如果确认不需要返回值，请显式指定返回值就是Unit，也就是java中的void
如果函数中使用return进行数值返回，函数定义时一定要指明数据类型

3.2 特殊的无参函数

package com.doit.function

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

    // 无参数，返回值是Unit，也就是java的void，相当于无返回值
    val show: () => Unit = () => {
      println("无参函数")
    }
    
    // 无参数，无返回值
    val show2=()=>{
      println("无参函数")
    }
    
    val get:()=>String=()=>{
      "有返回值，这个字符串就是返回值，因为最后一句代码默认就是返回值，和javascript一样"
    }
  }
}

3.3 函数细节点

1. 函数中的参数;列表可以有多个,也可以没有参数 ,没有参数的函数调用的时候不用写()
2. 函数的参数和返回值可以是值类型,也可以是引用类型,
3. 函数的返回值和参数是函数的时候称为高阶函数
4. 函数的最后一行为推断函数返回值的重要依据 , 可以省略return
5. 函数中可以在声明函数

4. scala中调用java对象和方法

1. scala和java代码之间的调用非常简单，直接使用即可。
2. 对比swift调用object c代码还要简单，有些类似c++直接调用c的代码，无缝连接。

package com.doit.method;

import javax.swing.*;

/**
 * @author hulc
 * @slogan: just do it
 * @date 2020/9/7 22:52
 */

public class Haha {
    public void xixi() {
        System.out.println("这个方法无参数，无返回值，只是打印了一个寂寞");
    }
}

package com.doit.method

object HahaTest {
  def main(args: Array[String]): Unit = {
    val haha = new Haha
    haha.xixi()
  }
}