三个工厂模式的具体实现(参观向)

工厂模式(简单工厂模式,工厂方法模式,抽象工厂模式)

**简单工厂模式**
//工厂类->产品类->抽象产品接口
//调用工厂类即可

vehicle接口
public interface vehicle {
    void name();
}

bus类
public class bus implements vehicle {
    @Override
    public void name() {
        System.out.println("This is a bus");
    }
}

car类
public class car implements vehicle{
    @Override
    public void name() {
        System.out.println("This is a car");
    }
}

train类
public class train implements vehicle{
    @Override
    public void name() {
        System.out.println("This is a train");
    }
}

工厂类
public class vehiclefactory{
    public static vehicle getVehicle(String vehicle) {
        if(vehicle.equals("bus"))
        {
            return new bus();
        }
        else if(vehicle.equals("car"))
        {
            return new car();
        }
        else if(vehicle.equals("train"))
        {
            return new train();
        }
        else
        {
            return null;
        }
    }

}

用户类
public class consumer {
    public static void main(String[] args) {
        vehicle bus = vehiclefactory.getVehicle("bus");
        vehicle train = vehiclefactory.getVehicle("train");
        vehicle car = vehiclefactory.getVehicle("car");
        bus.name();
        train.name();
        car.name();
    }
}

缺点:

由于工厂类集中了所有产品创建逻辑，一旦不能正常工作，整个系统都要受到影响。使用简单工厂模式将会增加系统中类的个数，在一定程序上增加了系统的复杂度和理解难度。系统扩展困难，一旦添加新产品就不得不修改工厂逻辑，同样破坏了“开闭原则”；在产品类型较多时，有可能造成工厂逻辑过于复杂，不利于系统的扩展和维护。简单工厂模式由于使用了静态工厂方法，造成工厂角色无法形成基于继承的等级结构。

**工厂方法模式**
//每一个工厂对应一个类
//调用对应工厂类即可

vehicle接口
public interface vehicle {
    void name();
}

bus类
public class bus implements vehicle {
    @Override
    public void name() {
        System.out.println("This is a bus");
    }
}

car类
public class car implements vehicle{
    @Override
    public void name() {
        System.out.println("This is a car");
    }
}

train类
public class train implements vehicle{
    @Override
    public void name() {
        System.out.println("This is a train");
    }
}

工厂抽象类
public interface vehiclefactory {
    vehicle getvehicle();
}

busfactory
public class busfactory implements  vehiclefactory{
    @Override
    public vehicle getvehicle() {
        return new bus();
    }
}

carfactory
public class carfactory implements  vehiclefactory{
    @Override
    public vehicle getvehicle() {
        return new car();
    }
}

trainfactory
public class trainfactory implements vehiclefactory{
    @Override
    public vehicle getvehicle() {
        return new train();
    }
}

用户类
public class consumer {
        public static void main(String[] args) {
            vehicle bus = new busfactory().getvehicle();
            vehicle car = new carfactory().getvehicle();
            vehicle train = new trainfactory().getvehicle();
            bus.name();
            train.name();
            car.name();
        }
    }

优点:符合开闭原则.

缺点:方法类过多时,类会冗余.

---

**抽象工厂模式**
/*抽象工厂模式的主要角色如下。
抽象工厂（Abstract Factory）：提供了创建产品的接口，它包含多个创建产品的方法 newProduct()，可以创建多个不同等级的产品。
具体工厂（Concrete Factory）：主要是实现抽象工厂中的多个抽象方法，完成具体产品的创建。
抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能，抽象工厂模式有多个抽象产品。
具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间是多对一的关系。*/

//手机接口
public interface  Iphoneproduct {

    void start();
    void shutdown();
    void callup();
    void sendSMS();

}

//路由器接口
public interface Irouteproduct {

    void start();
    void shutdown();

}

//华为手机
public class huaweiphone implements Iphoneproduct{
    @Override
    public void start() {
        System.out.println("华为开机");
    }

    @Override
    public void shutdown() {
        System.out.println("华为关机");
    }

    @Override
    public void callup() {
        System.out.println("华为打电话");
    }

    @Override
    public void sendSMS() {
        System.out.println("华为发信息");
    }
}

//小米手机
public class xiaomiphone implements Iphoneproduct{
    @Override
    public void start() {
        System.out.println("小米开机");
    }

    @Override
    public void shutdown() {
        System.out.println("小米关机");
    }

    @Override
    public void callup() {
        System.out.println("小米打电话");
    }

    @Override
    public void sendSMS() {
        System.out.println("小米发信息");
    }
}
//华为路由器
public class huaweiroute implements Irouteproduct{
    @Override
    public void start() {
        System.out.println("华为路由器开机");
    }

    @Override
    public void shutdown() {
        System.out.println("华为路由器关机");
    }

}
//小米路由器
public class xiaomiroute implements  Irouteproduct{
    @Override
    public void start() {
        System.out.println("小米路由器开机");
    }

    @Override
    public void shutdown() {
        System.out.println("小米路由器关机");
    }

}

//抽象产品工厂
public interface Iproductfactory {

    //生产手机
    Iphoneproduct  Iphoneproduct();

    //生产路由器
    Irouteproduct Irouteproduct();

}

//华为工厂
public class huaweiroute implements Irouteproduct{
    @Override
    public void start() {
        System.out.println("华为路由器开机");
    }

    @Override
    public void shutdown() {
        System.out.println("华为路由器关机");
    }

}

//小米工厂
public class xiaomifactory implements Iproductfactory{
    @Override
    public Iphoneproduct Iphoneproduct() {
        return new xiaomiphone();
    }

    @Override
    public Irouteproduct Irouteproduct() {
        return new xiaomiroute();
    }
}

//客户端
public class Client {
    public static void main(String[] args) {
        System.out.println("====================小米产品====================");
        //小米工厂
        xiaomifactory xiaomifactory = new xiaomifactory();
        Iphoneproduct iphoneproduct = xiaomifactory.Iphoneproduct();
        iphoneproduct.start();
        iphoneproduct.callup();
        iphoneproduct.sendSMS();
        iphoneproduct.shutdown();
        System.out.println("====================华为产品====================");
        //华为工厂
        huaweifactory huaweifactory = new huaweifactory();
        Irouteproduct irouteproduct = huaweifactory.Irouteproduct();
        irouteproduct.start();
        irouteproduct.shutdown();
    }
}

抽象工厂模式将考虑多等级产品的生产，将同一个具体工厂所生产的位于不同等级的一组产品称为一个产品族

抽象工厂模式除了具有工厂方法模式的优点外，其他主要优点如下。

• 可以在类的内部对产品族中相关联的多等级产品共同管理，而不必专门引入多个新的类来进行管理。
• 当需要产品族时，抽象工厂可以保证客户端始终只使用同一个产品的产品组。
• 抽象工厂增强了程序的可扩展性，当增加一个新的产品族时，不需要修改原代码，满足开闭原则。

其缺点是：当产品族中需要增加一个新的产品时，所有的工厂类都需要进行修改。增加了系统的抽象性和理解难度。