Design pattern for creating an object from another object in different ways

I have to create an object X using properties of object Y (both are of same type) in 4-5 different ways i.e. depending upon situation, those properties of Y can be used to initialize X in different ways. One way to do is , create an object X using default constructor and then set its properties, 开发者_JAVA百科but it has a disadvantage that if some problem occurs then we have an object in inconsistent state. Another way to do is create different constructors for all the cases with dummy parameters, which sounds really bad. Is there any good design pattern i can use here ?

If both objects are of the same type, you can use factory methods:

public class Foo {
    ...
    public Foo withBar(...) {
        Foo f = new Foo(this.param);
        f.setBar(...);
        return f;
    }

    public Foo withBaz(...) {
        Foo f = new Foo(this.param);
        f.setBaz(...);
        return f;
    }
}
...
Foo y = ...;
Foo x = y.withBar(...);

If types are different, you can make factory methods static and pass Y as a parameter.

Sounds like you could use a slightly-specialized version of the Factory Pattern. E.g. Part of building an object could be to pass in an existing instance (or interface to an instance) to initialize a new object.

Nice explanation for Factory Pattern can be found here.
Also Joshua Bloch is his book Effective Java suggests some good advantages of using static factories

This sounds like a case for the Abstract Factory pattern.

In addition to Factory Pattern, take a look at the Builder Pattern. This pattern allows the client to configure how an object is constructed.