Scala-隐式转换-私有函数-重载-构造器

最新推荐文章于 2021-07-09 23:36:58 发布

原创最新推荐文章于 2021-07-09 23:36:58 发布 · 647 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#Scala

Scala 专栏收录该内容

7 篇文章

订阅专栏

本文介绍Scala中的类构造过程，包括先决条件设置、函数与操作符重载、私有函数使用及隐式转换等核心概念，并通过Rational类实例进行详细解析。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

package com.zhu.scala

/**
  * Created by zhuhailong-dc on 2017/3/3.
  *
  * Scala编译器将把你放在类内部的任何不是字段的部分或者方法定义的代码,编译进主构造器中
  * 1.先决条件
  * 2.函数重载
  * 3.操作符重载
  * 4.私有函数
  * 5.隐式转换
  */

class Rational(n:Int,d:Int){
  //先决条件使用 require
  require(d!=0)
  require(n!=1)

  //在初始化Rational对象的时候执行
  //println("created "+n+"/"+d)

  //重载toString函数
  override def toString = n+"/"+d

  //添加字段
  val number:Int=n
  val denom:Int=d
  def add(that:Rational):Rational={
    println(n)
    println(d)
    new Rational(number*that.denom+that.number*denom,denom*that.denom)
  }

  def lessThan(that:Rational)=this.number*that.denom<that.number*this.denom
  def max(that:Rational)=if(this.lessThan(that)) that else this

  /**
    * 从构造器
    * Scala里的每一个从构造器的第一个动作都是调用同一个类里面其他的构造器.换句话说就是,每个Scala类里的每个从构造器都是以this(..)
    * 形式开头的.被调用的构造器即可以是主构造器,也可以是从文本上来看早于调用它的其他构造器.这个规则的根本结果就是每一个Scala
    * 的构造器调用终将结束于对类的主构造器的调用.因此主构造器是类的唯一入口点
    */

  def this(n:Int)=this(n,1)

  //私有字段和方法
  private def gcd(a:Int,b:Int):Int=if(b==0) a else gcd(b,a%b)
  private val g=gcd(n.abs,d.abs)

  //定义操作符
  def +(that:Rational):Rational=new Rational(number*that.denom+that.number*denom,denom*that.denom)
  def *(that:Rational):Rational=new Rational(number*that.number,denom*that.denom)

  //scala标识符

  //方法重载
  def +(i:Int):Rational=new Rational(number+i*denom,denom)

}

object Scala_4 {
  def main(args: Array[String]): Unit = {
    val rational=new Rational(2,2) //如果给0会提示 java.lang.IllegalArgumentException: requirement failed
    //println(rational.toString)

    val tmp1=new Rational(2,2)
    val tmp2=new Rational(2,3)
    val res1=tmp1 add tmp2
    val res2=tmp1.add(tmp2)
    val res3=tmp1 add(tmp2)

    //println(res1)
    //println(res2)
    //println(res3)

    val x=new Rational(2,2)
    val y=new Rational(2,3)
    //println(x+y)
    //println(x.+(y))
    //println(x+x*y)

    //隐式转换
    /**
      * 会抛出异常 2没有 * 方法
      * 这行代码定义了从Int到Rational的转换方法,方法前面的implicit修饰符告诉编译器若干情况下自动调用它
      */
    implicit def intToRational(x:Int)=new Rational(x)
    val r=new Rational(2,3)
    println(2*r)

  }
}