ਇੱਕ constructor ਹਮੇਸ਼ਾ ਆਪਣੀ ਬਿਲਕੁਲ ਉਸੇ class ਦੀ ਇੱਕ ਬਿਲਕੁਲ ਨਵੀਂ instance ਵਾਪਸ ਕਰਦਾ ਹੈ, ਅਤੇ ਨਾਮ class ਤੇ ਸਥਿਰ ਹੁੰਦਾ ਹੈ। ਇੱਕ factory method ਇੱਕ ਆਮ (ਅਕਸਰ static) method ਹੈ ਜੋ objects ਬਣਾਉਂਦਾ ਹੈ — ਤੁਹਾਨੂੰ naming, ਕਿਹੜੀ subtype ਵਾਪਸ ਕਰਨੀ ਹੈ, ਅਤੇ ਕੀ ਇੱਕ ਨਵੀ object ਬਣਾਨੀ ਹੈ ਉੱਪਰ ਸੁਤੰਤਰਤਾ ਦਿੰਦਾ ਹੈ।
public class Color {
private final int r, g, b;
private Color(int r, int g, int b) { this.r=r; this.g=g; this.b=b; }
// Named factories: clearer intent than overloaded constructors
public static Color fromRgb(int r, int g, int b) { return new Color(r,g,b); }
public static Color fromHex(String hex) { /* parse */ return new Color(0,0,0); }
// Can return a CACHED instance instead of always allocating
private static final Color BLACK = new Color(0,0,0);
public static Color black() { return BLACK; } // no 'new' every call
}
| Constructor | Factory method | |
|---|---|---|
| ਨਾਮ | Class ਤੇ ਸਥਿਰ | ਵਰਣਨਸ਼ੀਲ (fromHex) |
| ਵਾਪਸ ਕਰਨ ਦੀ ਕਿਸਮ | ਬਿਲਕੁਲ ਇਹ class | ਕੋਈ ਵੀ subtype / interface |
| ਪਛਾਣ | ਹਮੇਸ਼ਾ ਨਵੀਂ | Cache/pool/reuse ਕਰ ਸਕਦਾ ਹੈ |
| ਸ਼ਰਾਫ਼ਤ ਨਾਲ ਫੈਲ ਹੋ ਸਕਦਾ ਹੈ | Throws | Null/Optional ਵਾਪਸ ਕਰ ਸਕਦਾ ਹੈ |
Optional<User> u = User.tryParse(json); // a constructor can't return Optional
Factories indirection ਜੋੜਦੀਆਂ ਹਨ ਅਤੇ ਲੁਕਾ ਸਕਦੀਆਂ ਹਨ ਕਿ ਕੀ ਅਸਲ ਵਿੱਚ ਬਣਾਇਆ ਗਿਆ ਹੈ। ਸਾਧਾਰਨ value ਬਣਾਉਣ ਲਈ ਸਰਲ constructor ਵਰਤੋ; naming, polymorphic returns, ਜਾਂ instance control ਦੀ ਲੋੜ ਵਾਲੇ ਸਮੇ factory ਲਈ ਜਾਓ।
Factory methods callers ਨੂੰ concrete classes ਤੋਂ ਵੱਖ ਕਰਦੇ ਹਨ — ਤੁਸੀਂ call sites ਬਿਨਾ ਬਦਲਾਵ ਦੇ ਇੱਕ ਵੱਖਰੀ implementation ਜਾਂ cached instance ਵਾਪਸ ਕਰ ਸਕਦੇ ਹੋ।
وہ APIs ਨੂੰ ਵੀ ਸਾਫ ਸਾਫ ਬਣਾਉਂਦੇ ਹਨ: Color.fromHex("#fff") ਕਿਸੇ constructor overload ਨਾਲੋਂ ਬਿਹਤਰ ਪੜ੍ਹਦਾ ਹੈ, ਅਤੇ named factories ਕਈ same-typed constructors ਦੀ ਅਸਪਸ਼ਟਤਾ ਨੂੰ ਖਤਮ ਕਰਦੇ ਹਨ।