1、什么是面向对象

概念：类、对象（实例）

  1. // 类
  2. class Person {
  3.     constructor(name, age) {
  4.         this.name = name
  5.         this.age = age
  6.     }
  7.     eat() {
  8.         console.log(`${this.name} eat something`)
  9.     }
  10.     speak() {
  11.         console.log(`My name is ${this.name}, age ${this.age}`)
  12.     }
  13. }
  15. // 实例化
  16. let zhangsan = new Person('zhangsan', 20)
  17. zhangsan.eat()
  18. zhangsan.speak()
  20. let lisi = new Person('lisi', 18)
  21. lisi.eat()
  22. lisi.speak()

三要素：继承、封装、多态
继承：子类继承父类

  1. class Student extends Person {
  2.     constructor(name, age, num) {
  3.         super(name, age)
  4.         this.num = num
  5.     }
  6.     studu() {
  7.         console.log(`${this.name} is study`)
  8.     }
  9. }
  10. let xiaoming = new Student('xiaoming', 18, 'A30')
  11. xiaoming.eat()
  12. xiaoming.speak()
  13. xiaoming.study()

封装：数据的权限和保密

  1. // public 公共的
  2. // protected 受保护的
  3. // private 私有的
  4. 用ts来编写demo
  5. // 如果变量前面没有修饰符，默认public
  6. class Person {
  7.     name
  8.     age
  9.     protected weight
  10.     constructor(name, age, weight) {
  11.         this.name = name
  12.         this.age = age
  13.         this.weight = 120
  14.     }
  15. }
  16. class Student extends Person {
  17.     num,
  18.     private girlfriend
  19.     constructor(name, age, num) {
  20.         super(name, age)
  21.         this.num = num
  22.         this.girlfriend = 'xiaoli'
  23.     }
  24.     study(){
  25.         console.log(`${this.name} is study`)
  26.     }
  27.     getWeight() {
  28.         console.log(`${this.name} weight is ${this.weight}`)
  29.     }
  30. }
  31. let zhangsan = new Student('zhangsan', 18, 'A3')
  32. console.log(zhangsan.girlfriend) // 报错，因为girlfriend是私有变量，不能被外部访问

多态：同一接口的不同实现

  1. // 多态一般牵扯到重写、重载
  2. class Person {
  3.     constructor(name) {
  4.         this.name = name
  5.     }
  6.     saySomething() {
  8.     }
  9. }
  10. class A extends Person {
  11.     constructor(name) {
  12.         super(name)
  13.     }
  14.     saySomething() {
  15.         console.log('I A')
  16.     }
  17. }
  18. class B extends Person {
  19.     constructor(name) {
  20.         super(name)
  21.     }
  22.     saySomething() {
  23.         console.log('I B')
  24.     }
  25. }
  26. // 这就是重写了父类的saySomething方法

2、为什么要使用面向对象

1、程序执行：顺序、判断、循环 — 结构化
2、面向对象 — 数据结构化
3、对于计算机，结构化的才是最简单的
4、编程应该简单 抽象

3、UML类图 — （Unified Modeling Language：统一建模语言）

画图工具：MS Office visio（微软的一个工具）、processon
image.png
注意：

  1. + ：public
  2. # ：protected
  3. - ：private
  4. 格式：
  5.    属性名 类型
  6. + name: String

关系：泛化（继承）、关联（引用）

  1. class Person {
  2.     constructor(name, house) {
  3.         this.name = name
  4.         this.house = house
  5.     }
  6.     saySomething() {
  8.     }
  9. }
  10. class A extends Person {
  11.     constructor(name, house) {
  12.         super(name, house)
  13.     }
  14.     saySomething() {
  15.         console.log('I A')
  16.     }
  17. }
  18. class B extends Person {
  19.     constructor(name, house) {
  20.         super(name, house)
  21.     }
  22.     saySomething() {
  23.         console.log('I B')
  24.     }
  25. }
  26. class House {
  27.     constructor(city) {
  28.         this.city = city
  29.     }
  30.     showCity() {
  31.         console.log(`${this.city}`)
  32.     }
  33. }
  34. // 测试
  35. let aHouse = new House('北京')
  36. let a = new A('aa', aHouse)
  37. console.log(a) // a有房子
  38. let b = new B('bb')
  39. console.log(b) // b无房子

image.png
空心箭头：继承
实心箭头：引用

4、设计原则

《UNIX/LINUX设计哲学》

  • 准则1：小即是美
  • 准则2：让每个程序只做好一件事
  • 准则3：快速建立原型
  • 准则4：舍弃高效率而取可移植性
  • 准则5：采用纯文本来存储数据
  • 准则6：充分利用软件的杠杆效应（软件复用）
  • 准则7：使用shell脚本提高杠杆效应和可移植性
  • 准则8：避免强制性的用户界面
  • 准则9：让每个程序都称为一个过滤器
  • 小准则1：允许用户制定环境
  • 小准则2：使用小写，尽量简写
  • 小准则3：寻求90%的解决方案

    5、SOLID五大设计原则

    1. S -- 单一职责原则（一个程序只做一件事）
    2. O -- 开放封闭原则（对扩展开放，对修改封闭）
    3. L -- 李氏置换原则（子类能覆盖父类，父类出现的地方子类就能出现）
    4. I -- 接口独立原则（保持接口的单一独立，每个接口应该是一种角色）
    5. D -- 依赖导致原则（面向接口编程，依赖于抽象不依赖于具体）
    image.png

    6、设计和模式是分开的

    7、23种设计模式

    1. 一、创建型
    2. 1、工厂模式
    3. 2、单例模式
    4. 3、原型模式
    5. 二、结构型
    6. 1、适配器模式
    7. 2、装饰器模式
    8. 3、代理模式
    9. 4、外观模式
    10. 5、桥接模式
    11. 6、组合模式
    12. 7、享元模式
    13. 三、行为型
    14. 1、策略模式
    15. 2、模板方法模式
    16. 3、观察者模式
    17. 4、迭代器模式
    18. 5、职责连模式
    19. 6、命令模式
    20. 7、备忘录模式
    21. 8、状态模式
    22. 9、访问者模式
    23. 10、中介者模式
    24. 11、解释器模式