(缺点:每增加一个具体产品时 ,就要修改工厂方法,工厂方法负责了所有具体产品的创建)
举个例子:
------------------
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实现一个基于简单工厂模式的计算器,它能够处理加法、减法、乘法和除法四种基本运算。 首先,我们需要定义一个接口,例如命名为`Calculator`,...
从设计模式的类型上来说,简单工厂模式是属于创建型模式,又叫做静态工厂方法(Static Factory Method)模式,但不属于23种GOF设计模式之一。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂...
工厂模式分为三种主要类型:简单工厂模式、工厂方法模式和抽象工厂模式。 1. **简单工厂模式** 简单工厂模式是最简单的工厂模式实现,它提供一个静态方法或者类来创建对象,这个类通常被称为“工厂”。用户只需要...
简单工厂模式是一种最为基础的创建型模式,它提供一个静态方法来创建对象,这个静态方法根据传入的参数来决定创建哪个类的实例。简单工厂模式的主要优点在于客户端无需知道具体产品的类名,只需要知道产品的类型即可...
简单工厂模式是设计模式中的创建型模式之一,它在Java编程中被广泛使用,尤其适合于对象的创建过程相对固定,且系统不需频繁添加新类的情况。此模式通过一个公共的工厂类来创建对象,避免了客户端代码直接new对象,...
工厂模式分为三种主要类型:简单工厂模式、普通工厂模式(也称为工厂方法模式)和抽象工厂模式。 1. **简单工厂模式**: - 简单工厂模式中,有一个中心工厂类,它负责根据输入条件(通常是一个参数)来创建具体的...
在这个"一个简单的工厂模式(java)"示例中,我们将深入探讨如何在Java中实现这个模式。 首先,我们来看`HumanFactory.java`,这是工厂模式的核心,它定义了产品(在这个例子中是人)的创建逻辑。工厂类通常包含一个...
Java简单工厂模式定义与用法实例分析 Java简单工厂模式是Java设计模式中的一种,属于创建型模式。该模式提供了一种简单的方式来创建对象,免去了直接使用new关键字来创建对象的麻烦。 简单工厂模式定义 简单工厂...
总的来说,Java简单工厂模式是软件设计中常用的创建型模式,尤其适用于对象创建逻辑相对简单且不会频繁变动的场景。了解并合理运用这种模式,可以提高代码的可读性、可维护性和扩展性。在实际开发中,可以根据项目...
JAVA简单工厂模式(从现实生活角度理解代码原理) JAVA简单工厂模式是一种静态工厂设计模式,它提供了一个简单的解决方案来实例化对象。这种模式通过一个工厂类来实例化不同的对象,根据传入的参数来确定实例化哪种...
Java简单工厂模式是一种常见的创建型设计模式,它提供了一个创建对象的接口,但允许子类决定实例化哪一个类。这种模式使代码能够绕过复杂的实例化逻辑,将对象的创建过程封装起来,使得客户端代码无需知道具体创建的...
在Java中,简单工厂模式、工厂方法模式和抽象工厂模式是三种常见的实现方式。简单工厂模式虽然简单易懂,但扩展性较差,因为它将所有产品类型硬编码在工厂类中。工厂方法模式通过定义创建对象的接口,让子类决定实例...
《XML解析器与简单工厂模式》 XML(eXtensible Markup Language)是一种标记语言,广泛用于数据交换、配置文件存储等场景。在Java中,处理XML文档时,我们通常会使用解析器,其中SAX(Simple API for XML)解析器是...
**简单工厂模式**是软件设计模式中的一种,属于创建型模式。在Java编程中,它是一种用于创建对象的简便方法,将对象的实例化过程封装到一个单独的工厂类中,使得客户端代码无需直接调用具体类的构造函数,而是通过...