కూర్పు ఇతర వస్తువులను కలిగి ("కలిగి-ఒక" సంబంధం) మరియు వాటికి위임 చేయడం ద్వారా ప్రవర్తనను నిర్మిస్తుంది. వారసత్వం తరగతిని విస్తరించడం ("ఉంది-ఒక") ద్వారా ప్రవర్తనను పొందుతుంది. "కూర్పుకు ఐచ్ఛికం ఇవ్వండి" సలహా ఉనికిలో ఉంది, ఎందుకంటే వారసత్వం బేస్ క్లాస్కు గట్టి, నిస్తేజ కలపకను సృష్టిస్తుంది, అయితే కూర్పు సరళంగా ఉంటుంది.
<T> <T> {
{ add(x); }
T { remove(size() - ); }
}
class Stack<T> {
private final List<T> items = new ArrayList<>(); // HAS-A list
void push(T x) { items.add(x); }
T pop() { return items.remove(items.size() - 1); }
// only push/pop are exposed → LIFO invariant is safe
}
జాబితా యొక్క పైన్ కలిగి ఉండటం ద్వారా, Stack కేవలం కోరుకున్న కార్యకలాపాలను బహిర్గతం చేస్తుంది.
| కూర్పు | వారసత్వం |
|---|---|
| సరళమైనది, రানটైమ్లో భాగాలను మార్చండి | సంకలనం సమయంలో నిర్ణయించారు |
| అంతర్గతాన్ని ఒసగుతుంది (위임) | సంపూర్ణ ఇంటర్ఫేస్ను వారసించుకుంటుంది |
| మరింత వైర్లు/బాయిలర్ప్లేట్ | నిజమైనది ఉంది-ఒక కోడ్ తక్కువ |
| నిస్తేజ బేస్ క్లాస్ను నిరోధిస్తుంది | బేస్ మారితే సబ్క్లాస్ విచ్ఛిన్నమవుతుంది |
వారసత్వాన్ని నిజమైన, స్థిరమైన విషయానికే ఉపయోగించండి-ఒక సంబంధాలు; "ఈ ప్రవర్తన నాకు కావాలి" కూర్పును ఉపయోగించండి.
వారసత్వం తల్లిదండ్రుల సంపూర్ణ ఇంటర్ఫేస్ను బహిర్గతం చేస్తుంది, కాబట్టి సబ్క్లాస్ దాని స్వంత ఒప్పందాన్ని పూర్తిగా నియంత్రించలేము — Stack extends ArrayList లీక్ క్లాసిక్ ఉదాహరణ.
కూర్పు సంబంధాలను స్పష్టమైన మరియు మార్చగల్లిగా ఉంచుతుంది, అందుకే ఆధారపడటం ఇంజెక్షన్, వ్యూహ నమూనాలు మరియు చాలా సరళమైన డిజైన్లు దానిపై ఆధారపడతాయి.