工厂模式（Factory Pattern）的意义就跟它的名字一样，在面向对象程序设计中，工厂通常是一个用来创建其他对象的对象。工厂模式根据不同的参数来实现不同的分配方案和创建对象。
在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。例如用工厂来创建 人 这个对象，如果我们需要一个男人对象，工厂就会为我们创建一个男人；如果我们需要一个女人，工厂就会为我们生产一个女人。
普通工厂模式
多个工厂方法模式
静态工厂方法模式
/*
*工厂模式： 在创建对象时不会对客户端暴露创建裸机，而是通过使用一个共同的接口来指向
*新创建的对象。
* 普通工厂模式：
* 多个工厂方法模式：普通工厂模式中，如果传递的字符串出错，则不能正确创建对象，多个宫广场方法模式是
* 提供多个工厂方法，分别创建对象
* 静态工厂方法模式：将多个催工厂方法模式里的方法设置为静态的，则测试或是使用时不需要创建实例，可以直接调用
*/
interface Person{//两个类的共同接口
public void eat();
public void sleep();
public void beat();
}
class Female implements Person{
public void eat(){
System.out.println("Female can eat");
}
public void sleep(){
System.out.println("Female can sleep");
}
public void beat(){
System.out.println("Female can beat");
}
}
class Male implements Person{
public void eat(){
System.out.println("Male can eat");
}
public void sleep(){
System.out.println("Male can sleep");
}
public void beat(){
System.out.println("Male can beat");
}
}
// class HumanFactory{//创建普通工厂类
// public Person createHuman(String gender){
// if(gender.equals("male")){
// return new Male();
// }else if(gender.equals("female")){
// return new Female();
// }else {
// System.out.println("请输入正确的类型：");
// return null;
// }
// }
//}
//
//public class Main {//普通工厂测试类
// public static void main(String[] args){
// HumanFactory factory=new HumanFactory();
// Person male=factory.createHuman("male");
// male.eat();
// male.sleep();
// male.beat();
// }
//}
/*
* 测试结果：
* Male can eat
Male can sleep
Male can beat
*/
// class HumanFactory{//创建多个工厂方法
// public Male createMale(){
// return new Male();
// }
// public Female createFemale(){
// return new Female();
// }
// }
// public class Main{//多个工厂方法测试类
// public static void main(String args[]){
// HumanFactory factory = new HumanFactory();
// Person male= factory.createMale();
// male.eat();
// male.sleep();
// male.beat();
// }
// }
// /*
// * 测试结果：
// * Male can eat
// Male can sleep
// Male can beat
// */
class HumanFactory{//静态工厂方法
public static Male createMale(){
return new Male();
}
public static Female createFemale(){
return new Female();
}
}
public class Main{//静态工厂方法模式测试
public static void main(String args[]){
Person male=HumanFactory.createMale();
male.eat();
male.sleep();
male.beat();
}
}
/*
* 测试结果：
* Male can eat
Male can sleep
Male can beat
*/
/*
* 抽象工厂模式：
* 工厂方法模式有一个问题就是，类的创建依赖工厂类，也就是说，如果想要拓展程序，
* 必须对工厂类进行修改，这违背了闭包原则，所以，从设计角度考虑，有一定的问题，
* 如何解决？就用到抽象工厂模式，创建多个工厂类，这样一旦需要增加新的功能，
* 直接增加新的工厂类就可以了，不需要修改之前的代码。
*/
interface Sender{
public void Send();
}
class MailSender implements Sender{
@Override
public void Send() {
// TODO Auto-generated method stub
System.out.println("It's a mailSender!");
}
}
class SmsSender implements Sender{
@Override
public void Send() {
// TODO Auto-generated method stub
System.out.println("It's a SmsSender");
}
}
interface Provider{
public Sender produce();
}
class SendMailFactory implements Provider{
@Override
public Sender produce() {
// TODO Auto-generated method stub
return new MailSender();
}
}
class SendSmsFactory implements Provider{
@Override
public Sender produce() {
// TODO Auto-generated method stub
return new SmsSender();
}
}
public class Main {
public static void main(String args[]){
Provider provider = new SendMailFactory();
Sender sender = provider.produce();
sender.Send();
}
}
/*
* 测试结果：It's a mailSender!
*/
Reference: https://blog.****.net/doymm2008/article/details/13288067