Java设计模式-工厂模式

工厂模式分类：

1. 简单工厂模式(静态工厂模式)

2. 工厂方法

3. 抽象工厂模式

 

1. 

/**
 * @author huzhongkang
 * @Title: ${file_name}
 * @date 2020/6/113:49
 */
public interface Car {

    void run();
}


public class Benz implements Car {
    @Override
    public void run() {
        System.out.println("奔驰 run...");
    }
}
    

public class Byd implements Car{
    @Override
    public void run() {
        System.out.println("byd run.....");
    }
}


//简单工厂方法，静态工厂方法， 这种工厂方法如果有新增产品则需要在工厂方法中修改代码。
public class SimpleFactory {

    Car getCar(String type){
        switch (type){
            case "byd" :
                return new Byd();
            case "benz" :
                return new Benz();
           default:
               return null;
        }
    }

    public static void main(String[] args) {

        SimpleFactory simpleFactory = new SimpleFactory();
        Car byd = simpleFactory.getCar("byd");
        byd.run();
    }
}

2.

public interface Car {

    void run();
}

public class Audi implements Car {
    @Override
    public void run() {
        System.out.println("audi run....");
    }
}

public class FengTian implements Car {
    @Override
    public void run() {
        System.out.println("fengtian run...");
    }
}

public class AudiFactory implements FactoryMethod {
    @Override
    public Car makeCar() {
        return new Audi();
    }
}

public class FengtianFactory implements FactoryMethod {
    @Override
    public Car makeCar() {
        return new FengTian();
    }
}

public interface FactoryMethod {

    Car makeCar();
}


/*
* 这种工厂方法，比简单工厂方法比较好的一点是  如果有新的产品加进来 不需要在原先的代码中添加， 不要修改代码
* 但是新产品需要添加新的工厂方法 生产对应产品即可。
* */
public class Test {


    public static void main(String[] args) {
        Car car = new FengtianFactory().makeCar();
        car.run();

    }
}

 

3. 静态工厂模式

//程序员和司机都要吃饭， 抽象一个实物的抽象类
public abstract class Food {

    abstract void eatFood();
}

//程序员和司机都有工作， 抽象一个统一接口
public interface Work {

    void gotoWork();
}


//泡面继承自食物
public class Paomian extends Food {
    @Override
    void eatFood() {
        System.out.println("泡面。。。。");
    }
}
//米饭继承食物
public class Rice extends Food {
    @Override
    void eatFood() {
        System.out.println("吃米饭。。。");
    }
}

//开车继承工作
public class Driver implements Work {
    @Override
    public void gotoWork() {
        System.out.println("我要去开车...我是司机");
    }
}
//it继承自工作
public class IT implements Work {
    @Override
    public void gotoWork() {
        System.out.println("我在写代码...这是我的工作");
    }
}

//抽象一个生产对象的工厂
public abstract class AbstractFactory {

    abstract Food getFood();

    abstract Work getWork();
}


//生产司机的工厂
public class DriverFactory extends AbstractFactory {
    @Override
    Food getFood() {
        return new Rice();
    }

    @Override
    Work getWork() {
        return new Driver();
    }
}


//生产it的工厂
public class ITFactory extends AbstractFactory {
    @Override
    Food getFood() {
        return new Paomian();
    }

    @Override
    Work getWork() {
        return new IT();
    }
}

//这种抽象工厂方法可以生产一个产品族 
public class Test {
    public static void main(String[] args) {

        AbstractFactory driverFactory = new ITFactory();
        driverFactory.getFood().eatFood();
        driverFactory.getWork().gotoWork();



    }
}