10.设计模式&OO原则概览

10.设计模式&OO原则概览

1. OO基本概念

   1. 抽象
   2. 封装
   3. 继承
   4. 多态

2. OO原则

   1. 封装变化
   2. 多用组合，少用继承
   3. 针对接口编程，不针对实现编程
   4. 为交互对象之间的松耦合而努力

3. 设计原则

   1. 找出可能变化的代码，把他独立封装，不要和那些不需要变化的代码混在一起
   2. 针对接口编程，而不是针对实现编程

4. 良好的OO设计必须具备三个特性：

   1. 可复用
   2. 可以扩充
   3. 可维护

5. OO原则是我们的目标，而设计模式是我们的做法

6. 模式是被认为是历史验证的OO设计经验

7. 大多数模式和原则，都着眼于软件变化的主题

8. 知道抽象、继承、封装、多态并不会让你成为好的面向对象的设计者，设计应该更关注建立弹性的设计，可以维护，可以应对变化

9. 举例

   1. 类图

   

   2. 代码

      1. Duck

         package com.desmond.codebase.designpattern.overview.v4;
         
         /**
          * @author presleyli
          * @date 2018/10/17 上午8:11
          */
         public abstract class Duck {
             private Flyable flyable;
             private Quackable quackable;
         
             public Flyable getFlyable() {
                 return flyable;
             }
         
             public void setFlyable(Flyable flyable) {
                 this.flyable = flyable;
             }
         
             public Quackable getQuackable() {
                 return quackable;
             }
         
             public void setQuackable(Quackable quackable) {
                 this.quackable = quackable;
             }
         
             public void swim() {
                 System.out.println("swimming.");
             }
         
             public abstract void display();
         
             public void quack() {
                 System.out.println("original quack.");
             }
         
             public void fly() {
                 System.out.println("original fly.");
             }
         }
         
         

      2. MallrdDuck

         package com.desmond.codebase.designpattern.overview.v4;
         
         /**
          * @author presleyli
          * @date 2018/10/17 上午8:12
          */
         public class MallrdDuck extends Duck {
             @Override
             public void display() {
                 System.out.println("green");
             }
         
             @Override
             public void quack() {
                 this.getQuackable().quack();
             }
         
             @Override
             public void fly() {
                 this.getFlyable().fly();
             }
         }
         
         

      3. RubberDuck

         package com.desmond.codebase.designpattern.overview.v4;
         
         /**
          * @author presleyli
          * @date 2018/10/17 上午8:17
          */
         public class RubberDuck extends Duck {
             @Override
             public void display() {
                 System.out.println("yellow");
             }
         
             @Override
             public void quack() {
                 this.getQuackable().quack();
             }
         
             @Override
             public void swim() {
                 super.swim();
             }
         
             @Override
             public void fly() {
                 this.getFlyable().fly();
             }
         }
         
         

      4. Flyable

         package com.desmond.codebase.designpattern.overview.v4;
         
         /**
          * Created by presleyli on 2018/10/17.
          */
         public interface Flyable {
             void fly();
         }
         
         

      5. CanFly

         package com.desmond.codebase.designpattern.overview.v4;
         
         /**
          * @author presleyli
          * @date 2018/10/19 上午7:32
          */
         public class CanFly implements Flyable {
             @Override
             public void fly() {
                 System.out.println("I can fly...");
             }
         }
         
         

      6. CannotFly

         package com.desmond.codebase.designpattern.overview.v4;
         
         /**
          * @author presleyli
          * @date 2018/10/19 上午7:32
          */
         public class CannotFly implements Flyable {
             @Override
             public void fly() {
                 // do nothing.
             }
         }
         
         

      7. Quackable

         package com.desmond.codebase.designpattern.overview.v4;
         
         /**
          * Created by presleyli on 2018/10/17.
          */
         public interface Quackable {
             void quack();
         }
         
         

      8. CanQuack

         package com.desmond.codebase.designpattern.overview.v4;
         
         /**
          * @author presleyli
          * @date 2018/10/19 上午7:33
          */
         public class CanQuack implements Quackable{
             @Override
             public void quack() {
                 System.out.println("I can quack...");
             }
         }
         
         

      9. CannotQuack

         package com.desmond.codebase.designpattern.overview.v4;
         
         /**
          * @author presleyli
          * @date 2018/10/19 上午7:33
          */
         public class CannotQuack implements Quackable{
             @Override
             public void quack() {
                 // do nothing.
             }
         }
         
         

      10. Main

          package com.desmond.codebase.designpattern.overview.v4;
          
          /**
           * @author presleyli
           * @date 2018/10/17 上午8:14
           */
          public class Main {
              public static void main(String[] args) {
                  MallrdDuck mallrdDuck = new MallrdDuck();
                  mallrdDuck.setFlyable(new CanFly());
                  mallrdDuck.setQuackable(new CannotQuack());
                  mallrdDuck.fly();
                  mallrdDuck.quack();
          
                  RubberDuck rubberDuck = new RubberDuck();
                  rubberDuck.setFlyable(new CanFly());
                  rubberDuck.setQuackable(new CanQuack());
                  rubberDuck.fly();
                  rubberDuck.quack();
          
              }
          }
          
          

      11. Output:

          I can fly...
          I can fly...
          I can quack...