Scala中基础的函数编程

写在前面

• 操作系统：Windows10
• JDK版本：jdk1.8
• Maven版本：Maven-3.5.4
• Scala版本：Scala-2.12.11
• IDE工具：IntelliJ IDEA 2019.2.3

我们知道Java是面向对象编程，所以解决问题都是按照面向对象的方式来处理的。比如用户登陆等业务功能，但是Scala编程语言将函数式编程和面向对象编程完美地融合在一起了。

• 面向对象编程

分解对象，行为，属性，然后通过对象的关系以及行为的调用来解决问题

• 函数式编程

将问题分解成一个一个的步骤，将每个步骤进行封装（函数），通过调用这些封装好的功能按照指定的步骤，解决问题。

基础函数编程

基本语法

[修饰符] def 函数名 ( 参数列表 ) [:返回值类型] = {

函数体

}

private def test(str : String) : Unit = {
  println(str)
}

函数VS方法

• Scala 中存在方法与函数两个不同的概念，二者在语义上的区别很小。Scala 方法是类的一部分，而函数是一个对象，可以赋值给一个变量。换句话来说在类中定义的函数即是方法。Scala 中的方法跟 Java 的类似，方法是组成类的一部分。Scala 中的函数则是一个完整的对象。

• Scala中的方法和函数从语法概念上来讲，一般不好区分，所以简单的理解就是：方法也是函数。

  • 只不过类中声明的函数称之为方法，其他场合声明的就是函数了。
  • 类中的方法是有重载和重写的。而函数可就没有重载和重写的概念了，但是函数可以嵌套声明使用，方法就没有这个能力了。

函数的定义

• 无参函数，无返回值

object ScalaFunction {
    def main(args: Array[String]): Unit = {
        def fun1(): Unit = {
            println("函数体")
        }
        fun1()
    }
}

• 无参函数，有返回值

object ScalaFunction {
    def main(args: Array[String]): Unit = {
        def fun2(): String = {
            "whybigdata"
        }
        println(fun2())
    }
}

• 有参函数，无返回值

object ScalaFunction {
    def main(args: Array[String]): Unit = {
        def fun3(name:String): Unit = {
            println( name )
        }
        fun3("whybigdata")
    }
}

• 有参函数，有返回值

object ScalaFunction {
    def main(args: Array[String]): Unit = {
        def fun4(name:String): String = {
            "Hello" + name
        }
        println( fun4("whybigdata") )
    }
}

• 多参函数，无返回值

object ScalaFunction {
    def main(args: Array[String]): Unit = {
        def fun5(hello:String, name:String): Unit = {
            println( hello + " " + name )
        }
        fun5("Hello", "whybigdata")
    }
}

• 多参函数，有返回值

object ScalaFunction {
    def main(args: Array[String]): Unit = {
        def fun6(hello:String, name:String): String = {
            hello + " " + name
        }
        println( fun6("Hello", "whybigdata"))
    }
}

函数参数

• 可变参数

object ScalaFunction {
    def main(args: Array[String]): Unit = {
        def fun7(names:String*): Unit = {
            println(names)
        }
        fun7()
        fun7( "whybigdata" )
        fun7( "whybigdata", "zhangsan" )
    }
}

可变参数不能放置在参数列表的前面，一般放置在参数列表的最后。举例如下：

oobject ScalaFunction {
    def main(args: Array[String]): Unit = {
        // Error
        //def fun77(names:String*, name:String): Unit = {
        
        //}
        def fun777(name:String, names:String*): Unit = {
            println(name)
            println(names)
        }
    }
}

• 参数默认值

object ScalaFunction {
    def main(args: Array[String]): Unit = {
        def fun8( name:String, password:String = "000000" ): Unit = {
            println( name + "," + password )
        }
        fun8("whybigdata", "123123")
        fun8("whybigdata")
    }
}

• 带名参数

object ScalaFunction {
    def main(args: Array[String]): Unit = {
        def fun9( password:String = "000000", name:String ): Unit = {
            println( name + "," + password )
        }
        fun9("123123", "whybigdata" )
        fun9(name="whybigdata")
    }
}

函数至简原则

所谓的至简原则，其实就是Scala的作者为了开发人员能够大幅度提高开发效率。通过编译器的动态判定功能，帮助我们将函数声明中能简化的地方全部都进行了简化。也就是说将函数声明中那些能省的地方全部都省掉。所以这里的至简原则，简单来说就是：能省则省。

• 省略return关键字

object ScalaFunction {
    def main(args: Array[String]): Unit = {
        def fun1(): String = {
            return "whybigdata"
        }
        def fun11(): String = {
            "whybigdata"
        }
    }
}

• 省略花括号

object ScalaFunction {
    def main(args: Array[String]): Unit = {
        def fun2(): String = "whybigdata"
    }
}

• 省略返回值类型

object ScalaFunction {
    def main(args: Array[String]): Unit = {
        def fun3() = "whybigdata"
    }
}

• 省略参数列表

object ScalaFunction {
    def main(args: Array[String]): Unit = {
        def fun4 = "whybigdata"
        fun4// OK
        fun4()//(ERROR)
    }
}

• 省略等号

如果函数体中有明确的return语句，那么返回值类型不能省略

object ScalaFunction {
    def main(args: Array[String]): Unit = {
        def fun5(): String = {
            return "whybigdata"
        }
        println(fun5())
    }
}

如果函数体返回值类型明确为Unit, 那么函数体中即使有return关键字也不起作用

object ScalaFunction {
    def main(args: Array[String]): Unit = {
        def fun5(): Unit = {
            return "whybigdata"
        }
        println(fun5())
    }
}

如果函数体返回值类型声明为Unit, 但是又想省略，那么此时就必须连同等号一起省略

object ScalaFunction {
    def main(args: Array[String]): Unit = {
        def fun5() {
            return "whybigdata"
        }
        println(fun5())
    }
}

• 省略名称和关键字

object ScalaFunction {
    def main(args: Array[String]): Unit = {
        () => {
            println("whybigdata")
        }
    }
}

全文结束！