函数式编程

函数式编程

package chapter01

object test03 {
  def main(args:Array[String]):Unit={
    //函数式编程

    //函数的范式

    //面向对象，解决问题时，将问题拆解成一个一个小问题（形成对象），分别解决：继承，实现，重写，多态
    //函数式编程，问题的解决方案（封装功能），重点在于函数的入参，出参（返回值）

    //java中的方法和scala中的函数都可以进行功能的封装，但是方法必须和类型绑定，函数不需要
    // java 函数的声明：public static void test(String s){}

   //scala 声明函数
    def test(s:String):Unit={
      println(s)
    }
    //调用函数
    test("zhang")
  }

}

package chapter01

object test4 {

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

    //函数没有重载概念，同一个作用域中函数名不可以相同
    //scala中没有throw关键字，所以函数中如果有异常发送，不需要在函数申明时抛出异常


    //1.无参，无返回值
    def test():Unit={
      println("test")
    }
    test()

    //2.有参，无返回值
    def test2(s:String):Unit={
      println(s)
    }
    test2("test2")

    //3.有参，有返回值
    def test3(s:String):String={
      return s+"hello"
    }
    val result3=test3("test3")
    println(result3)

    //4.无参，有返回值
    def test4():String={
      return "hello"
    }
    val result4=test4()
    println(result4)

  }

}

package chapter01

object test05 {
  def main(args:Array[String]):Unit={
    //scala可以采用自动推断功能来简化函数的声明

    //如果函数声明中，明确无返回值Unit，那么即使函数体中有return也不起作用
    def test():Unit={
      return "hello"
    }
    println(test())//()

    //如果函数体的最后一行代码进行返回，那么return可以省略
    def test1():String={
      "hello"
    }
    println(test1())

    //如果可以根据函数的最后一行代码推断返回值类型，那么函数的返回值类型可以省略
    def test2()={
      "scala"
    }
    println(test2())

    //如果整个函数体当中只有一行代码，{}可以省略
    def test3()="zhang"
    println(test3())

    //如果函数声明中没有参数列表，()省略,调用时也不加（）；如果（）没有省略，调用时可加可不加（）
    //声明函数必须加def
    def test4="wang"
    println(test4)

    //函数声明没有返回值，=可以省略
    def test5(){
      "hello scala"
    }
    println(test5()) //()

    //匿名函数
    ()->{println("***********")}


  }

}

 

package chapter01

object test06 {
  def main(args:Array[String]):Unit={
    //可变参数
    def test(name:String*):Unit={
      println(name)
    }

    //调用时，可以传多个参数，也可以不传参数
    test("zhang shan","li si")  //WrappedArray(zhang shan, li si)
    test()// List()


    //默认参数
    def test2(name:String,age:Int=20):Unit={
      println(s"${name}-${age}")
    }

    test2("zhang shan")//zhang shan-20
    test2("zhang shan",30)//zhang shan-30

    //调用函数时，参数匹配规则为从前到后，从左到右
    def test3(name1:String,name2:String="li si"):Unit={
      println(s"${name1}-${name2}") //zhang shan-li si
    }

    test3("zhang shan")
    
    //带名参数
    test3(name1="zhang shan")
  }

}

 

package chapter01

object test07 {
  def main(args:Array[String]):Unit={
    //1.函数可以赋值给变量


    //1.函数可以作为函数的返回值

    def f():Unit={
      println("function")
    }

    def f0()={
      //返回函数
      //直接返回函数，有问题，增加特殊符号
      f _
    }
    f0()()

    //闭包
    //一个函数在实现逻辑时，将外部的变量引入到函数得内部，改变了这个变量得生命周期，称之为闭包
    def f1(i:Int)={
      def f2(j:Int):Int={
        i*j
      }
      f2 _
    }
    val result=f1(2)(3)
    println(result)


    //函数柯里化
    def f3(i:Int)(j:Int):Int={
      i*j
    }
    println(f3(2)(3))



    //2.函数可以作为函数的参数
    //参数列表=>返回值类型
    def f4(f :()=>Int):Int={
      f()+10

    }
    def f5():Int={
      9
    }
    println(f4(f5))
    

    def f9(f :(Int)=>Int):Int={
         f(10)
          }
    def f10(i:Int):Int={
         i
        }
    println(f9(f10))

    

    //使用匿名函数优化代码
    def f6(f:()=>Unit):Unit={
      f()
    }

    def f7():Unit={
      println("XXXXXXXXXX")
    }

    println(f6(f7))

    f6(()=>{println("XXXXXXXXX")})

    def f8(i:Int):Unit={
    println(i)
    }
    //()参数列表，{}逻辑代码
    f7((i:Int)=>{println(i}) 

    f7((i)=>{println(i）}） //Int类型可以省略

    f7((i)=> println(i) ）//只有一行代码，{}可以省略
    f7(println(_)//参数只用一次，参数可以写成_
    f7(println)//参数只用一次，参数可以省略

    def f8(F:(Int,Int)=>Int):Int={`- 自行车v不那么，。/\
\
     f(10,10)
       }

    f8((x:Int,y:Int)=>{x+y})
    f8((x,y)=>{x+y})  //Int类型可以省略
    f8((x,y)=>x+y) //只有一行代码，{}可以省略
    f8(_+_)//参数只用一次，可以省略

  }

}

 

package chapter01

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

    //递归
    //1.函数的逻辑代码调用自身
    //2. 函数在调用自身时，传递得参数应该有规律
    //3.函数应该有跳出递归的逻辑，否则出现死循环
    //4.递归函数无法推断函数返回值类型，所以必须有返回值类型


    def f(i:Int):Int={
      if(i==1){
        return 1
      }else{
        i*f(i-1)
      }

    }

    print(f(4))

  }

}