01设计模式--工厂模式

整体的代码量展示:

简单工厂模式

定义基本的电脑类

public interface Computer {
    void Create();
}

分别定义两个电脑品牌类实现基础电脑类

AcerComputer:

public class AcerComputer implements Computer {
    public AcerComputer() {
        this.Create();
    }
    @Override
    public void Create() {
        System.out.println("宏碁电脑");
    }
}

XiaoMiComputer:

public class XiaoMiComputer implements  Computer {
    public XiaoMiComputer() {
        this.Create();
    }
    @Override
    public void Create() {
        System.out.println("小米电脑");
    }
}

定义一个工厂类，里面用一个方法接收不同的参数来创建不同的电脑

ComputerFactory：

public class ComputerFactory {

    public Computer makeComputer(String mType){
        if("XiaoMi".equalsIgnoreCase(mType)){
            System.out.println("小米工厂");
         return new XiaoMiComputer();
        }else if ("Acer".equalsIgnoreCase(mType)){
            System.out.println("宏碁工厂");
            return new AcerComputer();
        }else{
            System.out.println("其他工厂");
            return null;
        }
    }
}

进行测试

RunComputer：

public class RunComputer {
    public static void main(String[] args) {
        ComputerFactory RunComputer = new ComputerFactory();
        RunComputer.makeComputer("XiaoMi");
        RunComputer.makeComputer("Acer");
    }
}

测试结果

工厂方法模式

在原有的代码Computer类及实现类AcerComputer，XiaoMiComputer上，接着新加代码

再创建一个工厂类AbstractFactory

public interface AbstractFactory {
    Computer makeComputer();
}

创建两个子类实现此工厂类

AcerFactory：

public class AcerFactory  implements  AbstractFactory {

    @Override
    public Computer makeComputer() {
        return new AcerComputer();
    }
}

XiaoMiFactory：

public class XiaoMiFactory implements  AbstractFactory {
    @Override
    public Computer makeComputer() {
        return new XiaoMiComputer();
    }
}

进行测试

public class RunComputer {
    public static void main(String[] args) {
        AbstractFactory a = new XiaoMiFactory();
        AbstractFactory b = new AcerFactory();
        a.makeComputer();
        b.makeComputer();
    }

}

测试结果

抽象工厂模式

在上面的工厂方法模式中，新增代码

新增一个球类

Ball：

public interface Ball {
    void createBall();
}

创建两个球的实现类

AcerBall：

public class AcerBall implements Ball {
   public AcerBall(){
        this.createBall();
    }
    @Override
    public void createBall() {
        System.out.println("宏碁生成球");
    }
}

XiaoMiBall:

public class XiaoMiBall implements  Ball {
    public XiaoMiBall(){
        this.createBall();
    }
    @Override
    public void createBall() {
        System.out.println("小米生成球");
    }
}

在原有类中增加新方法：
AbstractFactory:

public interface AbstractFactory {
    Computer makeComputer();
    Ball makeBall();
}

AcerFactory:

public class AcerFactory implements  AbstractFactory {

    @Override
    public Computer makeComputer() {
        return new AcerComputer();
    }

    @Override
    public Ball makeBall() {
        return new AcerBall();
    }
}

XiaoMiFactory:

public class XiaoMiFactory implements  AbstractFactory {
    @Override
    public Computer makeComputer() {
        return new XiaoMiComputer();
    }

    @Override
    public Ball makeBall() {
        return new XiaoMiBall();
    }
}

进行测试

RunComputer:

public class RunComputer {
    public static void main(String[] args) {
        AbstractFactory a = new XiaoMiFactory();
        AbstractFactory b = new AcerFactory();
        a.makeComputer();
        b.makeComputer();
        a.makeBall();
        b.makeBall();
    }
}

测试结果