//构造函数创建对象

<script>
  var cat = new Array();
  function Cat(){
  }
  var cat1 = new Cat();
  cat1.name = "小白";
  cat1.age = 1;
  cat[0] = cat1;
  var cat2 = new Cat();
  cat2.name = "小黑";
  cat2.age = 2;
  cat[1] = cat2;
  document.write(cat[0].name + cat[0].age + "<br/>");
  document.write(cat[1].name + cat[1].age);

  

  //判断某对象是不是某个类的实例,关键字instanceof
  var cat3 = new Cat();
  if(cat3 instanceof Cat)
    document.write("Yes! <br/>");
  else
    document.write("No! <br/>");

 

  //直接判断结构也行
  if(cat3.constructor == Cat)
    document.write("Yes! <br/>");
  else
    document.write("No! <br/>");

</script>

 

//JS中var可有可无,但是有无是有区别的

//例1:输出为2

<script>
  var a = 1;
  function b(){
    a = 2;
  }
  b();
  document.write(a);
</script>

//例2:输出为2

<script>
  a = 1;
  function b(){
  a = 2;
  }
  b();
  document.write(a);
</script>

//例3:输出为1(此时函数内重新定义了一个局部变量,和之前的全局变量不在一个栈,不冲突)

<script>
  var a = 1;
  function b(){
  var a = 2;
  }
  b();
  document.write(a);
</script>

//例4:输出为1(同上)

<script>
  a = 1;
  function b(){
  var a = 2;
  }
  b();
  document.write(a);
</script>

 

//如果想在让对象模版本身自带一些属性,可以用this,如果用var的话是private类型不能直接使用

<script>
  function Cat(){
    this.type1 = "1猫";
    var type2 = "2猫";
    //public方法
    this.get1 = function(){
      return type2;
    }
    //private方法不能直接使用
    function get2(){}
  }
  var cat1 = new Cat();
  cat1.name = "喵喵1号";
  cat1["age"] = 2;
  document.write(cat1.type1 + cat1.get1() + cat1["name"] + cat1.age + "<br/>");
</script>

 

//this 详解(谁在调用this就是谁,this只能在对象定义的内部使用)

//例1:

<script>
  function b(){
    document.write(this.a);
  }

  //相当于给window这个对象添加了一个变量a
  var a = 1;

  //此时相当于是window这个对象在调用b(),即window.b();所以this就是window,输出的就是window的属性a的值1
  b();
</script>

 

//例2:

<script>
  function b(){
    this.t = function(){
      document.write(this.a);
    }
  }

  

  function d(){
    document.write(this.a);
  }


  var a = 1;
  var c = new b();
  c.a = 2;

  //c在调用函数t(),所以现在this就是c,输出的自然就是c的属性a的值2
  c.t();

  //此时相当于window.d(),d()中的this就是window,输出1

  d();

  //相当于document.write(a)
  document.write(this.a);

</script>

 

//创建自带属性的对象

//例1:把各属性写在类中

<script>
  function p(name, age, n){
    this.name = name;
    this.age = age;
    this.com = function(){
      var r= 0;
      for(var i=1; i<=n; i++){
        r +=i;
      }
      return r;
    };
  }
  var p1 = new p("小白", 1);
  var p2 = new p("小白", 2, 3);
  document.write(p1.name + p1.age + "<br/>");
  document.write(p2.name + p2.age + "累加结果" + p2.com());

</script>

 

//例2:动态分配属性

<script>
  function p(name){
    this.name = name;
  }
  var p1 = new p("小白");
  var p2 = new p("小白");
  var age = 1;
  p1.age = age;

  function com(n){
    var r= 0;
    for(var i=1; i<=n; i++){
      r +=i;
    }
    return r;
  }
  p2.com = com;  //或者直接p2.com = function com(n){…};,这种动态添加方式只有p2会有该属性

  document.write(p1.name + p1.age + "<br/>");
  document.write(p2.name + "累加结果" + p2.com(10));
</script>

 

//例3:通过原型动态分配属性,这种方法添加的属性所有该类的实力对象都能拥有

//由于对象是按模版类创建的,如果属性函数在类的内部已经定义,那么每创建一个对象都会在对象对应的栈开辟一个该函数的空间,但是通过原型分配的属性函数只分配一次空间让所有对象共享,在对象很多的时候这个方法会更效率

<script>
  function p(name){
    this.name = name;
  }
  p.prototype.show = function show(){
    document.write("什么鬼<br/>");
  };
  p1 = new p("小白");
  p2 = new p("小黑");
  document.write(p1.name);
  p1.show();
  document.write(p2.name);
  p2.show();
</script>