Scala的函数式对象

Posted 2021-02-12 lyr999736

本节主要是通过一个关于有理数的案例来说一些知识点。

包括几大方面：1.类的创建

　　　　　　　　　2.重载方法

　　　　　　　3.检查先决条件

　　　　　　　4.添加字段

　　　　　　　5.自指向

　　　　　　　6.辅助构造器

　　　　　　　7.私有字段和方法

　　　　　　　8.定义操作符

　　　　　　　9.隐士转换　　

先贴个代码哈！！！！！！

 

object Test{
  def main(args: Array[String]): Unit = {
    val a = new Rational(1,2)
    println(a)

    val b = new Rational(2,3)
    println(b)

    val c = a add b
    println(c)

    println(c.m)
    println(c.n)

    println(c.comp)

    val d = new Rational(4)
    println(d)

    val e = new Rational(66,42)
    println(e)

    val f = new Rational(2,3)
    val g = new Rational(3)
    val h = f + g
    println(h)

    val i = new Rational(2,3)
    val j = new Rational(3,4)
    println(i*j)

    val k = new Rational(2,3)
    val l = new Rational(3,4)
    val m = new Rational(4,5)
    println(k+l*m) //*的优先级比+高，所以先计算l*m，在计算+

    val n = new Rational(2,3)
    val o = new Rational(3)
    val p = n * o
    println(p)

    implicit def intToRational(i:Int):Rational = return new Rational(i)//隐士转换，将整形转换为Rational类型
    val q = new Rational(3,4)
    val r = 2
    println(r*q)

  }
}
//创建Rational类
class Rational(x: Int, y: Int){
  require(y!=0) // 检查先决条件

  def this(cnt:Int) = this(cnt,1) //辅助构造器，可以有多个，定义开始为def this(),
                                  // 被定义的构造器既可以是主构造器，也可以是其他构造器，因此主构造器才是类的唯一入口点

  private val g = gcd(x.abs,y.abs)

  var m = x/g //对外可见的，public，如果没有var或者val修饰词，则是对外不可见的，private
  var n = y/g

  def add(r:Rational):Rational = {
    return new Rational(m*r.n+r.m*n,n*r.n)
  }

  def + (r:Rational):Rational = {
    return new Rational(m*r.n+r.m*n,n*r.n)
  }

  def + (i:Int):Rational = {
    return new Rational(m+i*n,n)
  }

  def - (r:Rational):Rational = {
    return new Rational(m*r.n-r.m*n,n*r.n)
  }

  def - (i:Int):Rational = {
    return new Rational(m-i*n,n)
  }

  def * (r:Rational):Rational = {
    return new Rational(m*r.m,n*r.n)
  }

  def * (i:Int):Rational = {
    return new Rational(m*i,n)
  }

  def / (r:Rational):Rational = {
    return new Rational(m*r.n,n*r.m)
  }

  def / (i:Int):Rational = {
    return new Rational(m,n*i)
  }

  def comp:Int = {if(this.m>this.n) return 1 else 0} // this关键字是自指向，指向的是调用该方法的对象和java的一样

  override def toString = {
    if (n == 1) {
      m+""
    } else {
      m + "/" + n
    } //override修饰符是对原方法的冲载
  }

  //求两个数的最大公约数
  private def gcd(x:Int,y:Int):Int = {
    if(y==0)
      return x
    else{
      return gcd(y,x%y)
    }
  }
}

 

 知识点：

1.当我们重新实现某个函数的时候，比如toString方法，需要使用override关键字。

2.检查先决条件使用require(b:Boolean),参数是一个布尔型参数，当为真的时候继续执行，为假的时候将抛出IllegalArgumentException阻止对象被构造。

3.添加字段，首先确定该字段是否是对外可见，如果对外可见则必须带有val或者var修饰符，默认是public，如果不对外可见，则不需要写修饰符。

4.自指向指的就是this关键字，用法和java的一样，this指向的是调用该函数的对象。

5.有时候某个类可能会需要多个构造器，除了主构造器之外的都是辅助构造器，但是辅助构造器最终还会走到主构造器， 所以主构造器才是类的唯一入口，主构造器内的参数为类参数，类参数对外不可见，辅助构造器固定写法都是以def this(....)定义。

6.在类中也可以定义一些操作符，例如+，-，*，/等。在java或其他语言中，操作符就是一个运算符，但是在scala中，它们是函数。

7.方法重载的定义和java中一样，函数名一样，参数列表不一样，也就是方法签名不一样。

8.隐士转换，这个功能很是强大，但是能力越大，责任越大。我上面的代码都是使用类的对象去调用，但是当我们使用其他类型，例如整型，我们计算1+2/3时，是报错的，但我们使用隐士转换就会把1这个整数转换为我们定义的类型，这样就可以进行其他操作。隐士转换需使用关键字implicit。但是一定要确定好作用域，当超出使用的范围时，不会生效的。