单例模式

public class Singleton {
    private static final Singleton singleton = new Singleton();
    /**
     * 限制外部调用构造方法，生成多个对象实例
     */
    private Singleton() {}
    
    public static Singleton getInstance() {
        return singleton;
    }
}

工厂方法

public interface Human {
    String getColor();
    void talk();
}

class YellowHuman implements Human {
    @Override
    public String getColor() {
        return "黄种人";
    }

    @Override
    public void talk() {
        System.out.println("说汉语");
    }
}

class WhiteHuman implements Human {
    @Override
    public String getColor() {
        return "白种人";
    }

    @Override
    public void talk() {
        System.out.println("说英语");
    }
}

public class HumanFactory {
    public static <T extends Human> T createHuman(Class<T> clazz) {
        T instance = null;
        try {
            instance = (T) Class.forName(clazz.getName()).newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return instance;
    }
}

抽象工厂方法

public interface Human {
    String getColor();
    void talk();
    String getSex();
}

abstract class AbstractYellowHuman implements Human {
    @Override
    public String getColor() {
        return "黄种人";
    }

    @Override
    public void talk() {
        System.out.println("说汉语");
    }
}

class FemaleYellowHuman extends AbstractYellowHuman {
    @Override
    public String getSex() {
        return "女性黄种人";
    }
}

class MaleYellowHuman extends AbstractYellowHuman {
    @Override
    public String getSex() {
        return "男性黄种人";
    }
}

abstract class AbstractWhiteHuman implements Human {
    @Override
    public String getColor() {
        return "白种人";
    }

    @Override
    public void talk() {
        System.out.println("说英语");
    }
}

class FemaleWhiteHuman extends AbstractYellowHuman {
    @Override
    public String getSex() {
        return "女性白种人";
    }
}

class MaleWhiteHuman extends AbstractYellowHuman {
    @Override
    public String getSex() {
        return "男性白种人";
    }
}

public interface HumanFactory {
    Human createYellowHuman();
    Human createWhiteHuman();
}

class FemaleFactory implements HumanFactory {

    @Override
    public Human createYellowHuman() {
        return new FemaleYellowHuman();
    }

    @Override
    public Human createWhiteHuman() {
        return new FemaleWhiteHuman();
    }
}

class MaleFactory implements HumanFactory {

    @Override
    public Human createYellowHuman() {
        return new MaleYellowHuman(); }

    @Override
    public Human createWhiteHuman() {
        return new MaleWhiteHuman();
    }
}

模板方法

public abstract class HummerModel {
    // 启动
    public abstract void start();
    // 停止
    public abstract void stop();
    // 按喇叭
    public abstract void alarm();
    // 引擎轰鸣
    public abstract void engineBoom();

    public void run() {
        start();
        alarm();
        engineBoom();
        stop();
    }
}

public class HummerH1Model extends HummerModel{
    @Override
    public void start() {
        System.out.println("悍马h1 启动了");
    }

    @Override
    public void stop() {
        System.out.println("悍马h1 停止了");
    }

    @Override
    public void alarm() {
        System.out.println("悍马h1 喇叭想了");
    }

    @Override
    public void engineBoom() {
        System.out.println("悍马h1 引擎在轰鸣");
    }
}

public class HummerH2Model extends HummerModel{
    @Override
    public void start() {
        System.out.println("悍马h2 启动了");
    }

    @Override
    public void stop() {
        System.out.println("悍马h2 停止了");
    }

    @Override
    public void alarm() {
        System.out.println("悍马h2 喇叭想了");
    }

    @Override
    public void engineBoom() {
        System.out.println("悍马h2 引擎在轰鸣");
    }
}

建造者模式

public abstract class CarModel {
    // 这个字段定义了各方法的执行顺序
    public List<String> sequence = new ArrayList<>();

    protected abstract void start();
    protected abstract void stop();
    protected abstract void alarm();
    protected abstract void engineBoom();

    final void run() {
        sequence.forEach(type -> {
            switch (type) {
                case "start":
                    start();
                    break;
                case "stop":
                    stop();
                    break;
                case "alarm":
                    alarm();
                    break;
                case "engineBoom":
                    engineBoom();
                    break;
                default:
                    break;
            }
        });
    }

    public void setSequence(List<String> sequence)  {
        this.sequence = sequence;
    }
}

class BMWModel extends CarModel {
    @Override
    protected void start() {
        System.out.println("宝马启动了");
    }

    @Override
    protected void stop() {
        System.out.println("宝马停止了");
    }

    @Override
    protected void alarm() {
        System.out.println("宝马按喇叭了");
    }

    @Override
    protected void engineBoom() {
        System.out.println("宝马引擎开始轰鸣了");
    }
}

class BenzModel extends CarModel {
    @Override
    protected void start() {
        System.out.println("奔驰启动了");
    }

    @Override
    protected void stop() {
        System.out.println("奔驰停止了");
    }

    @Override
    protected void alarm() {
        System.out.println("奔驰按喇叭了");
    }

    @Override
    protected void engineBoom() {
        System.out.println("奔驰引擎开始轰鸣了");
    }
}

abstract class CarBuilder {
   public abstract void setSequence(List<String> sequence);
   public abstract CarModel getCarModel();
}

class BMWBuilder extends CarBuilder {
    BMWModel bmw = new BMWModel();

    @Override
    public void setSequence(List<String> sequence) {
        this.bmw.setSequence(sequence);
    }

    @Override
    public CarModel getCarModel() {
        return bmw;
    }
}

class BenzBuilder extends CarBuilder {
    BenzModel benz = new BenzModel();

    @Override
    public void setSequence(List<String> sequence) {
        this.benz.setSequence(sequence);
    }

    @Override
    public CarModel getCarModel() {
        return benz;
    }
}

public class Test {
    public static void main(String[] args) {
        BMWBuilder bmwBuilder = new BMWBuilder();
        bmwBuilder.setSequence(Arrays.asList("start", "stop", "engineBoom"));

        CarModel bmw = bmwBuilder.getCarModel();
        bmw.run();

        BenzBuilder benzBuilder = new BenzBuilder();
        benzBuilder.setSequence(Arrays.asList("start", "engineBoom", "alarm"));

        CarModel benz = benzBuilder.getCarModel();
        benz.run();
    }
}

代理模式

/**
 * 游戏玩家
 */
public interface IGamePlayer {
    // 登录
    void login(String username, String password);

    // 杀怪
    void killBoss();

    // 升级
    void upgrade();
}

class GamePlayer implements IGamePlayer {
    private String username;

    public GamePlayer(String username) {
        this.username = username;
    }

    @Override
    public void login(String username, String password) {
        System.out.println(username + "登录游戏...");
    }

    @Override
    public void killBoss() {
        System.out.println(username + "杀怪成功...");
    }

    @Override
    public void upgrade() {
        System.out.println(username + "升级成功...");
    }
}

/**
 * 代练
 */
class GamePlayerProxy implements IGamePlayer {
    private IGamePlayer gamePlayer = null;

    public GamePlayerProxy(String username) {
        this.gamePlayer = new GamePlayer(username);
    }

    @Override
    public void login(String username, String password) {
        this.gamePlayer.login(username, password);
        System.out.println("代练 登录成功");
    }

    @Override
    public void killBoss() {
        this.gamePlayer.killBoss();
        System.out.println("代练 开始杀怪");
    }

    @Override
    public void upgrade() {
        this.gamePlayer.upgrade();
    }
}

public class Test {
    public static void main(String[] args) {
        GamePlayerProxy gamePlayerProxy = new GamePlayerProxy("张三");

        gamePlayerProxy.login("张三", "123456");
        gamePlayerProxy.killBoss();
        gamePlayerProxy.upgrade();
    }
}