设计模式--工厂模式

这是我参与更文挑战的第1天，活动详情查看： 更文挑战

1.简单工厂模式

工厂模式是常见的java设计模式，用工厂方法来代替new生成一个对象，创建对象时我们不会对使用客户端暴露逻辑，并且通过一个共同的接口来指向要创建的对象。该模式用于封装和管理对象的创建，是一种创建型模式。让其子类去实现工厂接口，确定要创建哪个对象，创建过程让其子类去执行。

比如你需要一部手机，你只要去工厂拿这个手机就可以了，不要要去了解这个手机是怎么造出来的。

创建一个接口

public interface tree {
	void result();
}

创建类去实现这个接口

apple类

public class apple implements tree{
	@Override
	public void result() {
		// TODO Auto-generated method stub
		System.out.println("apple tree result apple");
	}
}

banana类

public class banana implements tree{
	@Override
	public void result() {
		// TODO Auto-generated method stub
		System.out.println("banana tree result banana");
	}
}

cherry类

public class cherry implements tree{
	@Override
	public void result() {
		// TODO Auto-generated method stub
		System.out.println("cherry tree result cherry");
	}
}

classDiagram
tree <|-- apple
tree <|-- banana
tree <|-- cherry
tree: +result()

class apple{
+result()
}
class banana{
+result()
}
class cherry{
+result()
}

创建工厂生成实体类对象

public class treeFactory {
	public tree choseFactoryTree(String treeType) {
		if(treeType.length() <= 0 || treeType.equals("")) {
			return null;
		}
		if(treeType.equalsIgnoreCase("apple")) {
		  return new apple();
		}else if(treeType.equalsIgnoreCase("banana")) {
		  return new banana();
		}else if(treeType.equalsIgnoreCase("cherry")) {
		  return new cherry();
		}
		return null;
	}
}

使用该工厂，通过不同的参数获取不同的水果

public class factoryDemo {
	 public static void main(String[] args) {
             //生成工厂对象
             treeFactory treeFactory1 =  new treeFactory();
             //获取apple的对象
	     tree tree1 = treeFactory1.choseFactoryTree("apple");
             //调用apple的result方法
	     tree1.result();
             //获取banana的对象
	     tree tree2 = treeFactory1.choseFactoryTree("banana");
             //调用banana的result方法
	     tree2.result();
             //获取cherry的对象
	     tree tree3 = treeFactory1.choseFactoryTree("cherry");
             //调用cherry的result方法
	     tree3.result();
	 }
}

graph TD
factoryDemo --> treeFactory
treeFactory --> tree
tree --> appletree -->apple
tree --> bananatree -->banana
tree --> cherrytree -->cherry

运行代码输出结果

apple tree result apple
banana tree result banana
cherry tree result cherry

2.工厂方法模式

与简单工厂相比，工厂方法模式把具体的产品制造做任务分给具体的工厂

tree以及其实现类apple，banana，cherry不变

创建一个抽象工厂，生产不同产品的工厂类

public interface abstractFactory {
	tree getResult();
}

创建生成apple的工厂

public class appleFactory implements abstractFactory{
	@Override
	public tree getResult() {
		// TODO Auto-generated method stub
		return new apple();
	}
}

创建生成banana的工厂

public class bananaFactory implements abstractFactory{
	@Override
	public tree getResult() {
		// TODO Auto-generated method stub
		return new banana();
	}
}

创建生成cherry的工厂

public class cherryFactory implements abstractFactory{
	@Override
	public tree getResult() {
		// TODO Auto-generated method stub
		return new cherry();
	}
}

调用工厂去生产

public class Demo2 {
	 public static void main(String[] args) {
		 abstractFactory appleFactory =  new appleFactory();
		 appleFactory.getResult().result(); 
		 abstractFactory bananaFactory =  new bananaFactory();
		 bananaFactory.getResult().result(); 
		 abstractFactory cherryFactory =  new cherryFactory();
		 cherryFactory.getResult().result();  
	 }
}

输出结果

apple tree result apple
banana tree result banana
cherry tree result cherry

流程图

graph TD
demoClient --> abstractFactory 
abstractFactory --> appleFactory --> appletree -->apple
abstractFactory --> bananaFactory --> bananatree -->banana
abstractFactory --> cherryFactory --> cherrytree -->cherry

3.抽象工厂模式

相比于上边两个设计模式只是获取一个水果，现在我们要获取一种新的产品，抽象工厂模式在在抽向工厂中添加接口，在具体子工厂实现产品的创建。

定义leaf类产品的接口

public interface leaf {
	void makeLeaf();
}

定义appleLeaf产品

public class appleLeaf implements leaf{
	@Override
	public void makeLeaf() {
		// TODO Auto-generated method stub
		System.out.println("apple tree make appleLeft");
	}
}

定义bananaLeaf产品

public class bananaLeaf implements leaf{
	@Override
	public void makeLeaf() {
		// TODO Auto-generated method stub
		System.out.println("banana tree make bananaLeft");
	}
}

定义cherryLeaf产品

public class cherryLeaf implements leaf{
	@Override
	public void makeLeaf() {
		// TODO Auto-generated method stub
		System.out.println("cherry tree make cherryLeft");
	}
}

修改接口abstractFactory接口添加leaf的制造接口

public interface abstractFactory {
	tree getResult();
	leaf getLeaf();
}

修改appleFactory，增加leaf的制造

public class appleFactory implements abstractFactory{
	@Override
	public tree getResult() {
		// TODO Auto-generated method stub
		return new apple();
	}

	@Override
	public leaf getLeaf() {
		// TODO Auto-generated method stub
		return new appleLeaf();
	}
}

修改bananaFactory，增加leaf的制造

public class bananaFactory implements abstractFactory{
	@Override
	public tree getResult() {
		// TODO Auto-generated method stub
		return new banana();
	}

	@Override
	public leaf getLeaf() {
		// TODO Auto-generated method stub
		return new bananaLeaf();
	}
}

修改cherryFactory，增加leaf的制造

public class cherryFactory implements abstractFactory{
	@Override
	public tree getResult() {
		// TODO Auto-generated method stub
		return new cherry();
	}

	@Override
	public leaf getLeaf() {
		// TODO Auto-generated method stub
		return new cherryLeaf();
	}
}

Demo测试

public class Demo3 {
	public static void main(String[] args) {
		 abstractFactory appleFactory =  new appleFactory();
		 appleFactory.getResult().result(); 
		 appleFactory.getLeaf().makeLeaf();
		 abstractFactory bananaFactory =  new bananaFactory();
		 bananaFactory.getResult().result(); 
		 bananaFactory.getLeaf().makeLeaf(); 
		 abstractFactory cherryFactory =  new cherryFactory();
		 cherryFactory.getResult().result();  
		 cherryFactory.getLeaf().makeLeaf();
	 }
}

输出结果

apple tree result apple
apple tree make appleLeft
banana tree result banana
banana tree make bananaLeft
cherry tree result cherry
cherry tree make cherryLeft

流程

graph TD
client --> abstractFactory
abstractFactory --> appleFactory
appleFactory --> getapple -->apple
appleFactory --> makeappleLeaf -->appleLeaf
abstractFactory --> bananaFactory
bananaFactory --> getbanana -->banana
bananaFactory --> makebananaLeaf -->bananaLeaf
abstractFactory --> cherryFactory
cherryFactory --> getcherry -->cherry
cherryFactory --> makecherryLeaf -->cherryLeaf

跟前没有工具，画不了太好看的图。