scala学习笔记(七):单例对象、伴生对象、内部类

直接上代码说明:

object ClassScala {
  def main(args: Array[String]): Unit = {
    val obj = new University("a",1,1)
    println(obj)

    val stu = new Student("baby","女")

    /**
      * Array的apply方式创建对象
      * def apply(x: Int, xs: Int*): Array[Int] = {
          val array = new Array[Int](xs.length + 1)
          array(0) = x
          var i = 1
          for (x <- xs.iterator) { array(i) = x; i += 1 }
          array
        }
      */
    val arr =Array(1,2,3,4,5)
    //使用apply来创建对象
    val apply = ApplyScala("test")
    apply.info

    //内部类
    val outer1 = new OuterClass("outer1")
    val outer2 = new OuterClass("outer2")
    val inner1 = new outer1.InnerClass("inner1")//必须使用外部类的实例对象创建内部类
    val inner2 = new outer2.InnerClass("inner2")
    println(inner1)
    println(inner2)

    /**
      * 我inner2也是一个InnerClass对象 为什么编译出错?
      * 其实定义在内部类方法里面的InnerClass其实已经指定了只能传递当前outer1所创建的InnerClass
      * 所以传递outer2.InnerClass创建的对象是不行的
      */
    inner1.go(inner2)// Error:(46, 15) type mismatch;found   : outer2.InnerClass required: outer1.InnerClass inner1.go(inner2)
    inner1.go(inner1)// right
  }
}


/**
  * 伴生类
  * 默认构造函数
  * @param name 姓名
  * @param age 年龄
  * @param sex 性别
  */
class University (var name:String, var age:Int, var sex:Int){ //默认构造函数
  private val no = University.studentNo
  private var like:String =  _
  def this(name:String, age:Int, sex:Int, like:String) {//重载构造函数
    this(name, age, sex)
    this.like = like
  }

  def compareAge(other:University) = {
    this.age > other.age
  }

  override def toString: String = { //重写toString函数
     "["+this.no +"[["+this.name +"]["+this.age+"]["+this.sex+"]["+this.like+"]"
  }
}

/**
  * 伴生对象
  */
object University{ //
  private var no:Int = _
  def studentNo = {
    no += 1
    no
  }
}

/**
  * 在类名字后面加上private修饰表示不能用默认的构造函数去调用
  * 也就是 new Student("baby") 这种方式编译会报错
  * @param name
  */
class Student private(name:String){
  private var sex:String = _
  private[this] var age:Int = _
  def this(name:String, sex:String){
    this(name)
    this.sex = sex
  }
  def this(name:String, sex:String, age:Int){
    this(name, sex)
    this.age = age
  }

  def age_ = age

  /**
    * 我们设置age是私有的 为什么这里可以直接调用 而在我们new 出来的对象 为什么不能直接这样操作?
    * age设置private范围其实是类的内部能见
    * 如果要设置age只能在当前对象可见 我们只需要写成 private[this] var age
    * @param other
    * @return
    */
  def compareAge(other:Student) = {
    //this.age > other.age
    this.age > other.age_
  }
}

class ApplyScala(des: String) {
  def info = println("使用伴生对象的方法:"+ApplyScala.getNo +"---"+des)
}

object ApplyScala{

  private var no:Int = 0
  def getNo = {
    no += 1
    no
  }

  /**
    * 定义apply方法,实例化伴生类
    * @return
    */
  def apply(des: String): ApplyScala = {
    println("使用apply来实例化伴生类")
    new ApplyScala(des)
  }
}

/**
  * 内部类
  * @param name
  */
class OuterClass(val name:String){
  outer => class InnerClass(val name:String){
    /**
      * inner这个参数非常有特点 看调用
      * @param inner
      */
    def go(inner:InnerClass) = println(outer.name +"||" + inner.name)
    override def toString: String = {
      outer.name + " create " + this.name
    }
  }
}