OO极简设计模式

面向对象设计模式

SOLID原则

缩写	全称	中文
S	The Single Responsibility Principle	单一责任原则
O	The Open Closed Principle	开放封闭原则
L	Liskov Substitution Principle	里氏替换原则
I	The Interface Segregation Principle	接口分离原则
D	The Dependency Inversion Principle	依赖倒置原则

S:单一职责原则

• 问题由来：一个方法同时完成两个职责P1和P2，当P1需求改变时很可能使原来正常的P2功能发生改变

• 解决办法：应将每个类的功能尽可能独立，相互影响最小

O:开放封闭原则

• 问题由来：在对代码维护的时候如果修改原来的代码很可能引入新的错误

• 解决方案：扩展功能的时候通过扩展软件实体的行为，而不是修改已有代码

L:里氏替换原则

• 问题由来：原功能是P，现在需要对P扩展，如果不能透明的替换原来的功能，则很可能出现错误

• 解决方案：子类继承自父类的时候，尽量不要重写父类的方法。重载父类的方法时，输入参数应该更轻松？

一个对象在它出现的任何地方都可以被子类替换（功能不受影响）

I:接口分离原则

• 问题由来，如果接口I实现了类A不需要的方法，那A不得不去实现这个方法

• 解决方案：将臃肿的接口拆分

接口拆分，不应该让客户强迫实现它不需要的方法。应该让用户依赖最小的接口。

S：依赖倒置原则

• 问题由来：高层模块A原来依赖具体实现B，现在需要依赖C，就要修改A中代码。这样会增加代码出错的风险

• 解决方案：修改为A依赖接口I，BC仅和I相关。

高层模块不应该依赖底层模块，抽象不应该依赖细节

---

工厂模式

工厂接受用户传递的参数，可以获得不同的属性对象。

一般这些参数不同但是行为名称相同的，使用接口来实现。

工厂模式将创建对象的责任转移到工厂类。

//需要一个接口
public interface Shape {
   void draw();
}
//一些类实现了这个接口
public class Rectangle implements Shape {
 
   @Override
   public void draw() {
      System.out.println("Inside Rectangle::draw() method.");
   }
}
//接口实现2
public class Square implements Shape {
 
   @Override
   public void draw() {
      System.out.println("Inside Square::draw() method.");
   }
}
//工厂可以通过接受参数构造新的shape
public class ShapeFactory {
    
   //使用 getShape 方法获取形状类型的对象
   public Shape getShape(String shapeType){
      if(shapeType == null){
         return null;
      }        
      if(shapeType.equalsIgnoreCase("CIRCLE")){
         return new Circle();
      } else if(shapeType.equalsIgnoreCase("RECTANGLE")){
         return new Rectangle();
      }
      return null;
   }
}
//你可以通过定义Shape对象调用draw方法，draw方法会执行子类的方法。
//but,除了draw，你不能实现其他的方法

单例模式

一个类只有一个实例对象。避免了对资源的多重占用，比如写文件。

注意，对getInstance要同步化，否则可能创建多个实例。

实现方式：

私有化构造函数，如果需要这个类，就getInstance，并且实现同步化。没有接口不能继承

//单例的例子
public class SingleObject {
 
   //创建 SingleObject 的一个对象
   private static SingleObject instance = new SingleObject();
 
   //让构造函数为 private，这样该类就不会被实例化
   private SingleObject(){}
 
   //获取唯一可用的对象
   public static SingleObject getInstance(){
      return instance;
   }
 
   public void showMessage(){
      System.out.println("Hello World!");
   }
}
//怎么获取对象
public class SingletonPatternDemo {
   public static void main(String[] args) {
      //获取唯一可用的对象
      SingleObject object = SingleObject.getInstance();
 
      //显示消息
      object.showMessage();
   }
}

 

生产者消费者模式：

使用管程(monitor)来保护临界区

a.wait等待的是notifyAll,或者a.notify;

wait();notify();notifyall();必须在synchronized块中使用。且同步哪个对象就应该调用那个对象的锁。

wait()用来强制释放这个对象的锁。意思是交出自己的锁，进入等待队列。

 

迭代器模式：

可以顺序遍历集合对象，不需要考虑集合底层实现形式

/*一个容器接口，一个迭代器接口*/
public interface Iterator {
   public boolean hasNext();
   public Object next();
}
public interface Container {
   public Iterator getIterator();
}
/*一种可能的实现方式*/
public class NameRepository implements Container {
   public String names[] = {"Robert" , "John" ,"Julie" , "Lora"};
 
   @Override
   public Iterator getIterator() {
      return new NameIterator();
   }
 
   private class NameIterator implements Iterator {
 
      int index;
 
      @Override
      public boolean hasNext() {
         if(index < names.length){
            return true;
         }
         return false;
      }
 
      @Override
      public Object next() {
         if(this.hasNext()){
            return names[index++];
         }
         return null;
      }     
   }
}

 

观察者模式

适用于一对多的模式，当其中一个对象状态被修改的时候，会通知其他所有的依赖对象更新其状态。观察者和被观察者是抽象耦合的。观察者和被观察者相互拥有更方便修改对方的状态。

/*step 1: 创建被观察对象*/
import java.util.ArrayList;
import java.util.List;
 
public class Subject {
   
   private List<Observer> observers 
      = new ArrayList<Observer>();
   private int state;
 
   public int getState() {
      return state;
   }
 
   public void setState(int state) {
      this.state = state;
      notifyAllObservers();
   }
 
   public void attach(Observer observer){
      observers.add(observer);      
   }
 
   public void notifyAllObservers(){
      for (Observer observer : observers) {
         observer.update();
      }
   }  
}
/*观察者可以是不抽象的哦，这里实现了抽象的，易于扩展*/
public abstract class Observer {
   protected Subject subject;
   public abstract void update();
}
/*实例化一个观察者，*/
public class BinaryObserver extends Observer{
 
   public BinaryObserver(Subject subject){
      this.subject = subject;
      this.subject.attach(this);
   }
 
   @Override
   public void update() {
      System.out.println( "Binary String: " 
      + Integer.toBinaryString( subject.getState() ) ); 
   }
}
/*跑一下*/
public class ObserverPatternDemo {
   public static void main(String[] args) {
      Subject subject = new Subject();
 
      new BinaryObserver(subject);
 
      System.out.println("First state change: 15");   
      subject.setState(15); //每次重置状态，都会触发其他观察者的状态改变
      System.out.println("Second state change: 10");  
      subject.setState(10);
   }
}