工厂设计模式

接口的应用：工厂模式

工厂模式：实现了创建者与调用者的分离，即将创建对象的具体过程屏蔽隔离起来，达到提高灵活性的目的。
其实设计模式和面向对象设计原则都是为了使得开发项目更加容易扩展和维护，解决方式就是一个“分工”。

社会的发展也是这样，分工越来越细。

• 原始社会的人：人什么都要会，自己种，自己打猎，自己织衣服，自己治病
• 现在的人：可以只会一样，其他都不会，只会 Java 也能活，不会做饭，不会开车，不会…

1、工厂模式的分类：

1. 简单工厂模式：用来生产同一等级结构中的任意产品。（对于增加新的产品，需要修改已有代码）
2. 工厂方法模式：用来生产同一等级结构中的固定产品。（支持增加任意产品）
3. 抽象工厂模式：用来生产不同产品族的全部产品。（对于增加新的产品，无能为力；支持增加产品族）

GOF 在《设计模式》一书中将工厂模式分为两类：工厂方法模式（Factory Method）与抽象工厂模式（Abstract
Factory）。将简单工厂模式（Simple Factory）看为工厂方法模式的一种特例，两者归为一类。

核心本质：实例化对象，用工厂方法代替new操作。将选择实现类、创建对象统一管理和控制。从而将调用者跟我们的实现类解耦。

2、无工厂模式

	interface Car{
	    void run();
	}
	
	class Audi implements Car{
	    public void run() {
	        System.out.println("奥迪在跑");
	    }
	}
	
	class BYD implements Car{
	    public void run() {
	        System.out.println("比亚迪在跑");
	    }
	}
	
	public class FactoryDemo{
	    public static void main(String[] args) {
	        Car a= newAudi();
	        Car b= newBYD();
	        a.run();
	        b.run();
	    }
	}

3、简单工厂模式

简单工厂模式，从命名上就可以看出这个模式一定很简单。它存在的目的很简单：定义一个用于创建对象的工厂类。
调用者只要知道他要什么，从哪里拿，如何创建，不需要知道。
分工，多出了一个专门生产 Car 的实现类对象的工厂类。把调用者与创建者分离。

• 小结：简单工厂模式也叫静态工厂模式，就是工厂类一般是使用静态方法，通过接收的参数的不同来返回不同的实例对象。
• 缺点：对于增加新产品，不修改代码的话，是无法扩展的。违反了开闭原则（对扩展开放；对修改封闭）

	interface Car{
	    void run();
	}
	
	class Audi implements Car{
	    public void run() {
	        System.out.println("奥迪在跑");
	    }
	}
	class BYD implements Car{
	    public void run() {
	        System.out.println("比亚迪在跑");
	    }
	}
	
	class CarFactory{
	    
	    //方式一
	    /*public static Car getCar(String type){
	        if("奥迪".equals(type)) { 
	            return new Audi();
	        } else if("比亚迪".equals(type)) {
	            return new BYD();
	        } else {
	            return null;
	        }
	    }*/
	    
	    //方式二
	    public static Car getAudi(){
	        return new Audi();
	    }
	    public static Car getBYD(){
	        return new BYD();
	    }
	}


	public class factory{
	    public static void main(String[] args) {
	
	        Car audi = CarFactory.getAudi();
	        audi.run();
	        Car byd = CarFactory.getBYD();
	        byd.run();
	    }
	}

4、工厂方法模式

为了避免简单工厂模式的缺点，不完全满足OCP（对扩展开放，对修改关闭）。
工厂方法模式和简单工厂模式最大的不同在于，简单工厂模式只有一个（对于一个项目或者一个独立的模块而言）工厂类，而工厂方法模式有一组实现了相同接口的工厂类。这样在简单工厂模式里集中在工厂方法上的压力可以由工厂方法模式里不同的工厂子类来分担。

	interface Car{
	    void run();
	}
	
	class Audi implements Car{
	    public void run() {
	        System.out.println("奥迪在跑");
	    }
	}
	class BYD implements Car{
	    public void run() {
	        System.out.println("比亚迪在跑");
	    }
	}
	
	//抽象工厂
	interface Factory{
	    Car getCar();
	}
	
	//抽象工厂的两个具体实现类
	class AudiFactory implements Factory{
	    @Override
	    public Car getCar() {
	        return new Audi();
	    }
	}
	class BYDFactory implements Factory{
	    @Override
	    public Car getCar() {
	        return new BYD();
	    }
	}
	
	
	public class factory{
	    public static void main(String[] args) {
	
	        Car audi = new AudiFactory().getCar();
	        audi.run();
	        Car byd = new BYDFactory().getCar();
	        byd.run();
	    }
	}

总结：简单工厂模式与工厂方法模式真正的避免了代码的改动了？没有。

• 在简单工厂模式中，新产品的加入要修改工厂角色中的判断语句；
• 在工厂方法模式中，要么将判断逻辑留在抽象工厂角色中，要么在客户程序中将具体工厂角色写死（就像上面的例子一样）。而且产品对象创建条件的改变必然会引起工厂角色的修改。
• 面对这种情况，Java 的反射机制与配置文件的巧妙结合突破了限制——这在Spring 中完美的体现了出来。

5、抽象工厂模式

抽象工厂模式和工厂方法模式的区别就在于需要创建对象的复杂程度上。而且抽象工厂模式是三个里面最为抽象、最具一般性的。
抽象工厂模式的用意为：给客户端提供一个接口，可以实现一系列相关产品对象（属于同一个产品族）的创建过程。它和工厂方法模式的侧重点不同，工厂方法模式更加侧重于同一产品等级，而抽象工厂模式侧重的是同一产品族。而且使用抽象工厂模式还要满足一下条件：

1. 系统中有多个产品族，而系统一次只可能消费其中一族产品。
2. 同属于同一个产品族的产品以其使用。

抽象工厂是创建型设计模式，它强调了一系列相关产品对象（属于同一个产品族）的创建过程，它和工厂方法模式的侧重点不同，工厂方法模式更加侧重于同一产品等级，而抽象工厂模式侧重的是同一产品族。简单说就是一个工厂中生产的一系列对象都是同一个产品族的。
用汽车来举例，宝马生产的产品有宝马汽车、宝马跑车。比亚迪生产的产品有比亚迪汽车、比亚迪跑车。

//创建两个接口
interface Car{//汽车
    void car();
}

interface SportCar{//跑车
    void sportCar();
}

//创建具体的产品
class AodiCar implements Car{
    @Override
    public void car() {
        System.out.println("奥迪汽车");
    }
}

class AodiSportCar implements SportCar{
    @Override
    public void sportCar() {
        System.out.println("奥迪跑车");
    }
}

//比亚迪产品
class BYDCar implements Car{
    @Override
    public void car() {
        System.out.println("比亚迪汽车");
    }
}
class BYDSportCar implements SportCar{
    @Override
    public void sportCar() {
        System.out.println("比亚迪跑车");
    }
}

//抽象工厂
interface Factory{
    Car productCar();
    SportCar productSportCar();
}

//具体的生产工厂
class AodiFactory implements Factory{

    @Override
    public Car productCar() {
        return new AodiCar();
    }

    @Override
    public SportCar productSportCar() {
        return new AodiSportCar();
    }
}

//比亚迪具体生产工厂
class BYDFactory implements Factory{

    @Override
    public Car productCar() {
        return new BYDCar();
    }

    @Override
    public SportCar productSportCar() {
        return new BYDSportCar();
    }
}


public class AbstractFactory{
    public static void main(String[] args) {
    
        //抽象工厂
        Factory bydFactory = new BYDFactory();
        
        //比亚迪工厂
        Car BydCar = bydFactory.productCar();
        SportCar BydsportCar = bydFactory.productSportCar();
        
        //比亚迪具体产品
        BydCar.car();
        BydsportCar.sportCar();

 		Factory aodiFactory = new AodiFactory();
        Car aodiCar = aodiFactory.productCar();
        SportCar aodisportCar = aodiFactory.productSportCar();
        aodiCar.car();
        aodisportCar.sportCar();
    }
}

6、更多设计模式

如果需要了解更多设计模式详情，请访问链接查看https://blog.csdn.net/qq_44392492/article/details/108309010