`
BlogDown
  • 浏览: 223969 次
  • 性别: Icon_minigender_1
  • 来自: 上海
文章分类
社区版块
存档分类
最新评论

java简单工厂模式

阅读更多
(缺点:每增加一个具体产品时 ,就要修改工厂方法,工厂方法负责了所有具体产品的创建)

举个例子:
------------------
public interface Fruit {

void grow();

void harvest();

void plant();
}
-------------------
public class Apple implements Fruit {

private int treeAge;

public void grow() {
  // TODO Auto-generated method stub
  System.out.println("Apple is growing...");
 
}

public void harvest() {
  // TODO Auto-generated method stub
  System.out.println("Apple has been harvested.");
}

public void plant() {
  // TODO Auto-generated method stub
  System.out.println("Apple has been planted.");
 
}

public int getTreeAge() {
  return treeAge;
}

public void setTreeAge(int treeAge) {
  this.treeAge = treeAge;
}

}
-------------------
public class Grape implements Fruit {

private boolean seedless;



public boolean isSeedless() {
  return seedless;
}

public void setSeedless(boolean seedless) {
  this.seedless = seedless;
}

public void grow() {
  // TODO Auto-generated method stub
  System.out.println("Grape is growing...");
}

public void harvest() {
  // TODO Auto-generated method stub
  System.out.println("Grape has been harvested.");
}

public void plant() {
  // TODO Auto-generated method stub
  System.out.println("Grape has been planted.");
 
}


}


---------------------------
public class Strawberry implements Fruit {

public void grow() {
  // TODO Auto-generated method stub
  System.out.println("Strawberry is growing...");
}

public void harvest() {
  // TODO Auto-generated method stub
  System.out.println("Strawberry has been harvested.");
}

public void plant() {
  // TODO Auto-generated method stub
  System.out.println("Strawberry has been planted.");
}
}

-------------------------
public class FruitGardener {

//静态工厂方法
public static Fruit factory(String which) throws BadFruitException{
  if(which.equalsIgnoreCase("apple")){
   return new Apple();
  }
  else if(which.equalsIgnoreCase("strawberry")){
   return new Strawberry();
  }
  else if(which.equalsIgnoreCase("grape")){
   return new Grape();
  }
  else{
   throw new BadFruitException("Bad fruit request");
  }
}
}

---------------------------
public class BadFruitException extends Exception {

public BadFruitException(String msg){
  super(msg);
}
}


--------------------------
public class Client {

public static void main(String[] args){
 
  try{
   Fruit apple = (Fruit)FruitGardener.factory("Apple");
   System.out.println("apple is class: " + apple.getClass().getName());
   apple.plant();
   apple.grow();
   apple.harvest();
   System.out.println();
  
   Fruit grape = (Fruit)FruitGardener.factory("grape");
   System.out.println("grape is class: " + grape.getClass().getName());
   grape.plant();
   grape.grow();
   grape.harvest();
   System.out.println();
  
   Fruit strawberry = (Fruit)FruitGardener.factory("strawberry");
   System.out.println("strawberry is class: " + strawberry.getClass().getName());
   strawberry.plant();
   strawberry.grow();
   strawberry.harvest();
  
  }catch(BadFruitException e){
   e.printStackTrace();
  }
}
}


2 工厂方法模式:解决了简单工厂模式的缺点, 将每一个具体产品的创建工作交给对应的具体工厂角色去解决

举个例子:
---------------------
public interface FruitGardener {

public Fruit factory();
}


---------------------

public class AppleGardener implements FruitGardener{

public Fruit factory() {
  return new Apple();
}
}

-----------------

public class GrapeGardener implements FruitGardener{

public Fruit factory() {
  return new Grape();
}
}


----------------------

public class StrawGardener implements FruitGardener{

public Fruit factory() {
  return new Strawberry();
}
}

-----------------
public class Client {

private static FruitGardener applegardener, grapegardener, strawgardener;
private static Fruit apple, grape, strawberry;

public static void main(String[] args){
  applegardener = new AppleGardener();
  apple = applegardener.factory();
  System.out.println("apple is class: " + apple.getClass().getName());
  apple.plant();
  apple.grow();
  apple.harvest();
  System.out.println();
 
  grapegardener = new GrapeGardener();
  grape = grapegardener.factory();
  System.out.println("grape is class: " + grape.getClass().getName());
  grape.plant();
  grape.grow();
  grape.harvest();
  System.out.println();

  strawgardener = new StrawGardener();
  strawberry = strawgardener.factory();
  System.out.println("strawberry is class: " + strawberry.getClass().getName());
  strawberry.plant();
  strawberry.grow();
  strawberry.harvest();
}
}


3 抽象工厂模式:解决多产品簇问题

举个例子:

-------------------
public interface Fruit {

// public String getName();
}

public class NorthernFruit implements Fruit{

private String name;

public String getName() {
  return name;
}

public void setName(String name) {
  this.name = name;
}

public NorthernFruit(String name) {
  super();
  // TODO Auto-generated constructor stub
  this.name = name;
}


}



public class TropicalFruit implements Fruit{

private String name;

public String getName() {
  return name;
}

public void setName(String name) {
  this.name = name;
}

public TropicalFruit(String name) {
  super();
  // TODO Auto-generated constructor stub
  this.name = name;
}


}



public interface Veggie {

}


public class TropicalVeggie implements Veggie{

private String name;

public String getName() {
  return name;
}

public void setName(String name) {
  this.name = name;
}

public TropicalVeggie(String name) {
  super();
  // TODO Auto-generated constructor stub
  this.name = name;
}



}


public class NorthernVeggie implements Veggie{

private String name;

public String getName() {
  return name;
}

public void setName(String name) {
  this.name = name;
}

public NorthernVeggie(String name) {
  super();
  // TODO Auto-generated constructor stub
  this.name = name;
}


}

-------------------------

public interface Gardener {

public Fruit createFruit(String name);

public Veggie createVeggie(String name);
}

public class NorthernGardener implements Gardener {

public Fruit createFruit(String name) {
  return new NorthernFruit(name);
}

public Veggie createVeggie(String name) {
  return new NorthernVeggie(name);
}


}



public class TropicalGardener implements Gardener {

public Fruit createFruit(String name) {
  return new TropicalFruit(name);
}

public Veggie createVeggie(String name) {
  return new TropicalVeggie(name);
}


}


public class Client {

private static Gardener tropicalgardener ,northerngardener;
private static Fruit northernfruit, tropicalfruit;
private static Veggie northernveggie, tropicalveggie;

public static void main(String[] args){
  tropicalgardener = new TropicalGardener();
  tropicalfruit = tropicalgardener.createFruit("tropicalfruit");
  //System.out.println(tropicalfruit.getName());
  tropicalveggie = tropicalgardener.createVeggie("tropicalveggie");
 
  northerngardener = new NorthernGardener();
  northernfruit = northerngardener.createFruit("northernfruit");
  northernveggie = northerngardener.createVeggie("northernveggie");
}

}
分享到:
评论

相关推荐

    Java简单工厂模式和传统模式实现对比

    Java简单工厂模式是一种设计模式,它是创建型模式的一种,用于将对象的创建过程封装到一个独立的工厂类中,使得客户端代码无需关心具体的对象创建细节,只需要知道如何调用工厂方法即可得到所需的对象。这种模式在...

    Java 简单工厂模式例子

    **Java 简单工厂模式详解** ...通过上述分析,我们可以理解Java简单工厂模式的基本概念,以及如何在实际项目中应用这一模式。在给定的压缩包文件中,我们可以深入研究源代码,进一步掌握其实现细节。

    java简单工厂模式文档简单汇总

    【Java 简单工厂模式】简单工厂模式是一种创建型设计模式,它的主要思想是提供一个工厂类,根据传入的参数动态地返回一个产品对象。这种模式将对象的创建与对象的使用分离,使得代码更加简洁且易于维护。 在Java中...

    JAVA简单工厂模式四则运算计算器

    在这个“JAVA简单工厂模式四则运算计算器”中,我们将探讨如何使用Java实现一个基于简单工厂模式的计算器,它能够处理加法、减法、乘法和除法四种基本运算。 首先,我们需要定义一个接口,例如命名为`Calculator`,...

    java 简单工厂模式 源代码

    从设计模式的类型上来说,简单工厂模式是属于创建型模式,又叫做静态工厂方法(Static Factory Method)模式,但不属于23种GOF设计模式之一。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂...

    工厂模式:简单工厂模式、工厂方法模式、抽象工厂模式

    工厂模式分为三种主要类型:简单工厂模式、工厂方法模式和抽象工厂模式。 1. **简单工厂模式** 简单工厂模式是最简单的工厂模式实现,它提供一个静态方法或者类来创建对象,这个类通常被称为“工厂”。用户只需要...

    JAVA简单工厂创立性模式介绍

    简单工厂模式是一种最为基础的创建型模式,它提供一个静态方法来创建对象,这个静态方法根据传入的参数来决定创建哪个类的实例。简单工厂模式的主要优点在于客户端无需知道具体产品的类名,只需要知道产品的类型即可...

    java简单工厂模式源码实例

    简单工厂模式是设计模式中的创建型模式之一,它在Java编程中被广泛使用,尤其适合于对象的创建过程相对固定,且系统不需频繁添加新类的情况。此模式通过一个公共的工厂类来创建对象,避免了客户端代码直接new对象,...

    工厂模式(简单工厂,普通工厂,抽象工厂)代码java

    工厂模式分为三种主要类型:简单工厂模式、普通工厂模式(也称为工厂方法模式)和抽象工厂模式。 1. **简单工厂模式**: - 简单工厂模式中,有一个中心工厂类,它负责根据输入条件(通常是一个参数)来创建具体的...

    一个简单的工厂模式(java)

    在这个"一个简单的工厂模式(java)"示例中,我们将深入探讨如何在Java中实现这个模式。 首先,我们来看`HumanFactory.java`,这是工厂模式的核心,它定义了产品(在这个例子中是人)的创建逻辑。工厂类通常包含一个...

    Java简单工厂模式定义与用法实例分析

    Java简单工厂模式定义与用法实例分析 Java简单工厂模式是Java设计模式中的一种,属于创建型模式。该模式提供了一种简单的方式来创建对象,免去了直接使用new关键字来创建对象的麻烦。 简单工厂模式定义 简单工厂...

    Java简单工厂创立性模式介绍

    总的来说,Java简单工厂模式是软件设计中常用的创建型模式,尤其适用于对象创建逻辑相对简单且不会频繁变动的场景。了解并合理运用这种模式,可以提高代码的可读性、可维护性和扩展性。在实际开发中,可以根据项目...

    JAVA简单工厂模式(从现实生活角度理解代码原理)

    JAVA简单工厂模式(从现实生活角度理解代码原理) JAVA简单工厂模式是一种静态工厂设计模式,它提供了一个简单的解决方案来实例化对象。这种模式通过一个工厂类来实例化不同的对象,根据传入的参数来确定实例化哪种...

    java简单工厂创立性模式介绍

    Java简单工厂模式是一种常见的创建型设计模式,它提供了一个创建对象的接口,但允许子类决定实例化哪一个类。这种模式使代码能够绕过复杂的实例化逻辑,将对象的创建过程封装起来,使得客户端代码无需知道具体创建的...

    java 设计模式 mvc模式 单例模式 代理 工厂 简单工厂

    在Java中,简单工厂模式、工厂方法模式和抽象工厂模式是三种常见的实现方式。简单工厂模式虽然简单易懂,但扩展性较差,因为它将所有产品类型硬编码在工厂类中。工厂方法模式通过定义创建对象的接口,让子类决定实例...

    XML解析器-简单工厂模式.doc

    《XML解析器与简单工厂模式》 XML(eXtensible Markup Language)是一种标记语言,广泛用于数据交换、配置文件存储等场景。在Java中,处理XML文档时,我们通常会使用解析器,其中SAX(Simple API for XML)解析器是...

    JAVA设计模式(01):创建型-工厂模式【简单工厂模式】(Simple Factory)

    **简单工厂模式**是软件设计模式中的一种,属于创建型模式。在Java编程中,它是一种用于创建对象的简便方法,将对象的实例化过程封装到一个单独的工厂类中,使得客户端代码无需直接调用具体类的构造函数,而是通过...

Global site tag (gtag.js) - Google Analytics