常用设计原则和设计模式

常用设计原则和设计模式

目录
  • 常用设计原则和设计模式
    • 1. 常用的设计原则
    • 2. 常用的设计模式

1. 常用的设计原则

  • 开闭原则（Open Close Principle）

    对扩展开放对修改关闭，为了使程序的扩展性好，易于维护和升级

    public class Person {
    private String name;
    //private int age;
    public Person() {
    }

    public Person(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

    //尽量避免在设计好的原类中添加成员变量，可以使用子类的方式添加新的成员变量
public class SubPerson extends Person {
    private int age;
}

  • 里氏代换原则（Liskov Substitution Principle）

    任何父类可以出现的地方，子类一定可以出现，多使用多态的方式

  • 依赖倒转原则（Dependence Inversion Principle）

    尽量多依赖于抽象类或接口而不是具体实现类，对子类具有强制性和规范

    public abstract class Person {
    private String name;
    
    public Person() {
    }

    public Person(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public abstract void show();
}

    public class SubPerson extends Person {
    @Override
    public void show() {

    }
}

  • 接口隔离原则（Interface Segregation Principle）

    尽量多使用小接口而不是大接口，避免接口的污染，降低类之间耦合度

    public interface Animal {
    void run(); // 用于描述奔跑行为的抽象方法
    void fly(); // 用于描述飞行行为的抽象方法
}

    public interface FlyAnimal {
    void fly(); // 用于描述飞行行为的抽象方法
}

    public interface RunAnimal {
    void run(); // 用于描述奔跑行为的抽象方法
}

    public class Dog implements RunAnimal {
    @Override
    public void run() {
        
    }
}

  • 迪米特法则（最少知道原则）（Demeter Principle）

    一个实体应当尽量少与其他实体之间发生相互作用，使系统功能模块相对独立。

    高内聚，低耦合

  • 合成复用原则（Composite Reuse Principle）

    尽量多使用合成/聚合的方式，而不是继承的方式

    使用场景：生产者消费者模型、一对多通信

    public class A {
    public void show() {
        System.out.println("这是A类中的show方法！");
    }
}

    //问题：在B类中调用A中的方法，可以选择继承A类直接调用，但是这样影响扩展性
//解决：更好的方法是在B类中定义一个A类型的成员变量，同时带有构造方法进行初始化，通过成员变量调用自身类的方法
public class B/* extends A*/ {
    private A a;  // 合成复用原则

    public B(A a) {
        this.a = a;
    }

    public void test() {
        // 调用A类中的show方法，请问如何实现？
        a.show();
    }
}

2. 常用的设计模式

  • 单例模式懒汉式需要针对多线程进行同步处理

    //原版的单例懒汉式
public class Singleton {
    private static Singleton singleton = null;

    public Singleton() {

    }

    //当有两个线程执行时，可能会同时创建两个实例对象
    public static Singleton getInstance() {
        if (null == singleton) {
            singleton = new Singleton();
        }
        return singleton;
    }
}

    //线程同步优化后的单例懒汉式
public class Singleton {

    // 2.声明本类类型的引用指向本类类型的对象并使用private static关键字修饰
    private static Singleton sin = null;

    // 1.私有化构造方法，使用private关键字修饰
    private Singleton() {}

    // 3.提供公有的get方法负责将上述对象返回出去，使用public static关键字修饰
    public static /*synchronized*/ Singleton getInstance() {
        /*synchronized (Singleton.class) {
            if (null == sin) {
                sin = new Singleton();
            }
            return sin;
        }*/
        if (null == sin) {
            synchronized (Singleton.class) {
                if (null == sin) {
                    sin = new Singleton();
                }
            }
        }
        return sin;
    }
}

  • 工厂模式

    1. 普通工厂模式

      普通工厂方法模式就是建立一个工厂类，对实现了同一接口的不同实现类进行实例的创建

      public interface Sender {
    // 自定义抽象方法来描述发送的行为
    void send();
}

      public class MailSender implements Sender {
    @Override
    public void send() {
        System.out.println("正在发送邮件...");
    }
}

      public class SmsSender implements Sender {
    @Override
    public void send() {
        System.out.println("正在发送短信...");
    }
}

      //普通工厂方法模式缺点：如果传递的字符串出错，则不能正确创建对象，并且可能出现空指针异常
public class SendFactory {
    // 自定义成员方法实现对象的创建
    public Sender produce(String type) {
        //System.out.println("随便加一句打印进行测试");
        if ("mail".equals(type)) {
            return new MailSender();//多态，return一个实现类对象
        }
        if ("sms".equals(type)) {
            return new SmsSender();//多态，return一个实现类对象
        }
        return null;
    }
}

      public class SendFactoryTest {

    public static void main(String[] args) {
        // 缺点：代码复杂，可读性略差
        // 优点：扩展性和可维护性更强！  尤其是在创建大量对象的前提下
        // 1.声明工厂类类型的引用指向工厂类类型的对象
        SendFactory sf = new SendFactory();
        // 2.调用生产方法来实现对象的创建
        Sender sender = sf.produce("mail");
        // 3.使用对象调用方法模拟发生的行为
        sender.send();
        
        //工厂模式创建对象调用方法 与 实现类直接创建对象调用方法的对比
        System.out.println("-------------------------------------");
        // 优点：代码简单，可读性强    在创建单个对象时有优势
        // 缺点：扩展性和可维护性略差
        Sender sender1 = new MailSender();
        sender1.send();
    }
}

    2. 有多个工厂方法的工厂模式

      public class SendFactory {
    // 自定义成员方法实现对象的创建
    public Sender produce(String type) {
        //System.out.println("随便加一句打印进行测试");
        if ("mail".equals(type)) {
            return new MailSender();
        }
        if ("sms".equals(type)) {
            return new SmsSender();
        }
        return null;
    }

    public Sender produceMail() {
        return new MailSender();
    }
    public Sender produceSms() {
        return new SmsSender();
    }
}

      //多个工厂方法模式缺点：为了能够正确创建对象，先需要创建工厂类的对象才能调用工厂类中的生产方法
public class SendFactoryTest {

    public static void main(String[] args) {
        // 缺点：代码复杂，可读性略差
        // 优点：扩展性和可维护性更强！  尤其是在创建大量对象的前提下
        // 1.声明工厂类类型的引用指向工厂类类型的对象
        SendFactory sf = new SendFactory();
        // 2.调用生产方法来实现对象的创建
        //Sender sender = sf.produce("mail");
        Sender sender = sf.produceMail();
        // 3.使用对象调用方法模拟发生的行为
        sender.send();
    }
}

    3. 有静态工厂方法的工厂模式

      类图中带有下划线的方法为静态方法

      public class SendFactory {
    // 自定义成员方法实现对象的创建
    public Sender produce(String type) {
        //System.out.println("随便加一句打印进行测试");
        if ("mail".equals(type)) {
            return new MailSender();
        }
        if ("sms".equals(type)) {
            return new SmsSender();
        }
        return null;
    }

    public static Sender produceMail() {
        return new MailSender();
    }
    public static Sender produceSms() {
        return new SmsSender();
    }
}

      public class SendFactoryTest {

    public static void main(String[] args) {
        // 缺点：代码复杂，可读性略差
        // 优点：扩展性和可维护性更强！  尤其是在创建大量对象的前提下
        // 1.声明工厂类类型的引用指向工厂类类型的对象
        //SendFactory sf = new SendFactory();
        // 2.调用生产方法来实现对象的创建
        //Sender sender = sf.produce("mail");
        //Sender sender = sf.produceMail();
        Sender sender = SendFactory.produceMail();
        // 3.使用对象调用方法模拟发生的行为
        sender.send();
    }
}

    4. 抽象工厂模式

      工厂方法模式的实际意义和主要缺点

      实际意义：凡是出现了大量的产品需要创建且具有共同的接口时，可以通过工厂方法模式进行创建

      缺点：类的创建依赖工厂类，也就是说，如果想要拓展程序生产新的产品，就必须对工厂类的代码进行修改，这就违背了开闭原则

      public interface Provider {
    // 自定义抽象方法描述产品的生产行为
    Sender produce();
}

      public class SmsSendFactory implements Provider {
    @Override
    public Sender produce() {
        return new SmsSender();
    }
}

      public class MailSendFactory implements Provider {
    @Override
    public Sender produce() {
        return new MailSender();
    }
}

      public class SendFactoryTest {

    public static void main(String[] args) {
        // 缺点：代码复杂，可读性略差
        // 优点：扩展性和可维护性更强！  尤其是在创建大量对象的前提下
        // 1.声明工厂类类型的引用指向工厂类类型的对象
        //SendFactory sf = new SendFactory();
        // 2.调用生产方法来实现对象的创建
        //Sender sender = sf.produce("mail");
        //Sender sender = sf.produceMail();
        //Sender sender = SendFactory.produceMail();
        // 3.使用对象调用方法模拟发生的行为
        //sender.send();
        
        System.out.println("-------------------------------------");
        Provider provider = new MailSendFactory();
        Sender sender2 = provider.produce();
        sender2.send();
    }
}

      抽象工厂模式的扩展优势

      如果想要拓展程序生产新的产品，不用对工厂类的代码进行修改，就不会违背开闭原则

      public class PacketSender implements Sender {
    @Override
    public void send() {
        System.out.println("正在发送包裹...");
    }
}

      public class PacketSendFactory implements Provider {
    @Override
    public Sender produce() {
        return new PacketSender();
    }
}

      public class SendFactoryTest {

    public static void main(String[] args) {
        // 缺点：代码复杂，可读性略差
        // 优点：扩展性和可维护性更强！  尤其是在创建大量对象的前提下
        // 1.声明工厂类类型的引用指向工厂类类型的对象
        //SendFactory sf = new SendFactory();
        // 2.调用生产方法来实现对象的创建
        //Sender sender = sf.produce("mail");
        //Sender sender = sf.produceMail();
        //Sender sender = SendFactory.produceMail();
        // 3.使用对象调用方法模拟发生的行为
        //sender.send();
        
        /*
        System.out.println("-------------------------------------");
        Provider provider = new MailSendFactory();
        Sender sender2 = provider.produce();
        sender2.send();
        */
        
        System.out.println("-------------------------------------");
        Provider provider1 = new PacketSendFactory();
        Sender sender3 = provider1.produce();
        sender3.send();
    }
}

  • 装饰器模式

    装饰器模式的实际意义：

    • 可以实现一个类功能的扩展。

    • 可以动态的增加功能，而且还能动态撤销（继承不行）

    缺点：产生过多相似的对象，不易排错

    装饰器模式就是给一个对象动态的增加一些新功能，要求装饰对象和被装饰对象实现同一个接口，装饰对象持有被装饰对象的实例

    public interface Sourceable {
    // 自定义抽象方法
    void method();
}

    public class Source implements Sourceable {
    @Override
    public void method() {
        System.out.println("素颜美可以如此之美！");//若在这里直接添加新功能，会违背开闭原则
    }
}

    public class Decorator implements Sourceable {
    private Sourceable source;

    public Decorator(Sourceable source) {
        this.source = source;
    }

    @Override
    public void method() {
        source.method(); // 保证原有功能不变
        System.out.println("化妆之后你会更美！");
    }
}

    public class SourceableTest {

    public static void main(String[] args) {

        Sourceable sourceable = new Source();
        sourceable.method();

        System.out.println("---------------------------------------------------");
        // 接下来使用装饰类实现功能
        Sourceable sourceable1 = new Decorator(sourceable);
        sourceable1.method();
    }
}

  • 代理模式

    代理模式和装饰器模式的比较：

    • 装饰器模式通常的做法是将原始对象作为一个参数传给装饰者的构造器，而代理模式通常在一个代理类中创建一个被代理类的对象。

    • 装饰器模式关注于在一个对象上动态的添加方法，然而代理模式关注于控制对对象的访问

    public class Proxy implements Sourceable {
    private Source source;

    public Proxy() {
        source = new Source();
    }

    @Override
    public void method() {
        source.method();
        System.out.println("我和装饰器模式其实是不一样的！");
    }
}

    public class SourceableTest {

    public static void main(String[] args) {

        Sourceable sourceable = new Source();
        sourceable.method();

        System.out.println("---------------------------------------------------");
        // 接下来使用装饰类实现功能
        Sourceable sourceable1 = new Decorator(sourceable);
        sourceable1.method();

        System.out.println("---------------------------------------------------");
        Sourceable sourceable2 = new Proxy();
        sourceable2.method();
    }
}

  • 模板方法模式

    模板方法模式实际意义：

    • 将多个子类共有且逻辑基本相同的内容提取出来实现代码复用

    • 不同的子类实现不同的效果形成多态，有助于后期维护

    类图中为名字为斜体的为抽象方法或抽象类

    public abstract class AbstractCalculator {

    // 自定义成员方法实现将参数指定的表达式按照参数指定的规则进行切割并返回计算结果  1+1  +
    public int splitExpression(String exp, String op) {
        String[] sArr = exp.split(op);
        return calculate(Integer.parseInt(sArr[0]), Integer.parseInt(sArr[1]));
    }

    // 自定义抽象方法实现运算
    public abstract int calculate(int ia, int ib);
}

    public class Plus extends AbstractCalculator {
    @Override
    public int calculate(int ia, int ib) {
        return ia + ib;
    }
}

    public class Minus extends AbstractCalculator {
    @Override
    public int calculate(int ia, int ib) {
        return ia - ib;
    }
}

    public class AbstractCalculatorTest {

    public static void main(String[] args) {

        AbstractCalculator abstractCalculator = new Plus();
        int res = abstractCalculator.splitExpression("1+1", "\\+");
        System.out.println("最终的运算结果是：" + res); // 2
    }
}
Designpatterns

相关

标签