伴生对象

一个class和object具有同样的名字。这个object称为伴生对象，这个class称为伴生类

伴生对象必须要和伴生类一样的名字；
伴生对象和伴生类在同一个scala源文件中；
伴生对象和伴生类可以互相访问private属性。

作用：让伴生类更好访问到伴生对象的私有属性和方法

一旦私有 main方法直接不能调严格的权限控制

1.单例对象(object)

scala中是没有static关键字的，要想定义类似于Java中的static变量、static方法，就要使用到scala中的单例对象了, 也就是object。

2.定义单例对象

object 单例对象名{ } // 定义一个单例对象也可以解释为什么main方法是静态的了

网上说的什么伴生对像之间可以互相访问跟情侣一样同生死只有伴生类能够访问伴生对象中的私有属性和对象我尝试了一下明明只有类可以访问到对象访问不到类的东西。

但后来慢慢发现我放了一个错误

伴生对象不实例化类的对象，怎么访问伴生类中定义的私有属性？不实例化伴生对象是类的一个傀儡

就是必须要在伴生对象的中定义个方法去实例化它

举例：

class Person{

}

var op ：person = new Person（）实例化后才能调用

但我们一般都是在main方法中实例化的（java的思维）真的sorry

3.案例1 2 3

ps：可以试着运行下

可以尝试着把伴生对象理解成用static 修饰的类

package com.atiguigu.prc

/**
 * @author lyc
 * @date 2022/4/10 20:50  
 * @version V1.0.0
 */
object Logger {
   //单例对象 不能带参数 不能实例化 没有机会向单例对象传参
  //在第一次调用的时候进行 初始化
  //静态方法 一加上private就没办法访问了
    def log(msg:String)={
    println(s"info:$msg")
  }
}

class Test{
  def method(): Unit ={
    Logger.log("林杰");
  }
}


//为什么要有 object定义main方法 因为static 被scala完全给隔绝了
//scala是高度化的面向对象语言 不允许静态和非静态属性和方法 糅杂在一起 所以就用一个
//object 单例对象


//程序入口
object LoggerTest{
  def main(args: Array[String]): Unit = {
    Logger.log("林杰1") //类名.方法名

    val obj :Test = new Test()
    obj.method()
  }
}

package com.atiguigu.prc

/**
 * @author lyc
 * @date 2022/4/10 20:56  
 * @version V1.0.0
 */
class AccountInfo {
  var id =0
  id = AccountInfo.newUniqueNumber()

}

//之间的特点 互相访问对方的私有属性和方法
//称为类的伴生对象

object AccountInfo{
  private var last_num =0
  private  def newUniqueNumber()={
    last_num +=2
    last_num
  }

}
object  compannionTest{
  def main(args: Array[String]): Unit = {
    var obj :AccountInfo = new AccountInfo()
    println(obj.id)
  }
}

package com.atiguigu.prc

/**
 * @author lyc
 * @date 2022/4/10 21:15  
 * @version V1.0.0
 */


//类自带无参的构造器 开发者把这些觉得重复的东西全部省略了
//set get 底层封装起来了
// 有参构造函数 直接 给class（）java中是不允许的！！
//scala中的构造器 有两种
// 主构造函数 和 辅助构造函数
// 记住一点 辅助构造函数是在 类中的  定义必须以this开头 以下是具体例子
// 调用辅助构造函数 根据传参来区分是第几个辅助构造函数

object Constructorc {
  def main(args: Array[String]): Unit = {
    val obj :Const = new Const(20)
    var obj1 :Confuse = new Confuse(100)
    println(obj.a)
  }
}



class Const{
  var a = 10
  println("1调用无参的构造函数")
  println(a)

  def this(a1:Int){
    this() //调用主构造函数 必须的一步！！！
    println("2调用有参的构造函数")
    this.a = a1
  }
}

//有参的构造函数
//如果用 var就是放在类里面的一个属性 不带则为参数 注意一下
//class Confuse{
// int a

class Confuse(a :Int){
}