Scala学习笔记-1-类与对象

目录

• 基本概念
  • Hello Word
  • 与Java 不同的，Scala 的类定义可以有参数，称为类参数
  • require方法
• 附代码

基本概念

Hello Word

object HelloWord {
    def main(args: Array[String]) {
        println("Hello,word!");
    }
}

与Java 不同的，Scala 的类定义可以有参数，称为类参数

Scala中类定义的同时也定义了主构造函数，主构造函数只有这一个
其他的构造函数都称为辅助构造函数，辅助构造函数需要的第一个语句都需要调用其他的构造函数（并且最终要调用到主构造函数）

class Test(a: Int, b: Int) {
    def this() {
        this(null, null)
    }
}

require方法

Scala中有一个内置的require方法，常用作参数检查

class Test(i: Int) {
    require(i > 100)
}

附代码

package day02

/**
  * 自定义一个正整数的类
  * @param i 初始值
  */

// 与Java 不同的，Scala 的类定义可以有参数，称为类参数
// Scala 使用类参数，并把类定义和主构造函数合并在一起，在定义类的同时也定义了类的主构造函数
// 类参数只在类的内部可以访问，外部无法访问
class PositiveInteger(i: Int) extends SuperClass {

  var iii: Int = i

  // require方法：Prede f对象的定义的一个方法，Scala 环境自动载入这个类的定义，因此无需使用 import 引入这个对象
  // 常用于参数检查
  require(i > 0)

  def this(i1: Int, i2: Int) {
    // Scala中有只有一个主要构造函数，其他都是辅助构造函数
    // 所有 Scala 的辅助构造函数的第一个语句都为调用其它构造函数
    // 并且最终会调用到主构造函数才行
    this(i1 + i2)
  }

  // 复写的方法必须使用override修饰
  override def toString: String = i.toString

  // 复写父类的方法
  override def test(): Unit = {
    // 伴生对象和伴生类可以互相访问其私有成员
    println(PositiveInteger.desc concat "：" concat i.toString) // 如果一个方法只有一个参数，你可以不用括号和. 来调用这个方法
  }

  // 定义运算符
  def + (another: PositiveInteger): PositiveInteger = {
    new PositiveInteger(i + another.iii)
  }

  // 方法的重载
  def + (i2: Int): PositiveInteger = {
    new PositiveInteger(i + i2)
  }

  // 注意：自定义运算符的优先级与默认是一致的。比如：* / 的优先级高于 + -
  def * (another: PositiveInteger): PositiveInteger = {
    new PositiveInteger(i * another.iii)
  }
}

// 单例对象与类同名时，这个单例对象被称为这个类的伴生对象，而这个类被称为这个单例对象的伴生类
// 伴生类和伴生对象要在同一个源文件中定义，伴生对象和伴生类可以互相访问其私有成员
object PositiveInteger {

  // 私有成员变量和方法定义与Java类似
  private val desc: String = "我是一个正整数"

  /**
    * 为了找到相关的隐式参数与方法，scala会按如下优先级查找相关的隐式声明：
    * 1. 在当前函数调用的作用域及父作用域内；
    * 2. 在声明隐式参数类型的伴生作用域内；
    */
  // 该对象支持 pi + 2 的表达的，但是 2 + pi的表达式就会报错（因为Int类型不能与该类型对象相加，除非去修改Int的源码）
  // 我们可以通过 隐式类型转换 实现这一点，在执行加操作之前将Int隐式转换为PositiveInteger
  implicit def intToPositiveInteger(x: Int): PositiveInteger = new PositiveInteger(x)
  implicit def positiveIntegerToInt(pi: PositiveInteger): Int = pi.iii

  def main(args: Array[String]): Unit = {
    new PositiveInteger(1, 2).test()
    new PositiveInteger(1).test()

    println(new PositiveInteger(1) + 2)
    println(2 + new PositiveInteger(1))
  }
}

class SuperClass {

  def test(): Unit = {
    println("test")
  }
}