反射,工厂方法Demo

package model2;

import java.lang.reflect.Constructor;
import java.util.Enumeration;
import java.util.Vector;

public abstract class Trash {

    private double weight;
    
    public Trash() {
    }
    
    Trash(double weight) {
        this.weight=weight;
    }

    public abstract double value();
    
    public double weight(){
        return weight;
    }
    
    public static void sumValue(Vector bin){
        Enumeration e = bin.elements();
        double val = 0.0f;
        while(e.hasMoreElements()){
            Trash t = (Trash)e.nextElement();
            val += t.weight() * t.value();
            System.out.println(t.getClass().getName()+"="+t.weight());
        }
        System.out.println("Total value="+val);
    }
    
    public static class PrototypeNotFoundException extends Exception{//...
    }
    
    public static class CannotCreateTrashException extends Exception{//...
    }
    
    private static Vector trashTypes = new Vector();
    
    public static Trash factory(Info info) throws PrototypeNotFoundException,CannotCreateTrashException{
        //take
        for(int i=0;i<trashTypes.size();i++){
            Class tc = (Class)trashTypes.elementAt(i);
            if (tc.getName().indexOf(info.className) !=-1) {
                try {
                    Constructor ctor = tc.getConstructor(new Class[]{double.class});
                    Trash trash =(Trash)ctor.newInstance(new Object[]{new Double(info.data)});
                    return trash;
                } catch (Exception e) {
                    e.printStackTrace();
                    throw new CannotCreateTrashException();
                }
            }
        }
        //add
        try {
            trashTypes.addElement(Class.forName(info.className));
        } catch (Exception e) {
            e.printStackTrace();
            throw new PrototypeNotFoundException();
        }
        //back
        return factory(info);
    }
    
    public static class Info{
        public String className;
        public double data;
        public Info(String className,double data){
            this.className = className;
            this.data = data;
        }
    }
    
}

 

 

 

 

转载于:https://www.cnblogs.com/gscq073240/articles/6746086.html

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
### 回答1: 下面是一个使用 C 语言实现面向对象的工厂方法模式的简单示例: ``` #include <stdio.h> #include <stdlib.h> typedef struct Product Product; struct Product { void (*use)(Product*); }; typedef struct ConcreteProductA ConcreteProductA; struct ConcreteProductA { Product product; int concrete_a_data; }; void concrete_product_a_use(Product* product) { ConcreteProductA* concrete_product_a = (ConcreteProductA*) product; printf("ConcreteProductA use, concrete_a_data = %d\n", concrete_product_a->concrete_a_data); } typedef struct ConcreteProductB ConcreteProductB; struct ConcreteProductB { Product product; int concrete_b_data; }; void concrete_product_b_use(Product* product) { ConcreteProductB* concrete_product_b = (ConcreteProductB*) product; printf("ConcreteProductB use, concrete_b_data = %d\n", concrete_product_b->concrete_b_data); } typedef struct Creator Creator; struct Creator { Product* (*factory_method)(); }; typedef struct ConcreteCreatorA ConcreteCreatorA; struct ConcreteCreatorA { Creator creator; }; Product* concrete_creator_a_factory_method() { ConcreteProductA* concrete_product_a = (ConcreteProductA*) malloc(sizeof(ConcreteProductA)); concrete_product_a->product.use = concrete_product_a_use; concrete_product_a->concrete_a_data = rand() % 100; return (Product*) concrete_product_a; } typedef struct ConcreteCreatorB ConcreteCreatorB; struct ConcreteCreatorB { Creator creator; }; Product* concrete_creator_b_factory_method() { ConcreteProductB* concrete_product_b = (ConcreteProductB*) malloc(sizeof(ConcreteProductB)); concrete_product_b->product.use = concrete_product_b_use; concrete_product_b->concrete_b_data = rand() % 100; return (Product*) concrete_product_b; } int main() { Creator* creator = (Creator*) malloc(sizeof(ConcreteCreatorA)); creator->factory_method = concrete_creator_a_factory_method; Product* product = creator->factory_method(); product->use(product); free(product); creator = (Creator*) malloc(sizeof(ConcreteCreatorB)); creator->factory_method = concrete_creator_b_factory_method; product = creator->factory_method(); product->use(product); free(product); free(creator); ### 回答2: 面向对象的工厂方法模式是一种创建型设计模式,它将对象的创建委托给工厂类,实现了对象的创建与使用的分离,可以灵活地添加新的产品类型而无需修改客户端代码。 以一个简单的图形绘制工具为例,我们可以使用工厂方法模式实现对不同图形对象的创建。 首先,我们定义一个抽象的图形类,包含绘制方法draw(): class Shape { public abstract void draw(); } 然后,定义不同的具体图形类,继承自抽象图形类: class Rectangle extends Shape { public void draw() { // 绘制矩形的具体实现 } } class Circle extends Shape { public void draw() { // 绘制圆形的具体实现 } } 接下来,我们定义一个抽象的图形工厂类,包含创建图形对象的方法createShape(): class ShapeFactory { public abstract Shape createShape(); } 然后,定义不同的具体图形工厂类,继承自抽象图形工厂类: class RectangleFactory extends ShapeFactory { public Shape createShape() { return new Rectangle(); } } class CircleFactory extends ShapeFactory { public Shape createShape() { return new Circle(); } } 最后,我们可以在客户端代码中通过具体的工厂类创建具体的图形对象并调用相应的方法: ShapeFactory factory = new RectangleFactory(); Shape shape = factory.createShape(); shape.draw(); 这样,通过工厂方法模式,我们可以实现对不同图形对象的创建和使用的解耦,从而提高了系统的扩展性和灵活性。 ### 回答3: 工厂方法模式是一种创建型设计模式,用于解耦具体对象的创建和使用。在面向对象的编程中,通常需要通过实例化具体的对象来完成某个功能,这会导致代码耦合度高、可维护性差。而工厂方法模式通过定义一个抽象工厂类,让子类具体实现创建对象的方法,以达到解耦的效果。 下面以一个计算器为例来演示工厂方法模式的使用。 首先,我们定义一个抽象的计算器接口Calculator,其中包含了两个方法:add和subtract。 接着,我们创建两个具体类CalculatorAdd和CalculatorSubtract,它们分别实现了Calculator接口,并分别实现了add和subtract方法,用于进行加法和减法运算。 然后,我们创建一个抽象工厂类CalculatorFactory,其中包含一个创建计算器的抽象方法createCalculator。 最后,我们创建两个具体工厂类CalculatorAddFactory和CalculatorSubtractFactory,它们分别实现了CalculatorFactory接口,并实现了createCalculator方法,分别用来创建加法计算器和减法计算器的对象。 这样,当我们需要使用计算器时,只需通过具体工厂类创建对应的计算器对象,并直接使用其方法进行计算,无需关心具体对象的创建细节。 工厂方法模式可以将对象的创建和使用分离开来,提高代码的可维护性和可扩展性。当需要新增一种计算器时,只需创建一个新的具体工厂类和计算器类,并通过扩展抽象工厂类和接口来完成,无需修改已有的代码。同时,也方便进行单元测试和代码的复用。 总之,工厂方法模式是一种常用的设计模式,在面向对象的编程中具有重要的应用价值。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值