设计模式学习笔记

设计模式学习笔记 设计模式

Spring IOC 工厂、单例、装饰器
Spring AOP 代理、观察者
Spring MVC 委派
Spring JDBC 模板方法

创建型模式 工厂模式

简单工厂模式：是指由工厂对象决定要创建哪一种产品类的实例。
属于创建型模式，但是不属于设计模式，但是非常常见。
适用场景：
1、工厂类负责创建的对象不多
2、只需要知道创建的参数是什么，不需要知道具体的创建细节。
优点：
1、不需要看到创建的细节
2、只需要知道具体传入创建对象的参数
缺点：
1、不易于扩展，每次有新的创建细节的时候就需要修改工厂类，违背开闭原则。
2、一旦参数输错，就可能得不到想要的结果
示例：例如我要创建一个生产手机的工厂，这个工厂可以生产苹果手机，可以生产三星手机。

public interface Phone {
   
   void create();
}

public class IphoneImpl implements Phone{
    @Override
    public void create() {
        System.out.println("苹果手机已经生产出来了");
    }
}

public class ScanStarImpl implements Phone{
    @Override
    public void create() {
        System.out.println("三星手机已经生产出来了");
    }
}

public class PhoneFactory {
    public static String Iphone="Iphone";
    public static String SanStar="ScanStar";

    public Phone createPhone(String className){
        if(Iphone.equals(className)){
             return new IphoneImpl();
        }else if(SanStar.equals(className)){
             return new ScanStarImpl();
        }else{
            return null;
        }
    }
}

public class test {
    public static void main(String[] args) {
        PhoneFactory phoneFactory=new PhoneFactory();
        Phone phone=phoneFactory.createPhone("Iphone");
        Phone phone1=phoneFactory.createPhone("SanStar");
        Phone phone2=phoneFactory.createPhone("");
        phone.create();
        phone1.create();
        phone2.create();
    }
}

工厂方法模式：将工厂类抽象出一个接口，将对象的创建延迟到子类。
属于创建型模式。
适用场景：
1、创建对象需要大量重复的代码，可以将公共的逻辑提取出来
2、客户端不依赖于产品类如何被创建、实现等细节
3、一个类通过其子类来指定创建哪个对象
优点：
1、用户只需要关心所需产品对应的工厂，无须关心创建细节
2、加入新产品符合开闭原则，提高了系统的可扩展性
缺点：代码复杂度变高、代码更抽象不易理解

public interface AbstractFactory {
    
    Phone createPhone();
}

public class IphoneFactoryImpl implements AbstractFactory{
    @Override
    public Phone createPhone() {
        return new IphoneImpl();
    }
}

public class SanStarFactoryImpl implements AbstractFactory{
    @Override
    public Phone createPhone() {
        return new ScanStarImpl();
    }
}

public class test {
    public static void main(String[] args) {
          AbstractFactory abstractFactory=new IphoneFactoryImpl();
          abstractFactory.createPhone().create();
          AbstractFactory abstractFactory1=new SanStarFactoryImpl();
          abstractFactory1.createPhone().create();
    }
}

抽象工厂模式：是指提供一个创建一系列相关或相互依赖的接口，无须指定他们具体的类。
属于创建型模式。
适用场景：一个产品族，例如有3个不同的厂，但是不同的厂都可以生产手机，可以生产电脑。
优点：
1、具体产品在应用层代码隔离，无须关心创建细节
2、将一个系列的产品族统一到一起创建
缺点：
1、规定了可能被创建的产品集合，产品族中扩展的产品困难，需要修改抽象工厂的接口
2、增加了系统的抽象性和理解难度

public interface Computer {
    
    void create();
}

public class IphoneComputer implements Computer{
    @Override
    public void create() {
        System.out.println("苹果电脑生产出来了");
    }
}

public class SanStarComputer implements Computer{
    @Override
    public void create() {
        System.out.println("三星电脑生产出来了");
    }
}

public interface AbstractMultiProductFactory {
    
    Phone createPhone();

    
    Computer createComputer();
}

public class IphoneMultiFactory implements AbstractMultiProductFactory{
    @Override
    public Phone createPhone() {
        return new IphoneImpl();
    }

    @Override
    public Computer createComputer() {
        return new IphoneComputer();
    }
}


public class SanStarMultiFactory implements AbstractMultiProductFactory{
    @Override
    public Phone createPhone() {
        return new ScanStarImpl();
    }

    @Override
    public Computer createComputer() {
        return new SanStarComputer();
    }
}

public class test {
    public static void main(String[] args) {
        AbstractMultiProductFactory abstractMultiProductFactory=new IphoneMultiFactory();
        AbstractMultiProductFactory abstractMultiProductFactory1=new SanStarMultiFactory();
        abstractMultiProductFactory.createPhone().create();
        abstractMultiProductFactory1.createPhone().create();
        abstractMultiProductFactory.createComputer().create();
        abstractMultiProductFactory1.createComputer().create();
    }
}