scala--基础语法-方法-函数-★★★★★

于 2021-02-24 00:26:47 发布
阅读量145 收藏
点赞数
分类专栏： Scala 文章标签： scala
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46893497/article/details/114006092
版权

方法-函数

方法

def 方法名(参数名1:参数类型1,参数名2:参数类型2):返回值类型 = {方法体}

在这里插入图片描述

  • Scala之后的方法和Java中的方法一样,都可以用来将一些操作进行封装,
  • 如接收一些参数, 根据这些参数执行封装好的代码, 并将执行结果进行返回(如果有就返回)

入门案例

hanjiaxiaozhipackage cn.hanjiaxiaozhi.basic2

/**
* Author hanjiaxiaozhi
* Date 2020/7/13 15:17
* Desc
*/
object _01_MethodDemo {
 //main方法
 def main(args: Array[String]): Unit = {
   val res: Int = sum(1, 10)
   println(res) // 55
   val res2: Int = sum(1, 100)
   println(res2) // 5050
}

 //定义一个方法,完成从n~m的累加和
 //方法的定义格式:
 //def 方法名(参数名1:参数类型1,参数名2:参数类型2):返回值类型 = {方法体}
 def sum(n: Int, m: Int): Int = {
   var result: Int = 0
   for (i <- n to m) {
     result += i
  }
   result //for循环执行完,result中存的就是n~m的累加和,将result返回
}
}

方法定义的细节

  • 1.方法的返回值类型和return可以不写，编译器可以自动推断出来
  • 2.对于递归方法，必须指定返回类型
  • 3.如果方法没有返回值，返回Unit类型(类似于void，也可以不写)
  • 4.返回值类型有多种情况则返回Any
  • 5.带有默认值参数的方法，调用时，可以给定新值，也可以使用默认值
  • 6.可以通过参数名来指定传递给哪一个参数，这样传递参数时就可以不按照顺序传递
  • 7.方法没有参数，调用时可以省略()，如果定义时()省略，调用时则必须省略
  • 8.可变参使用 变量名:类型*（类似Java的…）
package cn.hanjiaxiaozhi.basic2

/**
 * Author hanjiaxiaozhi
 * Date 2020/7/13 15:17
 * Desc 演示方法定义的细节
 */
object _02_MethodDemo2 {
  //main方法
  def main(args: Array[String]): Unit = {
    method3("jack") //jack 默认的msg为sucess
    method3("jack", "hello") //jack hello
    method4(1, 10) //a=1, b=10
    method4(a = 1, b = 10) //a=1, b=10
    method4(b = 10, a = 1) //a=1, b=10
    method5() //方法参数,调用时可以有(),也可以省略
    method5
    //method6()//但是如果方法没有参数,定义的时候省略的(),那么调用的时候必须省略,不能加
    method6

    println(getSum(1,2)) //3
    println(getSum(1,2,3,4,5)) //15
  }

  //1.方法的返回值类型和return可以不写，编译器可以自动推断出来
  def add(x: Int, y: Int) = {
    x + y
  }

  //2.对于递归方法，必须指定返回类型,不可省略
  //使用递归求阶乘,如求10! = 10 * 9 * 8 * .... *2 * 1  = 10 * 9! = 10 * 9 * 8!.......
  def getFactorial(n: Int): Int = {
    if (n <= 0) {
      1
    } else {
      n * getFactorial(n - 1)
    }
  }

  //3.如果方法没有返回值，返回Unit类型(类似于void，也可以不写)
  def method1(msg: String): Unit = {
    println(msg)
  }

  //4.返回值类型有多种情况则返回Any,或者不写
  def method2(age: Int): Any = {
    if (age >= 18) {
      "ok"
    } else {
      0
    }
  }

  //5.带有默认值参数的方法，调用时，可以给定新值，也可以使用默认值 ---有点类似python语法
  def method3(name: String, msg: String = "默认的msg为sucess"): Unit = {
    println(name + " " + msg)
  }

  //6.可以通过参数名来指定传递给哪一个参数，这样传递参数时就可以不按照顺序传递
  def method4(a: Int, b: Int) = {
    println("a=" + a)
    println("b=" + b)
  }

  //7.方法没有参数，调用时可以省略()，如果定义时()省略，调用时则必须省略
  def method5() = {
    println("method5")
  }

  def method6 = {
    println("method6")
  }

  //8.可变参使用 变量名:类型* （类似Java的...表示可变参数） ---和python中的语法也类似
  def getSum(args: Int*) = { //Int*表示可以接收多个Int值,也就是可以组成一个Int数组
    var result = 0
    for (i <- args) {
      result += i
    }
    result
  }

}
  • 补充Java中的可变参数
package cn.hanjiaxiaozhi.basic2;

/**
 * Author hanjiaxiaozhi
 * Date 2020/7/13 15:46
 * Desc 演示Java可变参
 */
public class VaribaleDemo {
    public static void main(String[] args) {
        System.out.println(getSum(1));//1
        System.out.println(getSum(1, 2));//3
        System.out.println(getSum(1,2,3,4,5));//15
    }
    public static int getSum(int... args){//int...args表示可以传递多个int值,给args组成一个int数组
        int result = 0;
        for (int i : args) {
            result += i;
        }
        return result;
    }

}

函数–难点

语法：

  • 完整语法:

    • val 函数名称 :(参数类型)=>函数返回值类型 = (参数名称:参数类型)=>函数体

  • 简写语法:

    • val函数名称 = (参数名称:参数类型) => 函数体

  • 符号解释

    • = 表示将右边的函数赋给左边的变量
    • => 左面表示输入参数名称和类型，右边表示函数的实现和返回值类型

与方法的区别

  • Scala中的函数和方法类似,也是可以接收一些参数,进行一些操作,再返回
  • 但是和方法不同的是,
    • 方法隶属于对象/类和Java中的方法一样去理解即可
    • Scala中的函数和Java8中新推出的函数式编程Lambda表达式一样,本质是对象，有apply、curried、toString、tupled等方法
    • Scala中函数继承自FuctionN，带有一个参数的函数的类型是function1，带有两个是function2，以此类推
    • 也就是说 方法隶属于对象/类, 而函数本身就是对象!!!

证明函数是对象

  • 调用方法
  • 赋值给变量
  • 作为参数进行传递

方法可以转换为函数

  • 在方法后面加一个下划线

Java8中的函数

package cn.hanjiaxiaozhi.basic3;

/**
 * Author hanjiaxiaozhi
 * Date 2020/7/13 16:10
 * Desc 演示Java8中的函数
 */
public class FunctionDemo_Java {
    public static void main(String[] args) {
        //Java8中的匿名内部类实现一个Runnable线程任务对象
        new Thread(
                new Runnable() {
                @Override
                public void run() {
                    System.out.println("Runnable线程任务对象执行了");
                }
            }
        ).start();

        //上面的写法是Java8之前的写法
        //接下来使用Java8的写法,也就是使用函数式编程-Lambda表达式,格式为: (参数)->{函数体}
        new Thread(
                ()->{
                    System.out.println("Runnable线程任务对象执行了--java8");
                }
        ).start();

        //还可以接着简写:
        new Thread(()->System.out.println("Runnable线程任务对象执行了--java8")).start();

        //为什么可以直接传入一个Lambda表达式给Thread(Runnable target)
        //通过查看源码我们发现Thread(Runnable target)参数中要的是一个Runnable接口类型的对象
        //而我们传入的是一个函数,也就是lambda ()->System.out.println("Runnable线程任务对象执行了--java8")
        //那么就意味着我们传入的东西/函数 其实本质就是 Runnable接口类型的对象!
        //也就是说Java8中的函数的本质是对象,准确的说是接口的匿名内部类实现对象
    }
}

Scala中的函数-入门案例

  • 本质
    • Scala中的函数的本质就是对象
  • 定义格式
  • 1.完整语法
    • val 函数名 :(参数类型)=>返回值类型 = (参数名称:参数类型)=>{函数体}
  • 2.简写语法
    • val 函数名 = (参数名称:参数类型)=>{函数体}
  • 进一步简写
    • val 函数名 = (参数名称)=>函数体
  • 代码演示
package cn.hanjiaxiaozhi.basic3

/**
 * Author hanjiaxiaozhi
 * Date 2020/7/13 16:24
 * Desc 演示Scala中的函数
 */
object FunctionDemo_Scala {
  def main(args: Array[String]): Unit = {
     //定义一个函数实现两个Int数的相加
    //1.完整语法
    //val 函数名 :(参数类型)=>返回值类型 = (参数名称:参数类型)=>{函数体}
    val add1:(Int,Int)=>Int = (a:Int,b:Int) => {a + b}

    //2.简写语法
    //val 函数名 = (参数名称:参数类型)=>{函数体}
    val add2 = (a:Int,b:Int) => {a + b}

    //调用测试一下
    val result1: Int = add1(1,2) 
    println(result1)//3

    val result2: Int = add2(1,2)
    println(result2)//3

  }
}

Scala中的函数-证明Scala中的函数的本质是对象!

  • 根据我们之前学习的编程语言,如果一个东西是对象的话,那么应该有如下的特征:
    • 1.可以调用方法
    • 2.可以作为值赋值给变量接收
    • 3.可以当作参数被传递给方法
  • 那么如果能演示出上面的三点不就证明了函数是对象嘛!!!
package cn.hanjiaxiaozhi.basic3

/**
 * Author hanjiaxiaozhi
 * Date 2020/7/13 16:24
 * Desc 演示证明Scala中的函数的本质是对象
 * 1.完整语法
 * val 函数名 :(参数类型)=>返回值类型 = (参数名称:参数类型)=>{函数体}
 * 2.简写语法
 * val 函数名 = (参数名称:参数类型)=>{函数体}
 */
object FunctionDemo2_Scala {
  def main(args: Array[String]): Unit = {
    //根据我们之前学习的编程语言,如果一个东西是对象的话吗,那么应该有如下的特征:
    //1.可以调用方法
    //2.可以作为值赋值给变量接收
    //3.可以当作参数被传递给方法
    //那么如果能演示出上面的三点不就证明了函数是对象嘛!!!

    //定义一些函数
    val f1 = (x: Int) => x
    val f2 = (x: Int, y: Int) => x + y
    //证明1.函数可以调用方法--推出-->函数是对象
    println(f1)//<function1>//直接打印函数,如果是对象的话,根据以前的经验,应该会调用对象的toString方法
    println(f2)//<function2>
    println(f1.toString())//<function1>//函数确实可以调用toString方法,那么如果和上面的打印结果一样,那么不就证明了我们的观点么!
    println(f2.toString())//<function2>

    //证明2.函数可以作为值赋值给变量接收--推出-->函数是对象
    val f3 = f2 //f2是上面定义好的函数,现在赋值给fun变量了, 那么fun变量也成了函数
    println(f3)//<function2>

    //证明3.函数可以当作参数被传递给方法--推出-->函数是对象
    val f4 = (x: Int, y: Int) => x + y
    val result: Int = myMethod(1,2,f4) //f4是一个函数,现在被当作参数传递给了myMethod方法的fun参数了
    println(result)//3
    val result2: Int = f4(1,2)
    println(result2)//3

  }
  //定义一个方法,该方法接收2个int值,和1个函数,并在方法体中调用该函数,将2个int值传个该函数
  def myMethod(a:Int,b:Int,fun:(Int, Int) => Int):Int ={
    fun(a,b)//在方法体中调用函数,并将函数的计算结果作为myMethod方法的返回值
  }

}
  • 在Scala中,方法可以转变为函数!
package cn.hanjiaxiaozhi.basic3

/**
 * Author hanjiaxiaozhi
 * Date 2020/7/14 9:37
 * Desc 演示Scala中的方法可以转变为函数
 */
object FunctionDemo3_Scala {
  def main(args: Array[String]): Unit = {
    //定义一个函数
    val fun = (x:Int,y:Int)=> x+y
    //调用函数对象的toString
    println(fun.toString())

    //将方法转为函数并调用函数的toString
    val fun_sum = sum _ //方法名 _ 表示将隶属于对象/类的方法直接转为一个函数对象
    println(fun_sum.toString())

  }
  //定义一个方法
  def sum(a:Int,b:Int):Int={
    a+b
  }
}

总结

1.Scala中的方法和函数的定义

  • ●定义方法:
    • def 方法名(参数名1: 参数类型1, 参数名2: 参数类型2) : 返回类型 = {方法体}
  • ●定义函数完整语法:
    • val函数名称 :(参数类型)=>函数返回值类型 = (参数名称:参数类型)=>函数体
  • ●定义函数简写语法:
    • val函数名名称 = (参数名称:参数类型) => 函数体

2.Scala中的方法和函数

  • 1.方法隶属于对象/类

  • 2.函数本身就是对象

  • 3.方法可以转为函数

韩家小志
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值