2025年创建型——工厂系列(Factory)day04

创建型——工厂系列(Factory)day04任何可以产生对象的方法或类 都可以称为工厂 单例也是一种工厂 为什么有了 new 以后 还要有工厂 1 灵活控制生产过程 2 权限 修饰 日志 接口模式 package cn xhl interfacemod public interface IFruit public void plant

大家好,我是讯享网,很高兴认识大家。
  • 任何可以产生对象的方法或类,都可以称为工厂
  • 单例也是一种工厂
  • 为什么有了new以后,还要有工厂?
    1、灵活控制生产过程
    2、权限、修饰、日志……

接口模式

在这里插入图片描述
讯享网

package cn.xhl.interfacemodel; public interface IFruit { 
    public void plant(); public void harvest(); public void grow(); } 

讯享网
讯享网package cn.xhl.interfacemodel; public class Apple implements IFruit { 
    int treeAge = 5; public void plant() { 
    // TODO Auto-generated method stub log("苹果种植ֲ"); } public void harvest() { 
    // TODO Auto-generated method stub log("苹果收获"); } public void grow() { 
    // TODO Auto-generated method stub log("苹果增长"); } public static void log(String msg) { 
    System.out.println(msg); } } 
package cn.xhl.interfacemodel; public class Grape implements IFruit { 
    boolean seedful=false; public void plant() { 
    // TODO Auto-generated method stub log("葡萄种植ֲ"); } public void harvest() { 
    // TODO Auto-generated method stub log("葡萄收获"); } public void grow() { 
    // TODO Auto-generated method stub log("葡萄生长"); } public static void log(String msg) { 
    System.out.println(msg); } } 
讯享网package cn.xhl.interfacemodel; public class Strawberry implements IFruit { 
    public void plant() { 
    // TODO Auto-generated method stub log("草莓种植"); } public void harvest() { 
    // TODO Auto-generated method stub log("草莓收获"); } public void grow() { 
    // TODO Auto-generated method stub log("草莓生长"); } public static void log(String msg) { 
    System.out.println(msg); } } 
package cn.xhl.interfacemodel; public class Client1 { 
    public static void main(String[] args) { 
    // TODO Auto-generated method stub IFruit[] fruits = { 
   new Grape(),new Strawberry(),new Apple()}; for(IFruit fruit : fruits) { 
    fruit .plant(); fruit.grow(); fruit .harvest(); } } } 

简单工厂模式

在这里插入图片描述
一般情况下我们可以用一个FruitFactory去创建不同的Fruit

讯享网public class FruitFactory{ 
    public IFruit creatApple(){ 
    //进行一些前置操作,例如设置权限、进行修饰、打印日志…… return new Apple(); } public IFruit creatGrape(){ 
   return new Grape();} public IFruit creatStrawberry(){ 
   return new Strawberry();} } 

但是这不符合开闭原则,每次新增一个品种的IFruit都需要对Factory进行改动。

我们可以对简单工厂模式进行改进,让它符合开闭原则。

package cn.xhl.simpleFactory; public class FruitGardent { 
    public static IFruit factory(String which) throws InstantiationException, IllegalAccessException, ClassNotFoundException { 
    IFruit fruit = null; String pn = FruitGardent.class.getPackage().getName(); StringBuilder sb = new StringBuilder(); sb.append(pn); sb.append("."); sb.append(Character.toUpperCase(which.charAt(0))); sb.append(which.substring(1).toLowerCase()); fruit = (IFruit) Class.forName(sb.toString()).newInstance(); return fruit; } } 
讯享网package cn.xhl.simpleFactory; public class Client1 { 
    public static void main(String[] args) { 
    // TODO Auto-generated method stub String[] strs = { 
   "grape","apple","strawberry"}; for(String str : strs) { 
    IFruit fruit; try { 
    fruit = FruitGardent.factory(str); fruit.plant(); fruit.harvest(); } catch (InstantiationException e) { 
    // TODO Auto-generated catch block e.printStackTrace(); } catch (IllegalAccessException e) { 
    // TODO Auto-generated catch block e.printStackTrace(); } catch (ClassNotFoundException e) { 
    // TODO Auto-generated catch block e.printStackTrace(); } } } } 

但是这有产生了新的问题,如果对不同的产品对应需要给到不同的权限,也就是在new之前需要进行一些前置操作,且不同的IFruit操作不一样,这样就需要在前面加上判断的语句,判断这是什么IFruit,再进行一些权限设置,最后再创建对象,但这又不符合开闭原则了。

于是我们可以对每一个产品,也就是每一个IFruit都用一个Factory,这样就引出了工厂方法模式。

工厂方法模式

工厂方法方便产品的扩展
在这里插入图片描述

package factory1; public class Client1 { 
    public static void main(String[] args) { 
    // TODO Auto-generated method stub String[] strs = { 
   "ConcreateCreator1","ConcreateCreator2"}; for (String str : strs) { 
    try { 
    Creator creator = CreatFactory.factory(str); creator.factory().show(); } catch (InstantiationException e) { 
    // TODO Auto-generated catch block e.printStackTrace(); } catch (IllegalAccessException e) { 
    // TODO Auto-generated catch block e.printStackTrace(); } catch (ClassNotFoundException e) { 
    // TODO Auto-generated catch block e.printStackTrace(); } } } 
讯享网package factory1; public class CreatFactory { 
    public static Creator factory(String which) throws InstantiationException, IllegalAccessException, ClassNotFoundException { 
    Creator creator = null; StringBuilder sb = new StringBuilder(); sb.append(CreatFactory.class.getPackageName()); sb.append("."); sb.append(which); creator = (Creator) Class.forName(sb.toString()).newInstance(); return creator; } } 
package factory1; public interface Creator { 
    public Product factory(); } 
讯享网package factory1; public class ConcreateCreator1 implements Creator { 
    @Override public Product factory() { 
    // 可以进行一些前置操作,例如设置权限、进行修饰、打印日志…… return new ConcreateProduct1(); } } 
package factory1; public class ConcreateCreator2 implements Creator { 
    @Override public Product factory() { 
    // TODO Auto-generated method stub return new ConcreateProduct2(); } } 
讯享网package factory1; public interface Product { 
    public void show(); } 
package factory1; public class ConcreateProduct1 implements Product { 
    @Override public void show() { 
    // TODO Auto-generated method stub System.out.println("This is Product1111 show"); } } 
讯享网package factory1; public class ConcreateProduct2 implements Product { 
    @Override public void show() { 
    // TODO Auto-generated method stub System.out.println("This is Product2222 show"); } } 

抽象工厂模式

抽象工厂在于产品族的扩展
工厂方法是只有一种产品族的抽象工厂
在这里插入图片描述

package abstractFactory; public interface Shape { 
    public void draw(); } 
讯享网package abstractFactory; public class Circle implements Shape { 
    @Override public void draw() { 
    // TODO Auto-generated method stub System.out.println("画一个圆"); } } 
package abstractFactory; public class Rectangle implements Shape { 
    @Override public void draw() { 
    // TODO Auto-generated method stub System.out.println("画一个矩形"); } } 
讯享网package abstractFactory; public class Square implements Shape { 
    @Override public void draw() { 
    // TODO Auto-generated method stub System.out.println("画一个正方形"); } } 
package abstractFactory; public interface Color { 
    public void draw(); } 
讯享网package abstractFactory; public class Bule implements Color { 
    @Override public void draw() { 
    // TODO Auto-generated method stub System.out.println("涂蓝色"); } } 
package abstractFactory; public class Green implements Color { 
    @Override public void draw() { 
    // TODO Auto-generated method stub System.out.println("涂绿色"); } } 
讯享网package abstractFactory; public class Red implements Color { 
    @Override public void draw() { 
    // TODO Auto-generated method stub System.out.println("涂红色"); } } 
package abstractFactory; public class ShapeFactory implements AbstractFactory { 
    @Override public Color getColor(String color) { 
    // TODO Auto-generated method stub return null; } @Override public Shape getShape(String shape) { 
    // TODO Auto-generated method stub Shape sh=null; String pn = ShapeFactory.class.getPackageName(); StringBuilder sb = new StringBuilder(); sb.append(pn); sb.append("."); sb.append(Character.toUpperCase(shape.charAt(0))); sb.append(shape.substring(1).toLowerCase()); try { 
    sh=(Shape) Class.forName(sb.toString()).newInstance(); } catch (InstantiationException e) { 
    // TODO Auto-generated catch block e.printStackTrace(); } catch (IllegalAccessException e) { 
    // TODO Auto-generated catch block e.printStackTrace(); } catch (ClassNotFoundException e) { 
    // TODO Auto-generated catch block e.printStackTrace(); } return sh; } } 
讯享网package abstractFactory; public class ColorFactory implements AbstractFactory { 
    public Color getColor(String color) { 
    Color cl=null; String pn = ColorFactory.class.getPackageName(); StringBuilder sb = new StringBuilder(); sb.append(pn); sb.append("."); sb.append(Character.toUpperCase(color.charAt(0))); sb.append(color.substring(1).toLowerCase()); try { 
    cl=(Color) Class.forName(sb.toString()).newInstance(); } catch (InstantiationException e) { 
    // TODO Auto-generated catch block e.printStackTrace(); } catch (IllegalAccessException e) { 
    // TODO Auto-generated catch block e.printStackTrace(); } catch (ClassNotFoundException e) { 
    // TODO Auto-generated catch block e.printStackTrace(); } return cl; } @Override public Shape getShape(String shape) { 
    // TODO Auto-generated method stub return null; } } 
package abstractFactory; public interface AbstractFactory { 
    public Shape getShape(String shape); public Color getColor(String color); } 
讯享网package abstractFactory; public class FactoryProducer { 
    public static AbstractFactory getFactory(String which) { 
    AbstractFactory af=null; String pn = FactoryProducer.class.getPackageName(); StringBuilder sb = new StringBuilder(); sb.append(pn); sb.append("."); sb.append(which); try { 
    af = (AbstractFactory) Class.forName(sb.toString()).newInstance(); } catch (InstantiationException e) { 
    // TODO Auto-generated catch block e.printStackTrace(); } catch (IllegalAccessException e) { 
    // TODO Auto-generated catch block e.printStackTrace(); } catch (ClassNotFoundException e) { 
    // TODO Auto-generated catch block e.printStackTrace(); } return af; } } 
package abstractFactory; public class Client { 
    public static void main(String[] args) { 
    // TODO Auto-generated method stub String[] shapes = { 
   "circle","square","RECTANGLE"}; String[] colors = { 
   "bule","red","GREEN"}; String[] factory = { 
   "ShapeFactory","ColorFactory"}; for(String f : factory) { 
    AbstractFactory af = FactoryProducer.getFactory(f); for(String c : colors) { 
    if(af.getColor(c)!=null) { 
    af.getColor(c).draw(); } } for(String s : shapes) { 
    if(af.getShape(s)!=null) { 
    af.getShape(s).draw(); } } } } } 

总结

  • 简单工厂:把对象的创建放到一个工厂类中,通过参数来创建不同的对象。这个缺点是每添一个对象,就需要对简单工厂进行修改(尽管不是删代码,仅仅是添一个switch case,但仍然违背了“开闭”原则。
  • 工厂方法:每种产品由一种工厂来创建,是将创建对象的逻辑与任务交给工厂类,如果增加一个具体的产品,不用像简单工厂方法那样修改里面的代码,可以直接扩展,遵循 “开闭”原则
  • 抽象工厂:是工厂方法模式的进一步推广化和抽象化,扩充和升级,在抽象工厂模式中抽象产品可能是一个或者多个,从而构成了一个或多个产品族,只有一个产品族的抽象工厂模式就是工厂方法模式,一般是大项目用。
小讯
上一篇 2025-02-10 10:22
下一篇 2025-03-05 11:17

相关推荐

版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容,请联系我们,一经查实,本站将立刻删除。
如需转载请保留出处:https://51itzy.com/kjqy/132879.html