标签：思想   编程   模块   封装   call   gem   多态   console   level   

js面向对象（第五周）

什么是面向对象

面向对象是一种编程思想，是在面向过程编程（结构化编程）之后出现的，面向对象的思想基于抽象数据类型，在面向过程编程中，如果把某种数据结构和用于操作他的各种方法模块化一起，会很方便，如果抽象数据进一步抽象成模块，就会发现这些模块就是具体的东西（对象），

面向对象中，对象可以接收其他对象传过来的消息，对象中可以包含其他对象对象可以被当作其他类型的对象，这要求对象的类型“继承”另外的类型。对象只能通过其所提供的接口来进行访问，其内部具体实现是不可访问的，这成为“封装”。面向对象方法的三个核心要素是：封装、继承、多态。

js面向对象的方式

• 对象字面量创建对象：

var fahui = {
    name:"发挥不广泛",
    showName:function(){
        console.log(this.name);
    }
}
console.log(fahui);         
fahui.showName();

• 工厂方式创建对象

function createUser(name){//name 视为原料
    var obj = new Object();     //加工过程
    obj.name = name;            //加工过程
    obj.showName = function(){  //加工过程
        console.log(this.name); //加工过程
    }                            //加工过程
    return obj;             //成品出厂
}

var fahui = createUser("发挥不广泛");   //创建对象
var zhangsan = createUser("张三");
    console.log(fahui);                 //打印对象
    console.log(zhangsan);
    fahui.showName();                   //调用对象方法
    zhangsan.showName();

批量创建对象会比对象字面量创建方便很多；

• 构造函数创建对象

function User(name){
    this.name = name;
    this.showName = function(){
        console.log(this.name);
    }
}
var fahui = createUser("发挥不广泛");   //创建对象
var zhangsan = createUser("张三");
    console.log(fahui);                 //打印对象
    console.log(zhangsan);
    fahui.showName();                   //调用对象方法
    zhangsan.showName();

工厂方式和构造函数方式在创建多个对象时，每个对象中都会出现相同的方法，或者相同的属性，这样就会造成数据的大量冗余。
解决方式：参考JavaScript原生对象，如Array对象，在控制台打印一个数组对象：

有很多的原型属性，使用原型就可以解决上面的大量的数据冗余问题，所以js面向对象是这样的：

/**
定义类，或者叫构造函数
普通用户类
**/
 function User(name,age,sex){ //类，或者叫构造函数
     this.name = name;
     this.age = age;
     this.sex = sex;
 }
 User.prototype.showName = function(){  //类方法
     console.log(this.name);
 }
 User.prototype.showAge = function(){
     console.log(this.age);
 }
 User.prototype.showSex = function(){
     console.log(this.sex);
 }


/**
继承 VIP用户类（继承自普通用户类）
**/
 function VipUser(name,age,sex,level){ 
     User.call(this,name,age,sex);
     this.level = level;
 }
 VipUser.prototype = new User();
 VipUser.prototype.constructor = VipUser;
 VipUser.prototype.showLevel = function(){
     console.log(this.level);
 }

/**
普通用户类对象 张三
**/
 var zhangsan = new User("张三",25,"男");
     zhangsan.showName();
     zhangsan.showAge();
     zhangsan.showSex();

/**
Vip用户对象 发挥不广泛
**/     
var fahui = new VipUser("发挥不广泛",18,"男","Vip顶级");
    fahui.showName();
    fahui.showAge();
    fahui.showSex();
    fahui.showLevel();

结果：

上面的这样写法和Java面向对象相比，不是很像，实现起来，理解起来都和Java面向对象有点不同，比如，构造函数就是类，在Java中构造函数就是构造函数，类就是类，为了解决这个问题es6推出了新的写法，新写法和Java就很像了，下面是好将上面实现过程用es6写出的：

/**
定义类，或者叫构造函数
普通用户类
**/
 class User{
     constructor(name,age,sex){
         this.name = name;
         this.age = age;
         this.sex = sex;
     }
     showName(){
         console.log(this.name);
     }
     showAge(){
         console.log(this.age);
     }
     showSex(){
         console.log(this.sex);
     }
 }

/**
继承 VIP用户类（继承自普通用户类）
**/
 class VipUser extends User{
     constructor(name,age,sex,level){
         super(name,age,sex);
         this.level = level;
     }
     showLevel(){
         console.log(this.level);
     }
 }

  /**
普通用户类对象 张三
**/
 var zhangsan = new User("张三",25,"男");
     zhangsan.showName();
     zhangsan.showAge();
     zhangsan.showSex();

/**
Vip用户对象 发挥不广泛
**/     
var fahui = new VipUser("发挥不广泛",18,"男","Vip顶级");
    fahui.showName();
    fahui.showAge();
    fahui.showSex();
    fahui.showLevel();

<完>
20180823

发挥不广泛

js面向对象

标签：思想   编程   模块   封装   call   gem   多态   console   level   

原文地址：https://www.cnblogs.com/fahuibuguangfan/p/9570752.html