Scala学习（函数式编程面向对象编程）

Posted 2022-11-25 数据攻城小狮子

文章目录

• 函数式编程
• • 基础函数编程
  • • 函数定义
    • 函数参数
    • 函数至简原则
  • 高阶函数编程
• 面向对象编程
• • 基础面向对象编程
  • 高阶面向对象编程

函数式编程

基础函数编程

函数定义

package learn03
object demo01 
  def main(args: Array[String]): Unit = 
    //无参、无返回值
    def fun1(): Unit = 
      println("函数体")
    
    fun1()

    //无参、有返回值
    def fun2(): String = 
      "xwk"
    
    println(fun2())

    //有参、无返回值
    def fun3(name: String): Unit = 
      println(name)
    
    fun3("xwk")

    //有参、有返回值
    def fun4(name: String): String = 
      "Hello " + name
    
    println(fun4("xwk"))

    //多参、无返回值
    def fun5(hello: String, name: String): Unit = 
      println(hello + " " + name)
    
    fun5("Hello", "xwk")

    //多参、有返回值
    def fun6(hello: String, name: String): String = 
      hello + " " + name
    
    println(fun6("Hello", "xwk"))
  

函数参数

package learn03
object demo02 
  def main(args: Array[String]): Unit = 
    //可变参数
    def fun7(names: String*): Unit = 
      println(names)
    
    fun7()
    fun7("xwk")
    fun7("xwk", "zxy")

    //可变参数不能放置在参数列表的前面，一般放置在参数列表的最后
    //def fun77(names:String*,name:String):Unit=,这是错误的写法
    def fun77(name: String, names: String*): Unit = 
      println(name)
      println(names)
    

    //参数默认值
    def fun8(name: String, password: String = "000000"): Unit = 
      println(name + "," + password)
    
    fun8("xwk", "123456")
    fun8("xwk")

    //带名参数
    def fun9(password: String = "000000", name: String): Unit = 
      println(name + "," + password)
    
    fun9("123456", "xwk")
    fun9(name = "xwk")
  

函数至简原则

package learn03
object demo03 
  def main(args: Array[String]): Unit = 
    //省略return关键字
    def fun1(): String = 
      return "省略return关键字前"
    
    def fun11(): String = 
      "省略return关键字"
    
    println(fun1())
    println(fun11())

    //省略花括号
    def fun2(): String = "省略花括号"
    println(fun2())

    //省略返回值类型
    def fun3() = "省略返回值类型"
    println(fun3())

    //省略参数列表
    def fun4 = "省略参数列表"
    println(fun4) //正确
    //fun4()错误

    //省略等号
    //如果函数体中有明确的return语句，那么返回值类型不能省略
    def fun5_1(): String = 
      return "省略等号1"
    
    println(fun5_1())

    //如果函数体返回值类型明确为Unit, 那么函数体中即使有return关键字也不起作用
    def fun5_2(): Unit = 
      return "省略等号2"
    
    println(fun5_2())

    //如果函数体返回值类型声明为Unit, 但是又想省略，那么此时就必须连同等号一起省略
    def fun5_3()
      return "省略等号3"
    
    println(fun5_3())

    //省略名称和关键字
    () => 
      println("省略名称和关键字")
    
  

高阶函数编程

所谓的高阶函数，其实就是将函数当成一个类型来使用，而不是当成特定的语法结构。

package learn03

object demo04 
  def main(args: Array[String]): Unit = 
    //函数作为值
    def fun1(): String = 
      "xwk"
    

    val a = fun1
    val b = fun1 _
    val c: () => Unit = fun1
    println(a)
    println(b)

    //函数作为参数
    def fun2(i: Int): Int = 
      i * 2
    

    def fun22(f: Int => Int): Int = 
      f(10)
    
    println(fun22(fun2))

    //函数作为返回值
    def fun3(i: Int): Int = 
      i * 2
    

    def fun33() = 
      fun3 _
    
    println(fun33()(10))

    //匿名函数
    def fun4(f: Int => Int): Int = 
      f(10)
    

    println(fun4((x: Int) => 
      x * 20
    ))
    println(fun4((x) => 
      x * 20
    ))
    println(fun4((x) => x * 20))
    println(fun4(x => x * 20))
    println(fun4(_ * 20))

    //控制抽象
    def fun7(op: => Unit) = 
      op
    

    fun7 
      println("xx")
    

    //闭包
    def fun5() = 
      val i = 20

      def fun55() = 
        i * 2
      
      fun55 _
    
    fun5()()

    //函数柯里化
    def fun6(i: Int)(j: Int) = 
      i * j
    

    //递归函数
    def fun8(j: Int): Int = 
      if (j <= 1) 
        1
       else 
        j * fun8(j - 1)
      
    
    println(fun8(5))

    //惰性函数
    def fun9(): String = 
      println("function......")
      "xwk"
    
    lazy val x = fun9()
    println("........")
    println(x)
  

面向对象编程

基础面向对象编程

包

package关键字可以嵌套声明使用

package learn03
package p1 
  package p2 
    package p3 
      object demo01 
        def main(args: Array[String]): Unit = 
          println("test...")
        
      
    
  

同一个源码文件中子包可以直接访问父包中的内容，而无需import
Scala中package也可以看作对象，并声明属性和函数

导入

scala中基本的import导入语法和java完全一致
java中import导入的语法比较单一，scala对此进行扩展

package learn03
object demo05
  def main(args: Array[String]): Unit = 
    //scala中的import语法可以在任意位置使用
    import java.util.ArrayList
    new ArrayList()
    //scala中可以导包，而不是岛类
    import java.util
    new util.ArrayList()
    //scala可以在同一行中导入相同包中的多个类，简化代码
    import java.util.List,ArrayList
    //屏蔽某个包中的类
    import java.util._
    import java.sql.Date=>_,Array=>_,_
    //给类起别名
    import java.util.ArrayList=>AList
    new AList()
    //可以使用类的绝对路径而不是相对路径
    import _root_.java.util.ArrayList
    //默认情况下,scala中会导入如下包和对象
    import java.lang._
    import scala._
    import scala.Predef._
  

类

class User
      //类的主体内容
    
    //对象 : new 类名(参数列表) 
    new User()

scala中的一个源文件中可以声明多个公共类

属性

package learn03
object demo06 
  def main(args: Array[String]): Unit = 
    class User 
      var name : String = _ // 类属性其实就是类变量
      var age : Int = _ // 下划线表示类的属性默认初始化
    
  

访问权限

private : 私有访问权限
private[包名]: 包访问权限
protected : 受保护权限，不能同包
            : 公共访问权限（默认）

方法

Scala中的类的方法其实就是函数，所以声明方式完全一样，但是必须通过使用对象进行调用

package learn03
object demo07 
  def main(args: Array[String]): Unit = 
    val user=new User
    user.login("xwk","000000")
  

class User
  def login(name:String,password:String):Boolean=
    false
  

对象

val | var 对象名 [:类型]  = new 类型()
var user : User = new User()

构造方法

package learn03
class User()  // 主构造函数
  var username : String = _
  def this( name:String )  // 辅助构造函数，使用this关键字声明
    this() // 辅助构造函数应该直接或间接调用主构造函数
    username = name
  
  def this( name:String, password:String ) 
    this(name) // 构造器调用其他另外的构造器，要求被调用构造器必须提前声明
  

高阶面向对象编程

继承

package learn03
class Person 

package learn03
class User extends Person

抽象

Scala将一个不完整的类称之为抽象类

abstract class Person

Scala中如果一个方法只有声明而没有实现，那么是抽象方法，因为它不完整。

abstract class Person
  def test():Unit

Scala中如果一个属性只有声明没有初始化，那么是抽象属性，因为它不完整。

abstract class Person
  var name:String

子类如果继承抽象类，必须实现抽象方法或补全抽象属性，否则也必须声明为抽象的，因为依然不完整。

class User extends Person
  var name:String="xwk"

abstract class Person
  var name:String

单例对象

 所谓的单例对象，就是在程序运行过程中，指定类的对象只能创建一个，而不能创建多个。这样的对象可以由特殊的设计方式获得，也可以由语言本身设计得到，比如object伴生对象
 Scala语言是完全面向对象的语言，所以并没有静态的操作（即在Scala中没有静态的概念）。但是为了能够和Java语言交互（因为Java中有静态概念），就产生了一种特殊的对象来模拟类对象，该对象为单例对象。若单例对象名与类名一致，则称该单例对象这个类的伴生对象，这个类的所有“静态”内容都可以放置在它的伴生对象中声明，然后通过伴生对象名称直接调用
 如果类名和伴生对象名称保持一致，那么这个类称之为伴生类。Scala编译器可以通过伴生对象的apply方法创建伴生类对象。apply方法可以重载，并传递参数，且可由Scala编译器自动识别。所以在使用时，其实是可以省略的。

class User  // 伴生类

object User  // 伴生对象
    def apply() = new User() // 构造伴生类对象

...
val user1 = new User()// 通过构造方法创建对象
Val user2 = User.apply() // 通过伴生对象的apply方法构造伴生类对象 
val user3 = User() // scala编译器省略apply方法，自动完成调用