设计模式（一）

遵循的六大原则：

1. 开闭原则 ：扩展开放，修改关闭
2. 单一职责原则：每个类应该只负责一项职责
3. 依赖倒转原则：面向接口编程
4. 迪米特原则：类与类之间的依赖越少越好
5. 里氏替换原则：在子类中尽量不要重写和重载父类的方法
6. 接口隔离原则：接口尽可能精简，单一

工厂模式：

1. 简单工厂：将对象的创建过程分封装在工厂中，根据实际传递的参数选择创建不同的产品。（注：不属于设计模式）

2. 工厂方法：将不同的产品创建过程封装到不同的工厂中生产，具体的判断逻辑放到客户端。

3. 抽象工厂：将类似的产品组成一个产品族，交由一个具体工厂生产，其他与工厂方法类似。

   1. 抽象产品

      public interface PC {
       void make();
      }
       public interface Phone {
       void make();
      }
      

   2. 具体产品,小米手机和苹果手机为同一类产品，产品族。都可以放到手机工厂中创建。

      public class IPhone implements Phone{
         @Override
         public void make() {
                 System.out.println("生产苹果手机");
              }
         }
      public class MiPhone implements Phone{
             @Override
             public void make() {
                 System.out.println("生产小米手机");
             }
        }
      public class Mac implements Pc{
                      @Override
                      public void make() {
                          System.out.println("生产苹果平板");
                    }
               }
      public class MiPc implements Pc{
                        @Override
                        public void make() {
                          System.out.println("生产小米pc");
                  }
               }
      

   3. 抽象工厂

      public interfance Factory {
            Phone create();
            Pc createPc();          
      }
      

   4. 实际工厂

      public class IPhoneFactory implements Factory{
          @Override
          public Phone create() {
              return new IPhone();
          }
             
          @Override
          public Pc createPc() {
              return new Mac();
          }
      }
       public class MiPhoneFactory implements Factory{
                  @Override
                  public Phone create() {
                      return new MiPhone();
                  }
                  @Override
                  public Pc createPc() {
                      return new MiPc();
                  }
      }
      

   5. 测试

       public class DemoTest {
                      public static void main(String[] args) {
                          IPhoneFactory iPhoneFactory1 = new IPhoneFactory();
                          iPhoneFactory1.create().make();
                          iPhoneFactory1.createPc().make();
                          MiPhoneFactory miPhoneFactory1 = new MiPhoneFactory();
                          miPhoneFactory1.create().make();
                          miPhoneFactory1.createPc().make();
                      }
                  }
      

   ​

策略模式

1. context封装角色

   屏蔽高层模块对策略、算法的直接访问。

2. strategy 抽象策略角色

   定义每个策略必须有的方法和属性。

3. concreteStrategy具体策略角色

策略模式的实现方式：

1. 普通方式：略

2. 策略枚举：

   public enum Calculator {
       ADD("+"){
           public int exec(int a,int b){
               return a+b;
           }
       }
       SUB("-"){
           public int exec(int a,int b){
               return a-b;
           }
       }
       String value = "";
       private Calculator(String _value){
           this.value = _value;
       }
       public String getValue(){
           return this.value;
       }
       public abstrac int exec(int a,int b);
   }
   public class Client {
   	public static void main(String[] args) {
   		//输入的两个参数是数字
           int a = Integer.parseInt(args[0]);
           String symbol = args[1]; //符号
           int b = Integer.parseInt(args[2]);
           System.out.println("输入的参数为："+Arrays.toString(args));
           System.out.println("运行结果为："+a+symbol+b+"="+Calculator.ADD.exec(a,b));
   	}
   }
   

​

​