javascript OOP

  <!--面向对象的程序设计-->
    <!--<script type="text/javascript" >
        //创建对象
        var person = new Object();
        person.name = "张三";
        person.age = 21;
        person.job = "Net";
        person.sayName = function () { alert(this.name); }
        //  person.sayName();
        //工厂模式
        function createPerson(name, age, job) {
            var o = new Object();
            o.name = name;
            o.age = age;
            o.job = job;
            o.sayName = function () { alert(this.name); }
            return o;
        };
        var personOne = createPerson("里斯", 21, "Java");
        var personTwo = createPerson("赵六", 21, "Java");
        //     personOne.sayName();
        //  personTwo.sayName();


        //构造函数模式
        function Person(name, age, job) {
            this.name = name;
            this.age = age;
            this.job = job;
            this.sayName = function () { alert(this.name); }
        }
        var person1 = new Person("王哥", 21, "Net")
        //   person1.sayName();


        //把构造函数当作普通函数
        Person("亲爱的", 21, "Java");
        //  window.sayName();


        //在另一个函数的作用域中调用
        var o = new Object();
        Person.call(o, "王武", 21, "Net");
        //   o.sayName();
    </script>-->
    <!--构造函数的问题-->
    <!--<script type="text/javascript">


        function Person(name, age, job) {
            this.name = name;
            this.age = age;
            this.job = job;
            this.sayName = sayName;
        }
        var sayName = function () { alert(this.name); }
        var person = new Person("无敌", 21, "Net");
        //   person.sayName();
        alert(person instanceof Object);
        alert(person instanceof Person);
    </script>-->
    <!---原型模式-->
    <!--<script type="text/javascript">
        function Person() { }
        Person.prototype.name = "顺利";
        Person.prototype.age = 12;
        Person.prototype.job = "JS";
        Person.prototype.sayName = function () { alert(this.name); }
        var person = new Person();
        person.sayName();




        //原型和in操作符
        var person1 = new Person();
        var person2 = new Person();


        alert(person1.hasOwnProperty("name")); //判断name属性是否属于peron1实例
        alert("name" in person1); //使用in操作符，无论属性存在宇当前实例还是实例原型都返回true
        //判断对象是否存在原型中
        function hasPrototype(object, name) {
            return !object.hasOwnProperty(name) && (name in object);
        }
        alert(hasPrototype(person1, "name"))
        person1.name = "";
        // alert(person1.hasOwnProperty("name"));


    </script>-->
    <!--更简单的原型语法-->
    <!--  <script type="text/javascript">
        function Preson() { };
        //        Preson.prototype = {
        //            naem: "孤独",
        //            agg: 21,
        //            job: "Net",
        //            sayName: function () { alert(this.name); }
        //        };
        // var person1 = new Preson();
        //alert(person1 instanceof Object);
        //alert(person1 instanceof Preson);
        //因为重写了原型，所以实例的构造函数不再指向原型 弹出 false
        // alert(person1.constructor == Preson);
        //alert(person1.constructor == Object);


        Preson.prototype = {
            constructor: Preson,
            name: "孤独",
            agg: 21,
            job: "Net",
            sayName: function () { alert(this.name); }
        };
        var person1 = new Preson();
        //因为重写了原型，所以实例的构造函数不再指向原型 弹出 false
        alert(person1.constructor == Preson);
        alert(person1.constructor == Object);


    </script>-->
    <!---原型的动态性-->
    <!--<script type="text/javascript">
        function Person() { };
        var person1 = new Person();
        Person.prototype.sayHi = function () { alert("Hi"); };
        person1.sayHi();
    </script>-->
    <!--原生对象的原型:String、Array、Object....-->
    <!-- <script type="text/javascript">
        //原型模式的重要性不仅体现在创建自定义类型方面，就连所有原生的引用类型，都是采用这种模式创建的，所有原生引用类型（Object \ Array \ String \ )等等都是在其构造函数的原型上定义了方法，例如：在Array.prototype中可以找到sort方法
        //alert(typeof Array.prototype.sort);
        //为原生对象添加方法
        String.prototype.star = function () { alert("为原生对象添加方法"); }
        var msg = "";
        msg.star();
    </script>-->
    <!--原生对象的问题： 存在引用类型时,多个实例公用同一个引用类型-->
    <!--<script type="text/javascript">
        function Person() { };
        Person.prototype = {
            name: "",
            age: 12,
            job: "",
            friends: ["王武", "里斯"],
            sayName: function () { alert(this.name); }
        }
        var person1 = new Person();
        var person2 = new Person();
        person1.friends.push("赵六");
        alert(person1.friends);
        alert(person2.friends);
    </script>-->
    <!--组合使用构造函数模式和原型模式：构造函数：共享属性，重写prototype共享方法-->
    <!--<script type="text/javascript">
        function Person(name, age, job) {
            this.name = name;
            this.age = age;
            this.job = job;
            this.friends = ["Shelby", "Count"]
        }
        Person.prototype = {
            constructor: Person,
            sayName: function () {
                alert(this.name);
            }
        };
        var person1 = new Person("1", 12, "");
        var person2 = new Person("2", 12, "");
        person1.friends.push("里斯");
        person2.friends.push("小小");
        alert(person1.friends);
        alert(person2.friends);


    </script>-->
    <!--动态原型模式-->
    <!--<script type="text/javascript">
        //只有在sayName()不存在的情况下，才会将它添加到原型中，注意这段代码只会在初次调用构造函数是才会执行，此后，原型已经完成初始化，不需要在做什么修改了，不过要记住这里对原型所做的修改，能够立即在所有实例中得到实例
        function Person(name, age, job) {
            this.name = name;
            this.age = age;
            this.job = job;
            if (typeof this.sayName != "function") {
                Person.prototype.sayName = function () {
                    alert(this.name);
                }
            }
        }
        var person1 = new Person("213123", 12, "Net");
        person1.sayName();
    </script>-->
    <!---寄生构造函数模式-->
    <script type="text/javascript">
        function Person(name, age, job) {
            var o = new Object();
            o.name = name;
            o.age = age;
            o.job = job;
            o.sayName = function () { alert(this.name); }
            return o;
        }
        var person1 = new Person("1", 12, "");
        person1.sayName();
        var person2 = new Person("2", 12, "");
        person2.sayName();


        function SpeialArray() {
            var values = new Array();
            values.push.apply(values, arguments);
            values.toPipedString = function () { return this.join("|"); }
            return values;
        }
        var colors = new SpeialArray("red", "blue", "green");
        alert(colors.toPipedString());
    </script>