CODEWITHSUNDEEP
javadesign-patterns
S.Vignesh
S.Vignesh

Reputation: 121

Factory pattern: Accessing child methods

I have two classes CashStore and DrinkStore, both extends from Store. I have a StoreFactory class (returns Store object) to instantiate objects for clients. I want to access methods specific to child classes from these clients. How do I do it without casting? If I used casting, would it break the pattern, since now the clients know about the Child classes?

class Store{
    A(){}
    B(){}
}

class CashStore{
    A(){} 
    B(){}
    C(){}     
    D(){} 
}

//impl for drink store and other stores

class StoreFactory{
    public Store getStore(String type){
        //return a Store obj based on type DrinkStore or CashStore
    }
}


class Client{
    StoreFactory fac;

    public Client(){
        fac = new StoreFactory();
        Store s = fac.getStore("cash");
        s.C(); //requires a cast
    }
}

Does casting break my pattern?

Upvotes: 2

Views: 690

Answers (3)

Svetlin Zarev
Svetlin Zarev

Reputation: 15683

I want to access methods specific to child classes from these clients. How do I do it without casting?

If you know the expected type, then you can use generics to avoid casting:

interface Store {    
}

class WhiskeyStore implements Store {    
}

class VodkaStore implements Store {
}


class StoreFactory {
    <T extends Store> T getStore(Class<T> clazz) {
        try {
            // I use reflection just as an example, you can use whatever you want
            return clazz.getConstructor().newInstance();
        } catch (Exception e) {
            throw new RuntimeException("Cannot create store of type: " + clazz, e);
        }
    }
}

public final class Example {
    public static void main(String[] args) {
       WhiskeyStore whiskeyStore =  new StoreFactory().getStore(WhiskeyStore.class);
       VodkaStore vodkaStore =  new StoreFactory().getStore(VodkaStore.class);
    }
}

Upvotes: 0

Supun Wijerathne
Supun Wijerathne

Reputation: 12958

So basically you need to access child specific methods without casting. That's the whole purpose of Visitor pattern.

You can switch between different child by using method overloading. I have given an example below, you would need to adapt that to fit into your code. And also you should take out the business logic from the constructor (of Client) and implement them inside methods.

public class Client{

    public void doSomething(CashStore cs){
        cs.c();
        //you can call methods specific to CashStore.
    }

    public void doSomething(DrinkStore ds){
        ds.e();
        //you can call methods specific to DrinkStore.
    }

}

Upvotes: 0

Alexey Berezkin
Alexey Berezkin

Reputation: 1543

Factory pattern is used to decouple from runtime type. For example, when it's platform- or layout-specific, and you don't want your client code to mess with it. In your case you do need an exact type, so it seems factory pattern isn't a good choice. Consider using simple static methods, like:

class Stores {
  static CashStore createCashStore() {
    return new CashStore();
  }
  static DrinkStore createDrinkStore() {
    return new DrinkStore();
  }
}

Upvotes: 2

Related Questions