• java中的工厂模式


    1.工厂模式

    java中的工厂模式,个人理解是:要想制作一个汽车,则必须有轮子,发动机,座椅等.

    1.创建一个接口,并且使得轮子,发动机,座椅三个实现类实现这个接口.

    2.创建一个工厂,生成基于给定信息的实体类的对象。

     1   public class 零件工厂{
     2       
     3      
     4      public Shape 获得零件(String 零件名称){
     5         if(零件名称== null){
     6            return null;
     7         }        
     8         if(零件名称.equalsIgnoreCase("轮子")){
     9            return new 轮子类();
    10        } else if(零件名称.equalsIgnoreCase("发动机")){
    11           return new 发动机类();
    12        } else if(零件名称.equalsIgnoreCase("座椅")){
    13           return new 座椅类();
    14        }
    15        return null;
    16     }
    17  }

    3.调用者代码

     1   public class 生产{
     2   
     3      public static void main(String[] args) {
     4         零件工厂 factory = new 零件工厂 ();
     5     
     6          公共接口 获得的轮子= factory .getShape("轮子 ");
     7    
     8         
     9         公共接口  获得的座椅 = factory .getShape("座椅");
    10       
    11     }
    12  }

     2.抽象工厂模式

      

    接口1
    public interface Shape {
       void draw();
    }
    实现1
    public class Rectangle implements Shape {
    
       @Override
       public void draw() {
          System.out.println("Inside Rectangle::draw() method.");
       }
    }
    
    public class Square implements Shape {
    
       @Override
       public void draw() {
          System.out.println("Inside Square::draw() method.");
       }
    }
    
    public class Circle implements Shape {
    
       @Override
       public void draw() {
          System.out.println("Inside Circle::draw() method.");
       }
    }
    
    接口2
    public interface Color {
       void fill();
    }
    实现2
    public class Red implements Color {
    
       @Override
       public void fill() {
          System.out.println("Inside Red::fill() method.");
       }
    }
    
    public class Green implements Color {
    
       @Override
       public void fill() {
          System.out.println("Inside Green::fill() method.");
       }
    }
    
    public class Blue implements Color {
    
       @Override
       public void fill() {
          System.out.println("Inside Blue::fill() method.");
       }
    }
    
    为 Color 和 Shape 对象创建抽象类来获取工厂。
    
    public abstract class AbstractFactory {
       abstract Color getColor(String color);
       abstract Shape getShape(String shape) ;
    }
    
    创建扩展了 AbstractFactory 的工厂类,基于给定的信息生成实体类的对象。
    public class ShapeFactory extends AbstractFactory {
    	
       @Override
       public Shape getShape(String shapeType){
          if(shapeType == null){
             return null;
          }		
          if(shapeType.equalsIgnoreCase("CIRCLE")){
             return new Circle();
          } else if(shapeType.equalsIgnoreCase("RECTANGLE")){
             return new Rectangle();
          } else if(shapeType.equalsIgnoreCase("SQUARE")){
             return new Square();
          }
          return null;
       }
       
       @Override
       Color getColor(String color) {
          return null;
       }
    }
    
    public class ColorFactory extends AbstractFactory {
    	
       @Override
       public Shape getShape(String shapeType){
          return null;
       }
       
       @Override
       Color getColor(String color) {
          if(color == null){
             return null;
          }		
          if(color.equalsIgnoreCase("RED")){
             return new Red();
          } else if(color.equalsIgnoreCase("GREEN")){
             return new Green();
          } else if(color.equalsIgnoreCase("BLUE")){
             return new Blue();
          }
          return null;
       }
    }
    
    创建一个工厂创造器/生成器类,通过传递形状或颜色信息来获取工厂。
    public class FactoryProducer {
       public static AbstractFactory getFactory(String choice){
          if(choice.equalsIgnoreCase("SHAPE")){
             return new ShapeFactory();
          } else if(choice.equalsIgnoreCase("COLOR")){
             return new ColorFactory();
          }
          return null;
       }
    }
    
    使用 FactoryProducer 来获取 AbstractFactory,通过传递类型信息来获取实体类的对象。
    
    public class AbstractFactoryPatternDemo {
       public static void main(String[] args) {
    
          //获取形状工厂
          AbstractFactory shapeFactory = FactoryProducer.getFactory("SHAPE");
    
          //获取形状为 Circle 的对象
          Shape shape1 = shapeFactory.getShape("CIRCLE");
    
          //调用 Circle 的 draw 方法
          shape1.draw();
    
          //获取形状为 Rectangle 的对象
          Shape shape2 = shapeFactory.getShape("RECTANGLE");
    
          //调用 Rectangle 的 draw 方法
          shape2.draw();
          
          //获取形状为 Square 的对象
          Shape shape3 = shapeFactory.getShape("SQUARE");
    
          //调用 Square 的 draw 方法
          shape3.draw();
    
          //获取颜色工厂
          AbstractFactory colorFactory = FactoryProducer.getFactory("COLOR");
    
          //获取颜色为 Red 的对象
          Color color1 = colorFactory.getColor("RED");
    
          //调用 Red 的 fill 方法
          color1.fill();
    
          //获取颜色为 Green 的对象
          Color color2 = colorFactory.getColor("Green");
    
          //调用 Green 的 fill 方法
          color2.fill();
    
          //获取颜色为 Blue 的对象
          Color color3 = colorFactory.getColor("BLUE");
    
          //调用 Blue 的 fill 方法
          color3.fill();
       }
    }
    
    输出
    Inside Circle::draw() method.
    Inside Rectangle::draw() method.
    Inside Square::draw() method.
    Inside Red::fill() method.
    Inside Green::fill() method.
    Inside Blue::fill() method.
    

      

     

  • 相关阅读:
    Android开发历程_8(Tween Animation的2种属性设置方法)
    Kinect+OpenNI学习笔记之1(开发环境的建立)
    Android开发历程_12(Handler的使用)
    Qt学习之路_11(简易多文档编辑器)
    特征点检测学习_1(sift算法)
    Android开发历程_9(Frame Animation的使用)
    Qt学习之路_13(简易俄罗斯方块)
    总结系列_12(XML使用总结,续...)
    Android开发历程_11(AnimationListener的使用方法)
    Android开发历程_18(XML文件解析)
  • 原文地址:https://www.cnblogs.com/wonder2636/p/5520835.html
Copyright © 2020-2023  润新知