【Scala】伴生对象与原始对象的关系

今天遇到一个问题，如果我现在想重写一个Object内部的一部分方法从而获得一个新的Object，我该怎么做
最开始的想法是，我可不可以直接继承一个Object，结果发现不行，因为伴生对象是一个对象而不是一个类，因此伴生对象不能被继承
在这里把原始类生成的对象成为原始对象，比如val c=new C()，这个c就是一个原始对象

class C {
  val i = 1
  private val k=2
}

object C {
  val j = 2
  def f():Unit={
    println("func")
  }
  def main(args: Array[String]): Unit = {
    println(C,this)
    println(C==this)
//    (C$@57829d67,C$@57829d67)
//    true
    C.f()
    this.f()
    //    do the same thing
    //    由此可以看出，this和C都指向的是一个对象
  }
}

在scala里，如果类C拥有伴生对象，那么C指的是这个伴生对象，如上面代码所示；如果类C没有伴生对象，那么C就是一个未定义的变量，无法被访问，如下所示

class A1{
 }
object B1{
  def main(args: Array[String]): Unit = {
//    A1
//    A1是一个不合法字段，无法被访问
  }
}

而java不同的是，如果我们在java里定义了一个类Class C，那么C指的是一个类，如下所示

class C{
    static void show(){
        System.out.println(1);
    }
    public static void main(String[] args){
        Class c = C.class;
        C.show();
    }
}

并且，伴生对象与原始对象是两个独立的对象，只不过伴生对象之中可以访问原始对象中的所有成员，而原始对象无法访问伴生对象中的任何成员，如下

class C {
  val i = 1
  private val k=2
}

object C {
  val j = 2
  def f():Unit={
    println("func")
  }
  def main(args: Array[String]): Unit = {
    //    C.i
    //    this.i
    //    C和this都无法访问变量i

    val c = new C()
    print(c.i,c.k)
    //    在伴生对象中构建原始类的对象，可以访问该对象中的私有成员
    //    c.j
    //    但这个对象无法访问伴生对象中的成员
  }
}

最后回到刚刚我的需求，如果我现在想重写一个Object内部的一部分方法从而获得一个新的Object，我该怎么做，查了半天也没查到别人怎么做，这里我给出两种方法

object O1 {
  def f1(): Unit = {
    println("O1 f1")
  }
  def f2(): Unit = {
    println("O1 f2")
  }
}

class C1 {
  def f1(): Unit = {
    O1.f1()
  }
  def f2(): Unit = {
    O1.f2()
  }
}

object O2 extends C1{

  override def f1(): Unit = {
    print("O2 f1")
  }

  def main(args: Array[String]): Unit = {
    O2.f1()
    O2.f2()
  }
}

第二种方法是运用隐式转换

object O1 {
  def f1(): Unit = {
    println("O1 f1")
  }

  def f2(): Unit = {
    println("O1 f2")
  }
}


object O2 {
  implicit def toO1(o2: O2.type): O1.type = O1

  def f1(): Unit = {
    println("O2 f1")
  }

  def main(args: Array[String]): Unit = {
    O2.f1()
    O2.f2()
  }
}