简单工厂模式复件

初学者代码毛病：

活字印刷，面向对象

面向对象的好处

通过封装、继承、多态把程序的耦合度降低，传统印刷术的问题就在于所有的字都刻在同一版面上造成耦合度太高所致，开始用设计模式使得程序更加灵活，易于修改，并且易于复用。

中国古代的四大发明，另外三种应该是科技的进步，伟大的创造或发明。而唯有活字印刷，实在是思想的成功，面向对象的胜利。

业务的封装

应该让业务逻辑和界面逻辑分开，让他们之间的耦合度降低。只有分离开，才可以达到容易维护和扩展。例如计算器的程序，运算程序要和界面的程序分开。

public class Opeartion {

       /*

       * 1 +, 2 -,3 *,4 /

       */

       public static double getResult(double numA, double numB, int oper){

             double result = 0;

            

             switch (oper) {

             case 1://+

                  result = numA + numB;

                   break;

             case 2://-

                  result = numA - numB;

                   break;

             case 3://*

                  result = numA * numB;

                   break;

             case 4:///

                  result = numA / numB;

                   break;

             default:

                   break;

            }

            

             return result;

      }

}

public class Main {

      

       public static void main(String[] args) {

             double numA = 12;

             double numB = 23;

             double result = Opeartion.getResult(numA, numB, 1);

            System. out.println("The result is :" + result);

      }

}

紧耦合VS松耦合

大鸟：如果我希望增加一个开跟运算（sqrt），你如何改

小菜：那只需修改Operation类就可以了，在switch上增加一个分支就可以

大鸟：问题是你要增加一个平方根运算，却需要让加减乘除的运算都得来参与编译，你应该把加减乘除等运算分离，修改其中一个不影响另外的几个，增加运算算法也不影响其他代码。

简单工厂模式

到底实例化谁，将来是不是增加实例化的对象，比如增加开跟运算，这是很容易变化的地方，应该考虑让一个单独的类来做这个创造实例的过程，，这就是工厂。

public abstract class Opeartion {

       protected double numA ;

       protected double numB ;

      

       public double getNumA() {

             return numA ;

      }

       public void setNumA(double numA) {

             this.numA = numA;

      }

       public double getNumB() {

             return numB ;

      }

       public void setNumB(double numB) {

             this.numB = numB;

      }

       public abstract double getResult() throws Exception ;

}

public class OperationAdd extends Opeartion{

       @Override

       public double getResult() {

             // TODO Auto-generated method stub

             return numA + numB;

      }

}

public class OperationFactory {

       public static Opeartion createOperation(int operType){

            Opeartion oper = null;

            

             switch (operType) {

             case 1://+

                  oper = new OperationAdd();

                   break;

             case 2://-

                  oper = new OperationSub();

                   break;

             case 3://*

                  oper = new OpeartionMul();

                   break;

             case 4:///

                  oper = new OpeartionDiv();

                   break;

             default:

                   break;

            }

            

             return oper;

      }

}

public class MainSFactory {

       public static void main(String[] args) throws Exception {

            Opeartion oper;

            oper = OperationFactory. createOperation(1);

            oper. numA = 1;

            oper. numB = 23;

             double result = oper.getResult();

            System. out.println("The result is : " + result);

      }

}

当需求有变化的时候，使用抽象来封装变化（peration抽象类）。

---

组合：

合成（Composotion）也有翻译成‘组合’的，是一种强的拥有关系，体现了严格的整体和部分的关系，整体和部分的生命周期一样。这里鸟和翅膀就是合成（组合）关系，因为他们是部分和整体的关系，并且翅膀和鸟的生命周期是一样的。

public class Bird {

       private Wing wing ;

      

       public Bird() {

             wing = new Wing();//在Bird类中，初始化时实例化Wing，他们之间同时生产

      }

}

聚合：

聚合（Aggregation）表示一种弱的‘拥有’关系，体现的是A对象可以包含B对象，但是B对象不是A对象的一部分。

public class WideGooseAggregate {

       private WideGoose[] arrayWideGoose;

}

关联：

关联（Association）当一个类‘知道’另一个类时，可以用关联。体现的是两个类、或者类与接口之间语义级别的一种强依赖关系。

public class Penguin {

       private Climate climate;

}

依赖：

依赖（Dependency）存在于某个方法调用的参数中，或某个方法的局部变量中。就是一个类 A使用到了另一个类B，而这种使用关系是具有偶然性的、临时性的、非常弱的，但是 B类的变化会影响到A。

public class Animal {

       public void Metabolism(Oxygen oxygen,Water water){

            

      }

}

关联，依赖，聚合，组合四种关系都是语义级别的，所以从代码层面并不能完全区分各种关系。所表现的强弱程度依次为：组合 >聚合> 关联>依赖。

编程是一门技术，更是一门艺术，不能只满足于写完代码运算结果正确就完事，时常考虑如何让代码更加简练，更加容易维护，容易扩展和复用，只有这样才可以真正的提高。写出优雅的代码真是一件很爽的事。