设计模式一——工厂模式

简单工厂模式

简单实现

Player

public interface Player {

    /**
     * 训练
     */
    public void practicing();
}

BasketballPlayer

import com.xxx.Player;

public class BasketballPlayer implements Player {

    @Override
    public void practicing() {
        System.out.println("篮球队开始训练...");
    }
}

FootballPlayer

import com.xxx.Player;

public class FootballPlayer implements Player {
    @Override
    public void practicing() {
        System.out.println("足球队开始训练...");
    }
}

工厂类PlayerFactory

import com.xxx.BasketballPlayer;
import com.xxx.FootballPlayer;

public class PlayerFactory {

    public Player create(String type){
        if("basketball".equals(type)){
            return new BasketballPlayer();
        }else if ("football".equals(type)){
            return new FootballPlayer();
        }else {
            return null;
        }
    }
}

为方便调用，可以将create方法写为静态方法

Client

public class Client {
    public static void main(String[] args) {
        PlayerFactory factory = new PlayerFactory();
        Player player = factory.create("football");
        player.practicing();
    }
}

优化

工厂类PlayerFactory

public class PlayerFactory {

    public static Player create(Class<? extends Player> clazz){
        try{
            if(clazz != null){
                return clazz.newInstance();
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        return null;
    }
}

Client

public class Client {
    public static void main(String[] args) {
        Player player = PlayerFactory.create(BasketballPlayer.class);
        if(player != null){
            player.practicing();
        }
    }
}

缺点

工厂类的职责相对过重，不易于扩展过于复杂的产品结构

工厂方法模式

工厂方法接口PlayerFactory

public interface PlayerFactory {
    Player create();
}

工厂方法BasketballPlayerFactory

import com.xxx.Player;
import com.xxx.PlayerFactory;

public class BasketballPlayerFactory implements PlayerFactory {
    @Override
    public Player create() {
        return new BasketballPlayer();
    }
}

工厂方法FootballPlayerFactory

import com.xxx.Player;
import com.xxx.PlayerFactory;

public class FootballPlayerFactory implements PlayerFactory {
    @Override
    public Player create() {
        return new FootballPlayer();
    }
}

client

import com.xxx.BasketballPlayerFactory;
import com.xxx.FootballPlayerFactory;

public class Client {
    public static void main(String[] args) {
       PlayerFactory factory1 = new BasketballPlayerFactory();
       factory1.create();
       PlayerFactory factory2 = new FootballPlayerFactory();
       factory2.create();
    }
}

适用场景

• 创建对象需要大量重复的代码
• 应用层不依赖于产品类实例如何被创建、如何被实现等细节
• 一个类通过其子类来指定创建哪个对象

缺点

• 类的个数容易过多，增加复杂度
• 增加了系统的抽象性和理解难度

抽象工厂模式

训练接口

public interface ITrain {
    /**
     * 训练
     */
    void practicing();
}

篮球训练接口实现

public class BasketballTrain implements ITrain {
    @Override
    public void practicing() {
        System.out.println("篮球训练...");
    }
}

足球训练接口实现

public class FootballTrain implements ITrain {
    @Override
    public void practicing() {
        System.out.println("足球训练...");
    }
}

休息接口

public interface IRest {
    /**
     * 休息
     */
    void rest();
}

篮球运动休息接口实现

public class BasketballRest implements IRest {
    @Override
    public void rest() {
        System.out.println("篮球休息恢复...");
    }
}

足球运动休息接口实现

public class FooballRest implements IRest {
    @Override
    public void rest() {
        System.out.println("足球休息恢复...");
    }
}

运动员日程计划工厂类

public abstract class PlayerPlanFactoty {
    abstract IRest createRestPlan();
    abstract ITrain createTrainPlan();
}

篮球运动员日程计划工厂类

public class BasketBallPlayerPlanFactory extends PlayerPlanFactoty{
    @Override
    IRest createRestPlan() {
        return new BasketballRest();
    }

    @Override
    ITrain createTrainPlan() {
        return new BasketballTrain();
    }
}

足球运动员日程计划工厂类

public class FootballPlayerPlanFactory extends PlayerPlanFactoty{
    @Override
    IRest createRestPlan() {
        return new FooballRest();
    }

    @Override
    ITrain createTrainPlan() {
        return new FootballTrain();
    }
}

client

public class Client {
    public static void main(String[] args) {
        BasketBallPlayerPlanFactory factory1 = new BasketBallPlayerPlanFactory();
        factory1.createTrainPlan().practicing();
        factory1.createRestPlan().rest();

        FootballPlayerPlanFactory factory2 = new FootballPlayerPlanFactory();
        factory2.createTrainPlan().practicing();
        factory2.createRestPlan().rest();
    }
}

优点

清晰的展示了对象之间的族级关系及等级关系

缺点

• 不易于扩展
• 不易于理解