2023.03.21设计模式-----工厂模式、抽象工厂、适配器模式

本文链接：https://blog.csdn.net/weixin_51554985/article/details/129695520

设计模式分类：

设计模式分三类，一共23中
创建型模式：单例模式、抽象工厂、工厂模式、原型模式、建造者模式
结构型模式：适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、

代理模式
行为型模式：模板方法模式、命令模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式、状态模式、策略模式、访问者模式、责任链模式

工厂模式：

设计意图：定义一个创建对象的接口，让其子类去决定具体实现哪个接口
主要解决的问题：接口的选择问题
什么时候使用：不同条件下创建不同的实例
关键代码：创建过程在子类执行
使用场景：日志记录数据库访问

public interface Shape {
    public void draw();
}

public class Rict implements Shape{
    @Override
    public void draw() {
        System.out.println("我是矩形");
    }
}

public class Circle implements Shape{
    @Override
    public void draw() {
        System.out.println("我是一个圆");
    }
}

public class ShapeFactory {
    public static Shape getShape (String shapes){
        if(shapes.equalsIgnoreCase("circle")){
            return new Circle();
        }else if(shapes.equalsIgnoreCase("rict")){
            return new Rict();
        }
        return null;
    }
}

public class TestShape {
    public static void main(String[] args) {
        Shape shapes = ShapeFactory.getShape("circle");
        shapes.draw();
    }
}

总结：在图形工厂里面写一个getShape的方法，根据参数去判定，然后返回自己想要实例的对象，然后直接调用实现接口的方法。

抽象工厂模式

设计意图：提供了一个创建一系列相关或者互相依赖的接口，无需指定它们具体的类
主要解决的问题：接口选择的问题
什么时候使用：系统中有多于一个产品，而系统中只是消费其中一个产品
关键代码：在一个工厂里面聚合多个产品
使用场景: QQ皮肤一整套一整套的换！
生成不同的产品

public interface Color {
    public void fill();
}




public class Red implements Color{
    @Override
    public void fill() {
        System.out.println("填充红色");
    }
}


public class Green implements Color{
    @Override
    public void fill() {
        System.out.println("填充绿色");
    }
}




public class ColorFactory extends AbstactFactory{
    @Override
    public Shape getShape(String shapes) {
        return null;
    }
    @Override
    public Color getColor(String colors) {
        if(colors==null){
            return null;
        }
        if(colors.equalsIgnoreCase("green")){
            return new Green();
        }else if(colors.equalsIgnoreCase("red")){
            return new Red();
        }
        return null;
    }
}

public interface Shape {
    public void draw();
}


public class Rect implements Shape{
    @Override
    public void draw() {
        System.out.println("我是一个矩形");
    }
}

public class Circle implements Shape{
    @Override
    public void draw() {
        System.out.println("我是一个圆");
    }
}




public class ShapeFactory extends AbstactFactory{
    @Override
    public Shape getShape(String shapes) {
        if(shapes==null){
            return null;
        }
        if(shapes.equalsIgnoreCase("circle")){
            return new Circle();
        }else if(shapes.equalsIgnoreCase("rict")){
            return new Rect();
        }
        return null;
    }
    @Override
    public Color getColor(String colors) {
        return null;
    }
}

public class SuperFactory {
public static AbstactFactory getFactory(String factory){
    if(factory==null){
        return null;
    }
    if(factory.equalsIgnoreCase("color")){
        return new ColorFactory();
    }else if(factory.equalsIgnoreCase("shape")){
        return new ShapeFactory();
    }

    return null;
}
}





public class TestFactory {

    public static void main(String[] args) {
        AbstactFactory color = SuperFactory.getFactory("color");
        Color green = color.getColor("green");
        green.fill();
    }
}

总结：抽象工厂，就是当存在多个工厂的时候，同样需要参数去判定你到底想要选择哪个工厂，然后根据工厂再去给参数，再次返回你想要实例的对象，最后调用方法，输出你想要的结果，就是用两个get去实现。一定要去创建抽象类--抽象工厂，有几个工厂，抽象类就放几个抽象方法，不同工厂继承抽象类，就去实现属于自己的方法，方法根据参数判定条件去返回实例对象。

适配器模式-----作为两个接口不兼容的桥梁

public interface MediumMediaPlayer{
    public void playM3(String fileName);
    public void playM4(String fileName);
}



public class Mp3Player implements MediumMediaPlayer{
    @Override
    public void playM3(String fileName) {
        System.out.println("正在播放的歌曲是："+fileName);
    }
    @Override
    public void playM4(String fileName) {
    }
}


public class Mp4Player implements MediumMediaPlayer{
    @Override
    public void playM3(String fileName) {
    }
    @Override
    public void playM4(String fileName) {
        System.out.println("正在播放的电影是"+fileName);
    }
}

public interface MediaPlayer {
    public void play(String types,String fileName);
}



public class MediaAdapter implements MediaPlayer{
    MediumMediaPlayer mediumMediaPlayer;
    public MediaAdapter(String aduiotype){
        if (aduiotype.equalsIgnoreCase("mp3")){
            mediumMediaPlayer=new Mp3Player();
        }else if(aduiotype.equalsIgnoreCase("mp4")){
            mediumMediaPlayer=new Mp4Player();
        }
    }
    @Override
    public void play(String types, String fileName) {
        if(types.equalsIgnoreCase("mp3")){
             mediumMediaPlayer.playM3(fileName);
        }else if(types.equalsIgnoreCase("mp4")){
            mediumMediaPlayer.playM4(fileName);
        }

    }
}

public class AudioPlayer implements MediaPlayer{

    MediaAdapter mediaAdapter;

    @Override
    public void play(String types, String fileName) {
       if(types.equalsIgnoreCase("mp3")){
           System.out.println("音乐"+fileName);
           mediaAdapter=new MediaAdapter(types);
           mediaAdapter.play(types,fileName);
       }else if(types.equalsIgnoreCase("mp4")){
           System.out.println("视频"+fileName);
           mediaAdapter=new MediaAdapter(types);
           mediaAdapter.play(types,fileName);
       }
    }
}

public class Test03 {
    public static void main(String[] args) {
        AudioPlayer audioPlayer=new AudioPlayer();
        audioPlayer.play("mp4","绿皮书");
        audioPlayer.play("mp3","说好不哭");
    }
}