const obj = {}
// 优点：创建简单方便
// 弊端：创建多个对象麻烦、安全隐患（不利于属性值的验证）

function createStudentObj(name,cls){
    return {
        name,
        cls,
        study(){
            console.log(`我是${this.name},我能够快乐的学习`);
        } 
    }
}
const zs=createStudentObj('zs',18)
const lisi=createStudentObj('lisi',18)
const wangwu=createStudentObj('wangwu',18)
// 优点：创建多个对象方便
// 缺点：
//问题1:使用工厂模式创建的对象 类型一致 都是Object类型
console.log(zs,lisi,wangwu);
//问题2:相同的逻辑代码（函数）被保存到了不同的内存空间中 导致内存空间的一个浪费
zs.study=123

//构造函数：就是js中的类，本质上就是一个函数 只不过这个函数被new关键字调用了 
function Test(){
    console.log(123);
}
new Test
//构造函数的特点： 首字母大写的  被new关键字调用的
//使用构造函数创建对象
function Student(name,age){
    // this 代表的就是构造函数返回的对象
    this.name=name
    this.age=age
    this.study=function(){
        console.log(`我是${this.name},我能够快乐的学习`);
    }
}
const maliu=new Student('马六',18)
const tianqi=new Student('田七',18)
console.log(maliu,tianqi);//打印的结果是Student类型的对象
// 优点：创建多个对象方便
// 缺点：每个对象都有相同的数据，浪费内存。

function Person(name, age){
  this.name = name
  this.age = age
}
Person.prototype.setName = function(name){
  this.name = name
}
var p1 = new Person('Tom',18)
// 适用场景: 需要创建多个类型确定的对象。
// 优点：每个实例有自己的属性，同时又共享着方法的引用，还支持传参数

function Student(name,age){
    // this 代表的就是构造函数返回的对象
    this.name=name
    this.age=age
}
Student.prototype.study=function(){
        console.log(`我是${this.name},我能够快乐的学习`);
}
const maliu=new Student('马六',18)
console.log(maliu.__proto__===Student.prototype);//true
console.log(Object.getPrototypeOf(maliu)===Student.prototype);//true

function Student(name, age) {
        // this 代表的就是构造函数返回的对象
        this.name = name
        this.age = age
    }
    Student.prototype.study = function () {
        console.log(`我是${this.name},我能够快乐的学习`);
    }
    Student.prototype.name='章三'
    const maliu = new Student('马六', 18)
    console.log(maliu);
    console.log(maliu.name);
    maliu.study()
    console.log(maliu.toString());
   maliu.__proto__ //Student的原型对象
   maliu.__proto__.__proto__ //Object 的原型对象
   console.log(maliu.__proto__.__proto__.__proto__);