面向对象

ref:https://github.com/CyC2018

面向对象的设计思想

面向对象的设计思想是从自然界中来的，因为在自然界中就存在类（Class）和实例（Instance）的概念。

• Class 是一种抽象概念，比如我们定义的 Class——Student ，是指学生这个概念，

• 而实例（Instance）则是一个个具体的 Student ，比如， Michael 和 Bob 是两个具体的 Student 。

• 面向过程就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现。

• 面向对象是把构成问题事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为。

面向对象三要素

封装

利用抽象数据类型将数据和基于数据的操作封装在一起，使其构成一个不可分割的独立实体。数据被保护在抽象数据类型的内部，尽可能地隐藏内部的细节，只保留一些对外接口使之与外部发生联系。用户无需知道对象内部的细节，但可以通过对象对外提供的接口来访问该对象。

• 减少耦合：可以独立地开发和测试
• 减轻维护的负担：可以更容易被程序员理解，并且在调试的时候可以不影响其他模块
• 有效地调节性能：可以通过剖析确定哪些模块影响了系统的性能
  提高软件的可重用性
• 降低了构建大型系统的风险：即使整个系统不可用，但是这些独立的模块却有可能是可用的

// 以下 Person 类封装 name、gender、age 等属性，外界只能通过 get() 方法获取一个 Person 对象的 name 属性和 gender 属性，而无法获取 age 属性，但是 age 属性可以供 work() 方法使用。

// 注意到 gender 属性使用 int 数据类型进行存储，封装使得用户注意不到这种实现细节。并且在需要修改 gender 属性使用的数据类型时，也可以在不影响客户端代码的情况下进行。
class Person {

    private String name;
    private int gender;
    private int age;

    String getName() {
        return name;
    }

    String getGender() {
        return gender == 0 ? "man" : "woman";
    }

    void work() {
        if (18 <= age && age <= 50) {
            System.out.println(name + " is working very hard!");
        } else {
            System.out.println(name + " can't work any more!");
        }
    }
}

继承

• 子类可以访问父类非 private 属性

• 里氏替换原则，子类对象必须能够替换掉父类对象。

• 提高代码的复用性，继承是多态的前提。

ES5中的继承方式

function Human(name){
    this.name = name
}
Human.prototype.introduce = function(){
    return this.name
}

1. 构造函数继承

   • 只能继承构造函数中的属性

     function Asian(name){
         Human.call(this,name)
     }

2. 原型链继承

   • 不能向父类构造函数传参
   • 共享引用类型的属性

     function Asian(name){
         this.name = name
     }
     Asian.prototype  = new Human()

3. 1+2组合继承

   • 父类构造函数被调用太多次
   • 共享引用类型属性

     function Asian(name){
         Human.call(this,name)
     }
     Asian.prototype  = new Human()

4. 原型式继承

   • 适用于不想使用构造函数又想共享数据的情况
   • 与原型链模式一样共享引用类型的属性

     // 其实就是Object.create的实现
     function Asian(){
         function F(){}
         F.prototype = Human
         return new F()
     }

5. 寄生继承

   • 工厂函数模式
   • 难以复用

     function createAsian(source){
         const o = Object.create(source)
         o.xxx = xxx //添加自己的属性
         return o
     }
     const s1 = createAsian(Human)

6. 寄生组合继承

   • 只调用一次父构造函数
   • 保持原原型链

     function Asian(name){
         Human.call(this,name)
     }
     Asian.prototype  = Object.create(Human.prototype)
     Asian.prototype.constructor = Asian

     多态

• 父类或接口定义的引用变量可以指向子类或实例对象，即多种不同状态

• 提高了程序的扩展性

//  下面的代码中，乐器类（Instrument）有两个子类：Wind 和 Percussion，它们都覆盖了父类的 play() 方法，并且在 main() 方法中使用父类 Instrument 来引用 Wind 和 Percussion 对象。在Instrument 引用调用 play() 方法时，会执行实际引用对象所在类的 play() 方法，而不是 Instrument 的方法。
class Instrument {
    void play() {
        System.out.println("Instument is playing...");
    }
}
class Wind extends Instrument {
    void play() {
        System.out.println("Wind is playing...");
    }
}
class Percussion extends Instrument {
    void play() {
        System.out.println("Percussion is playing...");
    }
}
class Music {
    static void main(String[] args) {
        List<Instrument> instruments = new ArrayList<>();
        instruments.add(new Wind());
        instruments.add(new Percussion());
        for(Instrument instrument : instruments) {
            instrument.play();
        }
    }
}

六大基本原则：

• Single Responsibility Principle：单一职责原则

  一个类应该只有一个发生变化的原因，只负责一项职责

• Open Closed Principle：开闭原则

  对修改封闭，对拓展开放

• Liskov Substitution Principle：里氏替换原则

  子类能完全替代父类

• Law of Demeter：迪米特法则

  功能模块之间尽量减少相互作用，保持相互独立

• Interface Segregation Principle：接口隔离原则

  用多个借口将功能解耦

• Dependence Inversion Principle：依赖倒置原则

  高层模块不应该依赖低层模块，二者都应该依赖其抽象，对抽象接口进行编程

原型

JavaScript 是一种基于原型的语言 (prototype-based language)

区别于其他面向对象的语言实例中复制父类的全部属性，js 则使用原型去访问父类的公开属性。

原型链

• JS中万物都为对象，(但只有函数拥有原型)
• 构造函数生成的实例对象都包含一个指向其原型对象的内部指针O.__proto__/O.constructor.prototype;
• 如果这个原型又是另一个构造函数生成的实例，则这个原型对象也可以访问自己的原型对象，这样层层递进链式访问的关系就叫做原型链；
• js 中查找属性时，先查找实例自身，后查找原型对象，再沿着原型链不断上溯，直到原型链的尽头null；

特殊的Object和Function

typeof Function.prototype = "function"
Function.prototype = Function.__proto__//f(){[native code]}

// 所有引用类型都继承自Object
Function.prototype.__proto__ === Object.prototype // true

只有函数才有prototype

function f1() {}
f1.__proto__ === Function.prototype; // f1直接由Function构造而来

const obj1 = {};
obj1.prototype; // undefined

原形链的终点

typeof Object.prototype === 'object'
typeof Object === 'function'
// 意味着Object的原型是也是一个对象

// 而对象的构造器也是Object，则会出现死循环
！【Object.prototype.__proto__ === Object.prototype】！


// 为了让原型链有终点。Javascript规定，
Object.prototype.__proto__ === null

function f1(){}
f1.__proto__ = Function.prototype = f(){ [native code] }
f1.__proto__.__proto__ = Object.prototype = {constructor: ƒ, __defineGetter__: ƒ, __defineSetter__: ƒ, hasOwnProperty: ƒ, __lookupGetter__: ƒ, …}
f1.__proto__.__proto__.__proto__ = null

const obj = {}
obj.__proto__ = Object.prototype
obj.__proto__.__proto__ = null

相关方法

• Object.getPrototype()/__proto__

  返回指定对象的原型（隐式原型）

  __proto__虽然在绝大数浏览器都能正常工作，但官方不推荐且已标为废弃，使用Object.getPrototypeOf()替代

• Object.prototype.isPrototypeOf()

  判断对象是否在另一个对象原型链上

this的指向

1. 函数的 this 指向函数运行时的执行上下文
2. 当函数执行时候没指定this，则this指向global对象
3. 当函数被当作对象的方法调用时,this 指向调用对象
4. new操作符生成的对象 this 指向自己
5. 箭头函数的this取决于书写时外部函数体的this