## [接口和工廠方法模式](https://lingcoder.gitee.io/onjava8/#/book/10-Interfaces?id=%e6%8e%a5%e5%8f%a3%e5%92%8c%e5%b7%a5%e5%8e%82%e6%96%b9%e6%b3%95%e6%a8%a1%e5%bc%8f) 接口是多實現的途徑，而生成符合某個接口的對象的典型方式是*工廠方法*設計模式。不同于直接調用構造器，只需調用工廠對象中的創建方法就能生成對象的實現——理論上，通過這種方式可以將接口與實現的代碼完全分離，使得可以透明地將某個實現替換為另一個實現。這里是一個展示工廠方法結構的例子： ~~~ // interfaces/Factories.java interface Service { void method1(); void method2(); } interface ServiceFactory { Service getService(); } class Service1 implements Service { Service1() {} // Package access @Override public void method1() { System.out.println("Service1 method1"); } @Override public void method2() { System.out.println("Service1 method2"); } } class Service1Factory implements ServiceFactory { @Override public Service getService() { return new Service1(); } } class Service2 implements Service { Service2() {} // Package access @Override public void method1() { System.out.println("Service2 method1"); } @Override public void method2() { System.out.println("Service2 method2"); } } class Service2Factory implements ServiceFactory { @Override public Service getService() { return new Service2(); } } public class Factories { public static void serviceConsumer(ServiceFactory fact) { Service s = fact.getService(); s.method1(); s.method2(); } public static void main(String[] args) { serviceConsumer(new Service1Factory()); // Services are completely interchangeable: serviceConsumer(new Service2Factory()); } } ~~~ 輸出： ~~~ Service1 method1 Service1 method2 Service2 method1 Service2 method2 ~~~ 如果沒有工廠方法，代碼就必須在某處指定將要創建的**Service**的確切類型，從而調用恰當的構造器。 為什么要添加額外的間接層呢？一個常見的原因是創建框架。假設你正在創建一個游戲系統；例如，在相同的棋盤下國際象棋和西洋跳棋： ~~~ // interfaces/Games.java // A Game framework using Factory Methods interface Game { boolean move(); } interface GameFactory { Game getGame(); } class Checkers implements Game { private int moves = 0; private static final int MOVES = 3; @Override public boolean move() { System.out.println("Checkers move " + moves); return ++moves != MOVES; } } class CheckersFactory implements GameFactory { @Override public Game getGame() { return new Checkers(); } } class Chess implements Game { private int moves = 0; private static final int MOVES = 4; @Override public boolean move() { System.out.println("Chess move " + moves); return ++moves != MOVES; } } class ChessFactory implements GameFactory { @Override public Game getGame() { return new Chess(); } } public class Games { public static void playGame(GameFactory factory) { Game s = factory.getGame(); while (s.move()) { ; } } public static void main(String[] args) { playGame(new CheckersFactory()); playGame(new ChessFactory()); } } ~~~ 輸出： ~~~ Checkers move 0 Checkers move 1 Checkers move 2 Chess move 0 Chess move 1 Chess move 2 Chess move 3 ~~~ 如果類**Games**表示一段很復雜的代碼，那么這種方式意味著你可以在不同類型的游戲里復用這段代碼。你可以再想象一些能夠從這個模式中受益的更加精巧的游戲。 在下一章，你將會看到一種更加優雅的使用匿名內部類的工廠實現方式。