Confusion in prototype pattern

[sumittyagi]

Hi everybody!
I am having a difficulty in understanding the prototype pattern. Actually I got the idea behind it, but the example given in wikipedia for this pattern have confused me.
The code is as follows.

/** Prototype Class **/
public class Cookie implements Cloneable {
 
   public Object clone()
   {
       try{
          //In an actual implementation of this pattern you would now attach references to
           //the expensive to produce parts from the copies that are held inside the prototype.
            return this.getClass().newInstance();  // confused here.
      }
       catch(InstantiationException e)
       {
          e.printStackTrace();
          return null;
       }
   }
}
 
/** Concrete Prototypes to clone **/
public class CoconutCookie extends Cookie { }
 
/** Client Class**/
public class CookieMachine
{
 
  private Cookie cookie;//could have been a private Cloneable cookie; 
 
    public CookieMachine(Cookie cookie) { 
        this.cookie = cookie; 
    } 
    public Cookie makeCookie() { 
      return (Cookie)cookie.clone(); 
    } 
    public Object clone() { } 
 
    public static void main(String args[]){ 
        Cookie tempCookie =  null; 
        Cookie prot = new CoconutCookie(); 
        CookieMachine cm = new CookieMachine(prot); 
        for(int i=0; i<100; i++) 
            tempCookie = cm.makeCookie(); 
    } 
}
 

Now my confusion lies here.
>> return this.getClass() .newInstance()
in the clone method.
On one hand it is said, we create clone of the object, but in reality new instance is created. I am not able to understand the logic.

(Prototype Pattern link on wikipedia)

Thanks in Advance for any guidance.

[JosAH]

Now my confusion lies here.
>> return this.getClass() .newInstance()
in the clone method.
On one hand it is said, we create clone of the object, but in reality new instance is created. I am not able to understand the logic.

(Prototype Pattern link on wikipedia)

Thanks in Advance for any guidance.

The 'this' object can be either a Cookie or any derived object thereof (such as a
CoconutCookie). The corresponding class is found using the 'getClass()' method
which can create a new object of that class. Using one of the Cookie types as
a prototype (or 'exemplar' in SmallTalk) it can create new instances of itself which
is functionally equivalent to the clone() functionality. Maybe your confusion wouldn't
have existed if the wiki example had named the method 'duplicate()' instead of
'clone()'?

kind regards,

Jos

[sumittyagi]

The 'this' object can be either a Cookie or any derived object thereof (such as a
CoconutCookie). The corresponding class is found using the 'getClass()' method
which can create a new object of that class. Using one of the Cookie types as
a prototype (or 'exemplar' in SmallTalk) it can create new instances of itself which
is functionally equivalent to the clone() functionality. Maybe your confusion wouldn't
have existed if the wiki example had named the method 'duplicate()' instead of
'clone()'?

kind regards,

Jos

Thanks jos for your reply.
But What I got from the explaination of prototype pattern is not getting reflected in the code.

We use prototype pattern when the object creation and initialization is quite expensive. I mean when we want to get the exact copy(including its current state) of the existing complex object.

And what they did is, created a new object instead of copying it(existing state of object is not retained in this case).

And its not the name of the method that have confused me, but they have actually overridden the clone method of Object class.

Please guide me in this context.
Thanks again!

[sumittyagi]

Thanks jos for your reply.
But What I got from the explaination of prototype pattern is not getting reflected in the code.

We use prototype pattern when the object creation and initialization is quite expensive. I mean when we want to get the exact copy(including its current state) of the existing complex object.

And what they did is, created a new object instead of copying it(existing state of object is not retained in this case).

And its not the name of the method that have confused me, but they have actually overridden the clone method of Object class.

Please guide me in this context.
Thanks again!

Ok fine!!!
I think my answer lies here

           //In an actual implementation of this pattern you would now attach references to
           //the expensive to produce parts from the copies that are held inside the prototype.
 

Means they are cloning the internal complex parts of the complex object, rather than cloning the whole complex object.

Thanks for your support Jos.
Please correct me if I have misunderstood anything.

[JosAH]

Your question stayed in the back of my head for the entire day. Until I realized
something because of this sentense of yours:

We use prototype pattern when the object creation and initialization is quite expensive.

You're mixing up two different patterns:

1) the Prototype pattern or 'exemplar' where you basically have one (unknown)
object already and you want to tell something "give me another one of those".

2) the Proxy pattern where an object is quite expensive to create. A proxy can
handle the el-cheapo questions and acts as if it were the expensive object. Once
you ask a question that actually needs the expensive object itself, the Proxy
will create it for you.

Check them both out: the Proxy pattern and the Prototype pattern.

kind regards,

Jos

[sumittyagi]

Your question stayed in the back of my head for the entire day. Until I realized
something because of this sentense of yours:



You're mixing up two different patterns:

1) the Prototype pattern or 'exemplar' where you basically have one (unknown)
object already and you want to tell something "give me another one of those".

2) the Proxy pattern where an object is quite expensive to create. A proxy can
handle the el-cheapo questions and acts as if it were the expensive object. Once
you ask a question that actually needs the expensive object itself, the Proxy
will create it for you.

Check them both out: the Proxy pattern and the Prototype pattern.

kind regards,

Jos

Actually I am learning design patterns now a days. I have just read about creational patterns. I will now read structural patterns. I will come back to this thread when I am done with proxy pattern, to get your guidance again.

Thanks a lot for all your help.

[sumittyagi]

Your question stayed in the back of my head for the entire day. Until I realized
something because of this sentense of yours:



You're mixing up two different patterns:

1) the Prototype pattern or 'exemplar' where you basically have one (unknown)
object already and you want to tell something "give me another one of those".

2) the Proxy pattern where an object is quite expensive to create. A proxy can
handle the el-cheapo questions and acts as if it were the expensive object. Once
you ask a question that actually needs the expensive object itself, the Proxy
will create it for you.

Check them both out: the Proxy pattern and the Prototype pattern.

kind regards,

Jos

Hi! jos!
I don't think I am mixing the two patterns.
What I got from wikipeida explainations is:
1. Prototype pattern is a creational pattern, and hence deals with the creation of objects.
Now the purpose of prototype pattern is:
* there may be some standard states of any object (and reaching upto that state could be quite expensive).
* after reaching that state, we could need to change the state for our purpose to be accomplished in a particular scenario.
* there might be more than one scenario which needs to change the state from the standard state.

* so we make a copy of the standard state, and then customize the new object according to our requirements.
* in this way our particular requirement is also fulfilled, and standard state is also not changed, so that we can utilize in another scenario.
(all this explaination is my own assumption, its not written in article, so it may be wrong, so please correct me if I am wrong anywhere)


2. Now comming to proxy pattern:
proxy pattern is a structural pattern, and it deals with the overall structure of the application, rather than simply creation of objects.

Now here I paste some paras from the explaination about proxy pattern from article.
A proxy, in its most general form, is a class functioning as an interface to another thing. The other thing could be anything: a network connection, a large object in memory, a file, or some other resource that is expensive or impossible to duplicate.....

....Typically one instance of the complex object is created, and multiple proxy objects are created, all of which contain a reference to the single original complex object. Any operations performed on the proxies are forwarded to the original object. Once all instances of the proxy are out of scope, the complex object's memory may be deallocated.... .

* So here the complex object is basically a utility object, other parts of the application simply utilize it, but they don't change it state.

This is not at all to contradict you, but its just brainstorming session, which will clear doubts of both of us.
So please correct me if I am wrong any where.

I can't even think of contradicting you as I am a great fan of your articles, they are marvellous.

[r035198x]

/** Prototype Class **/
public class Cookie implements Cloneable {
 
public Object clone()
{
try{
//In an actual implementation of this pattern you would now attach references to
//the expensive to produce parts from the copies that are held inside the prototype.
return this.getClass().newInstance(); // confused here.
}
catch(InstantiationException e)
{
e.printStackTrace();
return null;
}
}
}
 
....}
 

Now my confusion lies here.
>> return this.getClass() .newInstance()
in the clone method.
On one hand it is said, we create clone of the object, but in reality new instance is created. I am not able to understand the logic.

(Prototype Pattern link on wikipedia)

Thanks in Advance for any guidance.

You didn't read the comment! They just returned the new instance to make it compile but the comment says instead of returning a new instance, you would now "attach references to
the expensive to produce parts from the copies that are held inside the prototype." before returning it.

[sumittyagi]

You didn't read the comment! They just returned the new instance to make it compile but the comment says instead of returning a new instance, you would now "attach references to
the expensive to produce parts from the copies that are held inside the prototype." before returning it.

Thanks r035198 for ur reply, I noticed that and indicated that above.
I and jos were discussing the differences between prototype and proxy pattern.

[JosAH]

Hi! jos!
I don't think I am mixing the two patterns.
What I got from wikipeida explainations is:
1. Prototype pattern is a creational pattern, and hence deals with the creation of objects.
Now the purpose of prototype pattern is:
* there may be some standard states of any object (and reaching upto that state could be quite expensive).
* after reaching that state, we could need to change the state for our purpose to be accomplished in a particular scenario.
* there might be more than one scenario which needs to change the state from the standard state.

* so we make a copy of the standard state, and then customize the new object according to our requirements.
* in this way our particular requirement is also fulfilled, and standard state is also not changed, so that we can utilize in another scenario.
(all this explaination is my own assumption, its not written in article, so it may be wrong, so please correct me if I am wrong anywhere)


2. Now comming to proxy pattern:
proxy pattern is a structural pattern, and it deals with the overall structure of the application, rather than simply creation of objects.

Now here I paste some paras from the explaination about proxy pattern from article.
A proxy, in its most general form, is a class functioning as an interface to another thing. The other thing could be anything: a network connection, a large object in memory, a file, or some other resource that is expensive or impossible to duplicate.....

....Typically one instance of the complex object is created, and multiple proxy objects are created, all of which contain a reference to the single original complex object. Any operations performed on the proxies are forwarded to the original object. Once all instances of the proxy are out of scope, the complex object's memory may be deallocated.... .

* So here the complex object is basically a utility object, other parts of the application simply utilize it, but they don't change it state.

This is not at all to contradict you, but its just brainstorming session, which will clear doubts of both of us.
So please correct me if I am wrong any where.

I can't even think of contradicting you as I am a great fan of your articles, they are marvellous.

I opened the Holy Scriptures (the Gang of Four book) and proxies are used when
the real thing can be expensive to create. Prototypes have nothing to do with
a 'real thing being expensive' or not. Prototypes implement an interface (like
Cloneable) that allows a caller to say "give me another one of you".

The Holy Scriptures are correct of course ;-)

kind regards,

Jos