引出工厂模式

package www.java.test;interface Computer{void printComputer();
}
class MacbookPro implements Computer{@Overridepublic void printComputer() {System.out.println("This is a MacbookPro");}
}
class SurfaceBook implements Computer{@Overridepublic void printComputer() {System.out.println("This is a Surfacebook");}
}
public class Test{//客户端public static void main(String[] args) {Computer computer = new MacbookPro();//子类为接口进行实例化处理computer.printComputer();}
}

如果我想买另外一款电脑，我就需要改变客户端的代码了，这就很麻烦了，所以我们就要想办法将实例化具体类的代码从客户端抽离（解耦到第三方），这时就需要用到工厂模式了。

简单工厂模式：用于没有产品族并且产品数量较少
专门定义一个类（第三方）用来创建其他类实例（解耦，将客户端创建对象的操作解耦到外部第三方类），被创建的实例通常都具有共同的父类。

package www.java.test;import java.util.Scanner;interface Computer{void printComputer();
}
class MacbookPro implements Computer{@Overridepublic void printComputer() {System.out.println("This is a MacbookPro");}
}
class SurfaceBook implements Computer{@Overridepublic void printComputer() {System.out.println("This is a Surfacebook");}
}
//第三方工厂类
class ComputerFactory{public static Computer getInstance(String type){if(type.equals("mac")){return new MacbookPro();}else if(type.equals("surface")){return new SurfaceBook();}return null;}
}
public class Test{//客户端public static void main(String[] args) {Scanner scanner = new Scanner(System.in);System.out.println("请输入你想要的电脑型号：");String type = scanner.nextLine();Computer computer = ComputerFactory.getInstance(type);computer.printComputer();}
}

假如现在我需要一个新型号的电脑，用了工厂设计模式之后，主方法是不需要改变的，只需要在工厂类中加一条分支就行（对应于我们现实生活中的工厂，也就是加一条生产线）。

package www.java.test;import java.util.Scanner;interface Computer{void printComputer();
}
class MacbookPro implements Computer{@Overridepublic void printComputer() {System.out.println("This is a MacbookPro");}
}
class SurfaceBook implements Computer{@Overridepublic void printComputer() {System.out.println("This is a Surfacebook");}
}
class AlienWare implements Computer{@Overridepublic void printComputer() {System.out.println("This is a AlienWare");}
}
//第三方工厂类
class ComputerFactory{public static Computer getInstance(String type){if(type.equals("mac")){return new MacbookPro();}else if(type.equals("surface")){return new SurfaceBook();}else if(type.equals("alienware")){return new AlienWare();}return null;}
}
public class Test{//客户端public static void main(String[] args) {Scanner scanner = new Scanner(System.in);System.out.println("请输入你想要的电脑型号：");String type = scanner.nextLine();Computer computer = ComputerFactory.getInstance(type);computer.printComputer();}
}

工厂方法模式----对应的是产品族
定义一个用来创建对象的接口，让子类决定实例化哪一个工厂。
我们需要加一个工厂接口，让不同的工厂类来实现这个接口。

package www.java.test;import java.util.Scanner;interface Computer{void printComputer();
}
class MacbookPro implements Computer{@Overridepublic void printComputer() {System.out.println("This is a MacbookPro");}
}
class SurfaceBook implements Computer{@Overridepublic void printComputer() {System.out.println("This is a Surfacebook");}
}
class AlienWare implements Computer{@Overridepublic void printComputer() {System.out.println("This is a AlienWare");}
}
interface ComputerFactory{Computer createCoputer();
}
class SurfaceFactory implements ComputerFactory{@Overridepublic Computer createCoputer() {return new SurfaceBook();}
}
class AppleFactory implements ComputerFactory{@Overridepublic Computer createCoputer() {return new MacbookPro();}
}
public class Test{//客户端public static void main(String[] args) {//假如我们现在需要苹果的产品//先拿到苹果的工厂ComputerFactory computerFactory = new AppleFactory();Computer computer = computerFactory.createCoputer();computer.printComputer();}
}

它与简单工厂的区别就在于多了一个抽象的工厂，多了很多具体工厂，以前是所有产品都在一个工厂中生产，而现在是不同产品在不同的工厂中生产。

还有一个升级的工厂模式：
抽象工厂—多个产品线混合
特点：提供一个创建一系列相关或相互依赖对象的接口（抽象工厂，多条产品线），而无需指定它们具体的类。