通过对简单工厂,工厂方法,抽象工厂模式的学习之后,三种模式的详细了解
使用Java对其进行了简单的实现。
简单工厂
手机基类
public abstract class AbstractPhone {
public abstract void call();
}
手机产品类
public class Oppo extends AbstractPhone{
@Override
public void call() {
System.out.println("Oppo 正在为你接通");
}
}
手机工厂
public class PhoneFactory {
public AbstractPhone crate(String phoneType){
if ("oppo".equals(phoneType)){
return new Oppo();
}
return null;
}
}
生产手机,并调用其实例方法
public class SimpleFactory {
public static void main(String[] args) {
new PhoneFactory().crate("oppo").call();
}
}
实现效果
Oppo 正在为你接通
工厂方法模式
抽象工厂类
public abstract class AbstractFactory {
//生产
public abstract AbstractProduct create();
}
抽象产品类
public abstract class AbstractProduct {
//产品使用
public abstract void use();
}
Car产品类
public class CarProduct extends AbstractProduct{
@Override
public void use() {
System.out.println("奥迪A6生产完成");
}
}
Car生产类
public class CarFactory extends AbstractFactory{
@Override
public AbstractProduct create() {
return new CarProduct();
}
}
Zoom产品类
public class ZoomProduct extends AbstractProduct{
@Override
public void use() {
System.out.println("zoom 生产完成");
}
}
Zoom工厂类
public class ZoomFactory extends AbstractFactory{
@Override
public AbstractProduct create() {
return new ZoomProduct();
}
}
生产代码
public class FactoryMethod {
public static void main(String[] args) {
CarFactory carFactory = new CarFactory();
carFactory.create().use();
ZoomFactory zoomFactory = new ZoomFactory();
zoomFactory.create().use();
}
}
实现效果
奥迪A6生产完成
zoom 生产完成
抽象工厂模式
创建手机,电脑与工厂枚举
public enum PhoneEnum {
IPHONE,OPPO
}
public enum PhoneEnum {
IPHONE,OPPO
}
public enum FactoryEnum {
COMPUTER, PHONE
}
抽象工厂
public abstract class AbstractFactory {
public abstract IPhone getPhone(PhoneEnum phoneType);
public abstract IComputer getComputer(ComputerEnum computerType);
}
电脑工厂实现
public class ComputerFactory extends AbstractFactory{
@Override
public IPhone getPhone(PhoneEnum phoneType) {
return null;
}
@Override
public IComputer getComputer(ComputerEnum computerType) {
switch (computerType){
case HUAWEI:
return new HuaweiProductImpl();
case MACBOOK:
return new MacbookProductImpl();
}
return null;
}
}
手机工厂实现
public class PhoneFactory extends AbstractFactory {
@Override
public IPhone getPhone(PhoneEnum phoneType) {
switch (phoneType) {
case OPPO:
return new OppoPhoneImpl();
case IPHONE:
return new IphonePhoneImpl();
}
return null;
}
@Override
public IComputer getComputer(ComputerEnum computerType) {
return null;
}
}
获得具体生产工厂
public class ProducerFactory {
public AbstractFactory getFactory(FactoryEnum factoryName) {
switch (factoryName) {
case PHONE:
return new PhoneFactory();
case COMPUTER:
return new ComputerFactory();
}
return null;
}
}
手机接口
public interface IPhone {
void call();
}
手机接口具体实现
public class OppoPhoneImpl implements IPhone{
@Override
public void call() {
System.out.println("oppo 手机为你拨通电话");
}
}
public class IphonePhoneImpl implements IPhone{
@Override
public void call() {
System.out.println("iphone 已为你拨通电话");
}
}
电脑接口
public interface IComputer{
void use();
}
电脑接口具体实现
public class MacbookProductImpl implements IComputer {
@Override
public void use() {
System.out.println("你正在使用的电脑是MacBook");
}
}
public class HuaweiProductImpl implements IComputer{
@Override
public void use() {
System.out.println("你正在使用的是huawei");
}
}
生产产品
public class AbstractFactoryMethod {
public static void main(String[] args) {
ProducerFactory producerFactory = new ProducerFactory();
AbstractFactory phoneFactory = producerFactory.getFactory(FactoryEnum.PHONE);
phoneFactory.getPhone(PhoneEnum.IPHONE).call();
producerFactory.getFactory(FactoryEnum.COMPUTER).getComputer(ComputerEnum.MACBOOK).use();
}
}
实现效果
iphone 已为你拨通电话
你正在使用的电脑是MacBook
以上便是对简单工厂,工厂方法,抽象工厂的简单实现。