以下是在教材上看到的一种名为寄生组合的继承方式

//返回一个以o为原型的对象
function object(o){
    function F(){}
    F.prototype = o;
    return new F();
}

function inheritPrototype(SubType, SuperType){
    //创建一个以SuperType的原型为原型的对象
    let prototype = object(SuperType.prototype);
    console.log(prototype);
    //用该对象取代SubType原有的原型
    prototype.constructor = SubType;
    SubType.prototype = prototype;
}

//测试
//定义父类
function SuperType(name){
    this.name = name;
    this.colors = ["red", "blue"];
}
SuperType.prototype.sayName = function(){
    console.log(this.name);
}
//定义子类
function SubType(name, age){
    SuperType.call(this, name);
	this.age = age;
}
//修改子类原型
inheritPrototype(SubType, SuperType);
//添加子类原型方法
SubType.prototype.sayAge = function(){
    console.log(this.age);
}

let instance = new SubType("Jack", 18);
console.log(instance.prototype);
console.log(instance.__proto__);
instance.sayName();

想问一下对于开头的object（o）方法，为什么不可以使用如下方式定义呢？返回的也是一个以o为原型的对象。

function object(o){
     let obj = new Object();
     obj.prototype = o;
     return obj;
}

我自己调试的结果是，如果按照教材方式，在object()函数中通过F()构造函数新建实例，那么通过new SubType()创建的对象instance的原型，就和老师说的一样，必须用__proto__才可访问，对父类型SuperType的方法可以正常继承。
但如果在object()函数中是直接用Object创建，那么通过new SubType()创建的对象instance的原型，是可以直接用prototype显式访问到的，且就是SuperType。但是父类型SuperType的方法sayName并没有被继承，instance.sayName()会报错sayName不是一个函数。为什么会有这种差别呢？