కన్స్ట్రక్టర్ ఎల్లప్పుడూ దాని ఖచ్చిత తరగతి యొక్క పూర్తిగా కొత్త ఉదాహరణను అందిస్తుంది, తరగతికి స్థిర పేరుతో. ఫ్యాక్టరీ పద్ధతి సాధారణ (తరచుగా స్టాటిక్) పద్ధతి ఇది ఆబ్జెక్టులను సృష్టిస్తుంది — పేరు పెట్టడం, ఏ సబ్టైప్ రిటర్న చేయాలో మరియు కొత్త ఆబ్జెక్ట్ సృష్టించాలో లేదా కాదో గురించి మీకు స్వేచ్ఛ ఇస్తుంది.
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
}
| కన్స్ట్రక్టర్ | ఫ్యాక్టరీ పద్ధతి | |
|---|---|---|
| పేరు | తరగతికి స్థిర | వివరణాత్మక (fromHex) |
| రిటర్న్ టైప్ | సరిగ్గా ఈ తరగతి | ఏదైనా సబ్టైప్ / ఇంటర్ఫేస్ |
| గుర్తింపు | ఎల్లప్పుడూ కొత్త | ఉపాచరణ/పూల్/పునర్ వ్యవహరించు |
| సున్నితంగా విఫలమవుతుంది | విసర్జనలను విసిరివేస్తుంది | null/Optional రిటర్న్ చేయవచ్చు |
Optional<User> u = User.tryParse(json); // a constructor can't return Optional
ఫ్యాక్టరీలు పరోక్షత జోడించి ఏమి నిజమైనదిగా నిర్మించబడిందో దాచివేయవచ్చు. సరళ విలువ సృష్టి కోసం సాధారణ కన్స్ట్రక్టర్ ఉపయోగించండి; పేరు పెట్టడం, బహుమुती రిటర్న్లు లేదా ఉదాహరణ నియంత్రణ అవసరమైనప్పుడు ఫ్యాక్టరీకి చేరుకోండి.
ఫ్యాక్టరీ పద్ధతులు కల్లర్లను కాంక్రీట్ తరగతుల నుండి విడదీస్తాయి — మీరు కాల్ సైట్లను మార్చకుండా భిన్న అమలు లేదా కేశ్డ్ ఉదాహరణను రిటర్న్ చేయవచ్చు.
వారు API లను స్పష్టంగా చేస్తారు: Color.fromHex("#fff") కన్స్ట్రక్టర్ ఓవర్లోడ్ కంటే చక్కగా చదువుతుంది, మరియు నామకరణ ఫ్యాక్టరీలు ఒకే డేటా సభ్యుల కలిగిన బహుళ కన్స్ట్రక్టర్ల అస్పష్టతను తగ్గిస్తాయి.