一、常见的设计原则

1、概念

在软件开发过程中需要遵循的规则和习惯

2、常见的设计原则

1、开闭原则
对修改关闭，对扩展开发
反射+配置文件+工厂等等
2. 里式代换原则
任何父类可以出现的地方，都可以使用子类替换
面向对象中：多态 子类 is a 分类
3. 依赖倒转原则
软件设计过程中尽量去依赖接口和抽象类
4. 接口隔离原则
尽量依赖小接口
降低的代码的耦合度
5. 合成复用原则
尽量实现代码的复用，而不是使用继承
把类作为另一个类的属性
class Person{
Student stu;
}
class Person extends Student{
Student stu;
}
6. 迪米特法则
高内聚，低耦合
耦合： 一个类/模块和其他类/模块之间的依赖关系
内聚： 一个类/模块的功能聚集起来放在类和模块的内部

二、设计模式

1. 设计模式概念

一套被反复使用，分类编目的代码设计经验的总结
在软件设计过程中总结出来的套路，是针对固定场合的处理方案

2. 分类

创建型模式：
工厂模式，单例模式，建造者模式，原型模式
结构型模式：
适配器，代理，装饰者，外观、桥接、享元，组合模式
行为型模式：
策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、
备忘录模式、状态模式、访问者模式、中介者模式、解释器模式

3. 常见的设计模式

1、单例设计模式

  1.       单例，单个实例，单例类在当前进程中只能创建一个实例<br />           <br />          实现单例的步骤：<br />              1.私有构造方法<br />              2.在当前类中调用构造方法的实例对象<br />              3.在当前类中创建方法，返回当前类实例<br />              4.将获取实例的方法提升到类级别，使用static修饰
  1. public class Singleton{
  3.     private Singleton(){}
  4.     private static Singleton sin=new Singleton();
  5.     public static Singleton getInstance(){
  6.            return sin;
  7.     }
  9. //懒汉式单例：
  10.     public  static Singleton2 getInstance(){
  11.         if(manager == null){
  12.             //----------
  13.             System.out.println("into");
  14.             synchronized (TaskManager2.class) {
  15.                 if(manager == null){
  16.                     manager = new TaskManager2();
  17.                 }
  18.             }
  19.         }
  20.         return manager;
  21.     }
  22. }

2. 模板设计模式

定义一个功能骨架，其中存在固定的功能实现和可变的功能实现
将变化的功能抽取出去，传递给子类实现

  1. package cn.blb.deign.mode;
  2. public abstract   class OperationMode {
  4.     /**模板设计模式
  5.      * 操作冰箱
  6.      */
  8.      public void Operation(){
  9.          System.out.println("开门");
  10.             if (style()){
  11.                 System.out.println("存东西");
  12.             }else{
  13.                 System.out.println("取东西");
  14.             }
  16.          System.out.println("关门");
  17.      }
  19.      public abstract boolean style();
  20. }
  21. ----------------------------------------------------------
  22. package cn.blb.deign.mode;
  25. public class Person extends OperationMode {
  26.     @Override
  27.     public boolean style() {
  28.         return false;
  29.     }
  30. }
  31.   package cn.blb.deign.mode;
  32. ------------------------------------------------------------
  34. public class TestPerson {
  35.     public static void main(String[] args) {
  36.         Person p=new Person();
  37.         p.style();
  39.        p.Operation();
  40.     }
  41. }

3. 策略设计模式

定义 并封装一系列的算法，使其可以互相替换，不影响使用的客户

  1. package cn.blb.deign.strategy;
  3. public interface IPayStyle {
  4.     public void payMoney(int money);
  5. }
  7. package cn.blb.deign.strategy;
  9. public class Customer {
  10.     IPayStyle iPayStyle;//多态
  12.     public void show(IPayStyle iPayStyle){//身份的方法
  13.         this.iPayStyle=iPayStyle;
  14.     }
  16.     /**
  17.      * 付钱
  18.      */
  19.     public void pay(int money){
  20.         iPayStyle.payMoney(money);
  21.     }
  22. }
  23. package cn.blb.deign.strategy;
  25. public class GJCustom implements IPayStyle {
  26.     //高级会员
  27.     @Override
  28.     public void payMoney(int money) {
  29.         System.out.println(money*0.6);
  30.     }
  31. package cn.blb.deign.strategy;
  33. public class PTCustom implements IPayStyle {
  34.     @Override
  35.     public void payMoney(int money) {
  36.         System.out.println(money*0.8);
  37.     }
  38. }
  39. package cn.blb.deign.strategy;
  41. public class StrategyDemo {
  43.     public static void main(String[] args) {
  44.         //1. 创建消费者
  45.         Customer customer = new Customer();
  47.         //2. 出示身份
  48.         customer.show( new PTCustom());
  50.         //3. 付钱
  51.         customer.pay(1000);
  52.     }
  53. }

4. 代理设计模式 （重要）

  1. 定义代理对象，为被代理者执行相应的操作，并且提供额外功能处理

5. 观察者模式.

  1. 组成：  <br />   被观察者接口<br />       注册称为观察者方法<br />       取消方法<br />       通知方法<br />   观察者接口<br />       接受通知的方法<br />   具体的观察者<br />   具体的被观察者<br />注意：<br />   /**<br />   *  在具体的被观察者中，申明集合存储观察者的信息<br />   */<br />   private List<Observer> obs = new ArrayList<>()

6. 适配器

将某个类的接口转换成客户端期望的另一个接口的表示形式
消除了由于接口不匹配所造成类的不兼容问题

7. 装饰者

动态的给对象增加功能
名字：
总基类
装饰者基类
被装饰者基类
注意：
装饰者持有被装饰者引用
装饰者和被装饰者具有相同的接口（父类）