面向对象1

 1  // 1. 异常捕获
 2     /*
 3     try{
 4         console.log(num);
 5     }catch (e) {
 6         //抛出错误
 7         console.log(e);
 8     }
 9     console.log(10);
10     */

1 /*try{
2         console.log(num);//有问题的代码
3     }catch (e) {
4         console.log(e); 
5     }finally {
6         console.log(‘释放一些资源‘);//都会进入到这里面
7     }*/

<script>
    function Dog(name, age, dogF) {
        // 属性
        this.name = name;
        this.age = age;
        this.dogF = dogF;

        // 方法
        this.eat = function (someThing) {
            console.log(this.name + ‘吃‘ + someThing);
        };

        this.run = function (someWhere) {
            console.log(this.name + ‘跑‘ + someWhere);
        }
    }

    // 产生狗对象
    var smallDog = new Dog(‘小狗‘, 1);
    console.log(smallDog);

    var bigDog = new Dog(‘大狗‘, 5, [‘大大‘, ‘小小‘]);
    console.log(bigDog);


</script>

封装：把客观事物封装成抽象的类，隐藏属性和方法的实现细节，仅对外公开接口

继承：子类可以继承父类的所有功能

多态：同一操作作用在不同的对象上，可以产生不同的解释和不同的执行结果

<script>
    /**
     * 构造函数
     * @param {Object}options
     * @constructor
     */
    function Dog(options) {
        // 属性
        this.name = options.name;
        this.age = options.age;
        this.dogF = options.dogF;

        // 方法
        this.eat = function (someThing) {
            console.log(this.name + ‘吃‘ + someThing);
        };

        this.run = function (someWhere) {
            console.log(this.name + ‘跑‘ + someWhere);
        }
    }

    // 产生狗对象
    var smallDog = new Dog({name: ‘小花狗‘, age: 1});
    console.log(smallDog);

    var bigDog = new Dog({name: ‘大狗‘, age: 5, dogF: [‘大大‘, ‘小小‘]});
    console.log(bigDog);

    console.log(‘------------------------‘);
    console.log(smallDog === bigDog); // false
    console.log(smallDog.eat === bigDog.eat); // false
    console.log(smallDog.run === bigDog.run); // false

</script>

 1 function Dog(options) {
 2         // 属性
 3         this.name = options.name;
 4         this.age = options.age;
 5         this.dogF = options.dogF;
 6     }
 7 
 8 Dog.prototype = {
 9         eat: function (someThing) {
10             console.log(this.name + ‘吃‘ + someThing);
11         },
12         run: function (someWhere) {
13             console.log(this.name + ‘跑‘ + someWhere);
14         }
15     };
16 将方法赋到原型上面

 1 <script>
 2     /**
 3      * 构造函数
 4      * @param {Object}options
 5      * @constructor
 6      */
 7     function Dog(options) {
 8         // 属性
 9         this.name = options.name;
10         this.age = options.age;
11         this.dogF = options.dogF;
12     }
　　　　　　
13 
14     Dog.prototype = {
15         constructor:Dog,  ///告诉原型对象的指向，必须要写
16         eat: function (someThing) {
17             console.log(this.name + ‘吃‘ + someThing);
18         },
19         run: function (someWhere) {
20             console.log(this.name + ‘跑‘ + someWhere);
21         }
22     };
23 
24     // 产生狗对象
25     var smallDog = new Dog({name: ‘小花狗‘, age: 1});
26     var bigDog = new Dog({name: ‘大狗‘, age: 5, dogF: [‘大大‘, ‘小小‘]});
27 
28 
29     console.log(‘------------拿到原型对象------------‘);
30     console.log(smallDog);
31     console.log(smallDog.__proto__);
32     console.log(smallDog.__proto__.constructor);
33     console.log(bigDog.__proto__.constructor);//指向创建对象的构造函数
34     console.log(bigDog.constructor === smallDog.constructor);
35 
36 </script>

Dog.prototype.eat = function (someThing) { console.log(this.name + ‘吃‘ + someThing); };  这样的写法，里面的object默认指向它的构造器