设计模式 -- 工厂模式（Factory Pattern）

最新推荐文章于 2024-05-07 09:08:15 发布

MagicianHong

最新推荐文章于 2024-05-07 09:08:15 发布

阅读量244

点赞数

分类专栏：设计模式文章标签：设计模式

本文链接：https://blog.csdn.net/scoryy/article/details/123638305

版权

设计模式专栏收录该内容

25 篇文章 11 订阅

订阅专栏

简单工厂模式（Simple Factory Pattern）

根据传入的参数决定实例化哪个对象。

优点：不直接在客户端创建具体产品的实例，降低了耦合性。
缺点：违反了开闭原则，（对扩展开放，对修改关闭），不容易形成高内聚松耦合结构。每当我们增加一种产品的时候就要去修改工厂方法，这样会破坏其内聚性，给维护带来额外开支。

public class SimpleComputerFactory {
    public static Computer makeComputer(String brand) {
        Computer computer=null;
        switch (brand) {
            case "mac":
                computer=new MacComputer();
                break;
            case "mi":
                computer=new MiComputer();
                break;
            default:
                break;
        }
        return computer;
    }
}


// 或者 利用反射来生成对象
public class SimpleFactory {      
    public static <T extends AbstractProduct> T create(Class<T> clasz) {         
        AbstractProduct product = null;         
        try {             
            product = (AbstractProduct) Class.forName(clasz.getName()).newInstance();         
        } catch (InstantiationException e) {             
            e.printStackTrace();        
        } catch (IllegalAccessException e) {             
            e.printStackTrace();         
        } catch (ClassNotFoundException e) {             
            e.printStackTrace();         
        }         
        return (T) product;     
    } 
}


// 或者
public class SendFactory {  
    public static Sender produceMail(){  
        return new MailSender();  
    }  
    public static Sender produceSms(){  
        return new SmsSender();  
    }  
}

工厂方法模式（Factory Method Pattern）

工厂模式定义了一个创建对象的接口，由子类进行对象的初始化，即工厂模式将子类的初始化推迟到了子类里。

优点：不直接在客户端创建具体产品的实例，降低了耦合性。
缺点：每增加一种产品就要相应的增加一个工厂类，比较繁琐。

public abstract class Computer {
     public abstract void setOperationSystem(); 
}


public class MacComputer extends Computer {
    @Override
    public void setOperationSystem() {
        System.out.println("Mac笔记本安装Mac系统");
    }
}
public class MiComputer extends Computer {
    @Override
    public void setOperationSystem() {
        System.out.println("小米笔记本安装Win10系统");
    }
}


public interface ComputerFactory {
     Computer makeComputer();
}
public class MacComputerFactory implements ComputerFactory {
    @Override
    public Computer makeComputer() {
        return new MacComputer();
    }
}
public class MiComputerFactory implements ComputerFactory {
    @Override
    public Computer makeComputer() {
        return new MiComputer();
    }
}


public static void main(String[] args) {
    //生产Mac电脑
    ComputerFactory macFactory=new MacComputerFactory();
    macFactory.makeComputer().setOperationSystem();


    //生产小米电脑
    ComputerFactory miFactory=new MiComputerFactory();
    miFactory.makeComputer().setOperationSystem();
}

抽象工厂模式（Abstract Factory Pattern）

抽象工厂模式和工厂模式很相似，只是它利用接口或者抽象类定义了一个产品族。

此模式在日常开发中使用频率不高，但关键时刻是能起大作用的。

两个产品家族小米公司和苹果公司，每个产品家族中包含笔记本电脑与手机。

//电脑接口
public abstract class Computer {
    public abstract void setOperationSystem();
}
public class MacComputer extends Computer {
    @Override
    public void setOperationSystem() {
        System.out.println("Mac笔记本安装Mac系统");
    }
}
public class MiComputer extends Computer {
    @Override
    public void setOperationSystem() {
        System.out.println("小米笔记本安装Win10系统");
    }
}


//手机接口
public abstract class MobilePhoto {
    public abstract void setOperationSystem();
}
public class IPhoto extends MobilePhoto {
    @Override
    public void setOperationSystem() {
        System.out.println("苹果手机安装IOS系统");
    }
}
public class MiPhoto extends MobilePhoto {
    @Override
    public void setOperationSystem() {
        System.out.println("小米手机安装Android系统");
    }
}


//抽象工厂接口
public interface AbstractFactory {
     Computer makeComputer();
     MobilePhoto makeMobilePhoto();
}
public class AppleFactory implements AbstractFactory {
    @Override
    public Computer makeComputer() {
        return new MacComputer();
    }


    @Override
    public MobilePhoto makeMobilePhoto() {
        return new IPhoto();
    }
}
public class XiaoMiFactory implements AbstractFactory {
    @Override
    public Computer makeComputer() {
        return new MiComputer();
    }


    @Override
    public MobilePhoto makeMobilePhoto() {
        return new MiPhoto();
    }
}


    public static void main(String[] args) {
        //使用苹果工厂生产苹果公司的系列产品
        AbstractFactory appleFactory=new AppleFactory();
        appleFactory.makeComputer().setOperationSystem();
        appleFactory.makeMobilePhoto().setOperationSystem();


       //使用小米工厂生产小米公司的系列产品
        AbstractFactory miFactory=new XiaoMiFactory ();
        miFactory.makeComputer().setOperationSystem();
        miFactory.makeMobilePhoto().setOperationSystem();
    }

根据以下文章总结：