లిస్కోవ్ స్థానభ్రంశ సూత్రం (LSP) అనేది సబ్టైప్ యొక్క వస్తువులు వాటి ఆధార రకానికి బదులుగా ఉండవలసి ఉందని చెప్పుతుంది ప్రోగ్రామ్ యొక్క ఖచ్చితత్వాన్ని విచ్ఛిన్నం చేయకుండా. Base ఉపయోగించి కోడ్ పనిచేస్తే, ఏదైనా Subclass ఉపయోగించి కూడా పనిచేయాలి — ఒకే ప్రవర్తన నిరీక్షణలు, ఆశ్చర్యాలు లేవు.
class Rectangle {
protected int w, h;
void setWidth(int w) { this.w = w; }
void setHeight(int h) { this.h = h; }
int area() { return w * h; }
}
class Square extends Rectangle { // "a square IS-A rectangle"... seemingly
void setWidth(int w) { this.w = w; this.h = w; } // keep sides equal
void setHeight(int h) { this.w = h; this.h = h; }
}
void resize(Rectangle r) {
r.setWidth(5);
r.setHeight(4);
assert r.area() == 20; // holds for Rectangle... FAILS for Square (area=16)
}
Square కॉલర్ల ఆధారపడే ఒప్పందాన్ని విచ్ఛిన్నం చేస్తుంది: వెడల్పు మరియు ఎత్తు స్వతంత్రంగా సెట్ చేయడం. ఇది "is-a" ఇంగ్లీష్ పరీక్షలో ఉత్తీర్ణత సాధించినప్పటికీ LSP ను ఉల్లంఘిస్తుంది.
A subtype must NOT:
✗ strengthen preconditions (demand more than the base, e.g. reject valid inputs)
✗ weaken postconditions (promise less than the base)
✗ break invariants the base guarantees
✗ throw new unexpected exceptions for previously valid calls
A subtype MAY:
✓ weaken preconditions (accept more) ✓ strengthen postconditions (promise more)
ఇది ఇన్పుట్ల నిరోధక వైవిధ్యం, అవుట్పుట్ల సహవైవిధ్యం — LSP యొక్క సంఘటన ఆధారం.
వారసత్వాన్ని వదిలివేయండి: Square మరియు Rectangle రెండూ area() ఉన్న Shapeలు, కానీ ఒకటి మరొకటి కాదు. ప్రవర్తనను మోడల్ చేయండి, భోలా వర్గీకరణ కాదు.
LSP బహుశా తిరిగి సురక్షితం చేస్తుంది: దానిని లేకుండా, ప్రతిটి if (x instanceof Square) తనిఖీ వెనుక దొర్లుకుంది, సబ్టైపింగ్ యొక్క ఉద్దేశ్యను పరాజయం చేస్తుంది.
ఇది ప్రవర్తన ఒప్పందాల చుట్టూ వారసత్వ రూపకల్పనను పునర్నిర్వచనం చేస్తుంది, శब్దజాలం కాదు — "కూర్పు ఇష్టపడండి" ఉనికిలో ఉండటానికి నిజమైన కారణం ఏమిటంటే, అనేక is-a సంబంధాలు నిశ్చల్యంగా LSP ను ఉల్లంఘిస్తాయి.