头第一设计模式将简单工厂描述为
public class SimplePizzaFactory {
public Pizza createPizza(String type) {
Pizza pizza = null;
if (type.equals(“cheese”)) {
pizza = new CheesePizza();
} else if (type.equals(“pepperoni”)) {
pizza = new PepperoniPizza();
我创建了一个下面的例子。这是否遵循AbstractFactory设计模式?
ButtonType.java
public enum ButtonType {
WIN, LINUX, MAC
}
Button.java
public interface Button {
ButtonType getButtonType();
void actionListener();
}
LinuxButton.java
public class LinuxButton implements Button {
@Override
public ButtonType
我编写了以下GenericDAO,如下面的代码所示
abstract public class DAO <T extends AbstractBusinessObject> {
// CRUD: create, read, update, delete
public abstract T create(Class<T> abObj);
public abstract T read();
public abstract void update(T abObj);
public abstract void delete(T abObj);
但有时,当我实现自定义
我想知道是否有某种设计模式使我的代码更加具体。
我想工厂方法模式可以帮助我,但不确定。
在代码下面,形状创建方法需要其他创建方法来创建子元素(例如:挤压->循环->顶点)。在形状创建方法中,程序员应该自定义已创建的子元素,以阐明该方法将生成什么形状。下面只是我的情况,不一定要深入我的处境。任何人都可以帮助我,任何建议都会很高兴的。
谢谢。
下面是我用C#编写的suedo代码流。遗憾的是缺乏细节,但更好的理解更快。
public class SomethingClass
{
//Some codes...
//create Circle
我正在读一篇关于工厂方法模式的文章。
我可以理解何时有一个工厂类,即StoreFactory#getStore(),根据某个运行时或其他状态返回Store实现。
但是,从阅读(例如)来看,似乎有一种通用的模式,人们创建一个抽象的工厂类,其他工厂类扩展到这个抽象工厂类:
public abstract class AbstractFactory {
public abstract Store getStore(int store);
}
public class StoreFactoryA extends AbstractFactory {
public Store
下面是我看到抽象工厂模式的典型方式:
public abstract class Factory
{
public abstract Product GetProduct();
}
public class ConcreteFactory1 : Factory
{
public override Product GetProduct() { return new Product1(); }
}
class ConcreteFactory2 : Factory
{
public override Product GetProduct() { retu
我正在学习设计模式,并在中遇到了非常奇怪的例子。如果我们有课:
public abstract class AbstractFactory {
abstract Color getColor(String color);
abstract Shape getShape(String shape) ;
}
正如我们所看到的,有两种创建对象的方法:颜色和形状。这个类是抽象的,所以我们必须创建这个类的具体实现,所以让我们假设我们有:
public class ShapeFactory extends AbstractFactory {
@Override
public Shape getShape
我有一个接口:
public interface MyInterface{}
和两个实现:
public class Imp1 implements MyInterface {}
public class Imp2 implements MyInterface {}
我的程序是CLI。我希望有一些类,它将接受命令行args,解析它并创建正确实现的新实例:
public class MyFactory {
public MyInterface getMyInterface(CommandLineArgs args) {
....
}
}
这里有图案吗?我不确定抽象的
我最近看到了很多这样的代码:
public interface IFoo { int Bar(); }
public static class Foo
{
public static IFoo Create() { return new FooImpl(); }
private class FooImpl : IFoo
{
public int Bar () { ... }
}
}
基本上,有一个由接口定义的契约,主业务对象类是提供工厂方法的静态类,还有一个提供实际实现的嵌入式类。
这种模式有一些优点,特别是合同与执行之间的分离。不过,对我来
大家都知道,AbstractFactory在不了解创建过程的情况下帮助创建对象。这将需要对抽象工厂创建者类进行重大更改。
我过去经常使用AbstractFactory,但经过我自己的修改,就像这样:将抽象工厂创建器类替换为空接口,该接口将由工厂类实现。这是有效的,但我想知道这是否打破了模式,或者这是模式上的一个糟糕的实践,或者它有任何缺点,将导致在未来的开发中相同的复杂性?
形状工厂:
public interface Shape {
void draw();
}
public class Circle implements Shape {
@Override
pub
我知道我可以编写这样的动态代理:
public class DecoratedFile implements java.lang.reflect.InvocationHandler {
private Object delegate;
public static Object newInstance(Object delegate) {
return java.lang.reflect.Proxy.newProxyInstance(
obj.getClass().getClassLoader(),
ob
当我的应用程序启动时,它需要根据登录的用户获取正确的DAL类的实例(目前有4个)。某些用户正在从某些数据库中拉取数据。
如果我只是返回DAL类的正确静态实例,而不是实例化这些DAL类的实例,那么它仍然被认为是“工厂”模式吗?我不需要不断地创建这些对象,因为所有用户都可以共享它们。
Psuedocode:
public class RepositoryFactory
{
public static IRepository repoA = new FranksLumberRepo();
public static IRepository repoB = new LowesHardw
Java noob这里,我有一个程序,我想迭代已经添加到另一个文件中的插件的数量,然后只要它是一个前缀和后缀计算器,我就想检查堆栈中的符号是否为'+‘,所以找到从Operator类扩展的add类,然后调用doAction(stack.pop(),stack.pop()),这是因为我想添加无限的方法来计算更多的符号,我试图使用反射,但我不知道如何在名称之间循环,让程序选择正确的方法
public class Operator {
public int doAction(int op1, int op2) {
return 0;
}
public
我正在学习马克·格兰德的"Patterns in Java“第一卷中的Java设计模式(特别是工厂方法)。我的观点是强调最接近的模式之间的差异。有很好的答案来阐明Factory方法和Abstract Factory之间的区别。 (Design Patterns: Factory vs Factory method vs Abstract Factory, What is the basic difference between the Factory and Abstract Factory Design Patterns?)。但我注意到,与我在“Java中的模式”中读到的解释相比,
我知道这上面有上百个问题。我可能读过50个不同的问题,博客文章和教科书。问题是我得到了大约75种不同的答案。我已经看到以下所有描述为某种类型的工厂,我不能遵循混乱的术语,并对利弊感到困惑。
public class PizzaFactory {
public static Pizza(String city) {
switch(city) {
case "Chicago": return new DeepDishPizza();
case "New York": return new ThinCrustPizza();
我有两个手术要做。一个用于Air transport,另一个用于Road transport。这两个过程都会处理一些message。
这是Interface
public interface IProcess
{
void Process(string message);
}
以下是我的Road transport实现
public class RoadTransport: IProcess
{
public void Process(string msg)
{
// do s