设计模式、面向对象二：面向对象四大特性

四者的理解

1. 封装
   封装也叫做信息隐藏或者数据访问保护。类通过暴露有限的访问接口，授权外部仅能通过类提供的方式来访问内部信息或者数据。它需要编程语言提供权限访问控制语法来支持。例如Java中的private、protected、public关键字

   封装存在的意义

   • 保护数据不被随意修改，提高代码的可维护性
   • 仅暴露有限的必要的接口，提高类的易用性

2. 抽象
   如果说封装主要讲如何隐藏信息、保护数据，那抽象就是讲如何隐藏方法的具体实现，抽象可以通过接口类或者抽象类来实现，但也并不需要特殊的语法机制来支持。单存的方法本身就满足抽象特性，因为类的方法是通过编程语言中的’函数’这一语法机制来实现的。通过函数包裹具体的实现逻辑，这本身就是一种抽象。

   抽象存在的意义

   • 提高代码的可扩展性、维护性，修改实现不需要改变定义，减少代码的改动范围
   • 是处理复杂系统的有效手段，能有效的过滤掉不必要关注的信息

3. 继承
   继承是用来表示类之间的is-a关系，分为两种模式：单继承和多继承。单继承表示一个子类只继承一个父类，多继承表示一个子类可以继承多个父类。为了实现继承这个特性，编程语言需要提供特殊的语法机制来支持

   继承存在的意义

   主要用来解决代码复用的问题

4. 多态
   多态是指子类可以替换父类，在实际的代码运行过程中，调用子类的方法实现。多态这种特性也需要编程语言提供特殊的语法机制来实现，比如继承、接口类、duck-typing。

   多态存在的意义

   多态可以提高代码的扩展性和复用性，是很多设计模式、设计原则、编程技巧的代码实现基础

抽象的另外一种理解
抽象是从众多事物中抽取出共同的、本质性的特征，而舍弃其非本质的特征。
在抽象时，同与不同，决定于从什么角度上抽象。抽象的角度取决于分析问题的目的
++为什么同与不同决定于从什么角度抽象++
因为，所谓的共同特征，是相对的。比如汽车和大米，从买卖的角度看都是商品，都有价格，这是他们的共同特性，而其他方面则不是。

四者的关系

封装、抽象和继承都结合起来，实现了多态

• 封装和抽象解决的都是信息隐藏的问题。也就是说不同的位置需要看到的信息不同

  • 封装是以类为边界，两边需要的信息量不对等
  • 抽象是以调用者和实现者的角度来区分，两者需要的信息量的差异也很大。

• 抽象和继承关系

  • 抽象将共同的内容从各个实现类中抽取出来，并且每个实现类 实现的这些方法都不相同
  • 继承是将当前类的功能方法直接copy到子类，子类如果不重写的话，各个子类调用的父类的方法结果都一样，只是简单的复用。

• 抽象和继承相同点

  • 当继承中 各个子类都重写了父类的方法，这时，对于抽象和继承，他们实现的思想都一样，都是为了实现多态

---

抽象和继承多态的具体实现

1. 继承时，多态表现

   
   public class DynamicArray {
     private static final int DEFAULT_CAPACITY = 10;
     private int size = 0;
     private int capacity = DEFAULT_CAPACITY;
     private Integer[] elements = new Integer[DEFAULT_CAPACITY];
     
     public int size() { return this.size; }
     public Integer get(int index) { return elements[index];}
     //...省略n多方法...
     
     public void add(Integer e) {
       ensureCapacity();
       elements[size++] = e;
     }
     
     protected void ensureCapacity() {
       //...如果数组满了就扩容...代码省略...
     }
   }
   
   public class SortedDynamicArray extends DynamicArray {
     @Override
     public void add(Integer e) {
       ensureCapacity();
       for (int i = size-1; i>=0; --i) { //保证数组中的数据有序
         if (elements[i] > e) {
           elements[i+1] = elements[i];
         } else {
           break;
         }
       }
       elements[i+1] = e;
       ++size;
     }
   }
   
   public class Example {
     public static void test(DynamicArray dynamicArray) {
       dynamicArray.add(5);
       dynamicArray.add(1);
       dynamicArray.add(3);
       for (int i = 0; i < dynamicArray.size(); ++i) {
         System.out.println(dynamicArray[i]);
       }
     }
     
     public static void main(String args[]) {
       DynamicArray dynamicArray = new SortedDynamicArray();
       test(dynamicArray); // 打印结果：1、3、5
     }
   }
   

   上面的语法机制，我们用到了三个语法机制才实现多态。

   • 第一个语法机制是编程语言要支持父类对象可以引用子类对象
   • 第二个语法机制是编程语言要支持继承
   • 第三个语法机制是编程语言要支持子类重写父类的方法

   通过这三种机制配置一起，我们实现了在 test()方法中，子类SortedDyamicArray替换父类DynamicArray，执行子类SortedDyamicArray的add()方法，就实现了多态特性

2. 接口时，多态的表现

   
   public interface Iterator {
     String hasNext();
     String next();
     String remove();
   }
   
   public class Array implements Iterator {
     private String[] data;
     
     public String hasNext() { ... }
     public String next() { ... }
     public String remove() { ... }
     //...省略其他方法...
   }
   
   public class LinkedList implements Iterator {
     private LinkedListNode head;
     
     public String hasNext() { ... }
     public String next() { ... }
     public String remove() { ... }
     //...省略其他方法... 
   }
   
   public class Demo {
     private static void print(Iterator iterator) {
       while (iterator.hasNext()) {
         System.out.println(iterator.next());
       }
     }
     
     public static void main(String[] args) {
       Iterator arrayIterator = new Array();
       print(arrayIterator);
       
       Iterator linkedListIterator = new LinkedList();
       print(linkedListIterator);
     }
   }
   

   Iterator是一个接口类，定义了一个可以遍历集合的迭代器。Array和LinkedList都实现了接口类Iterator.
   我们通过传递不同类型的实现类（Array、LinkedList）到print（Interator iterator）函数中，支持多态调用不同的next()、hasNext()实现