నాలుగు స్తంభాలు Encapsulation, Abstraction, Inheritance మరియు Polymorphism. కలిసి వారు OOP ఎలా కోడ్ను నిర్వహిస్తుంది మరియు పునర్వినియోగం చేస్తుంది అని వివరిస్తారు.
| స్తంభం | ప్రధాన ఆలోచన |
|---|
| Encapsulation | డేటా + ప్రవర్తన కట్ట; నియంత్రిత ఇంటర్ఫేస్ వెనుక అంతర్గత స్థితిని దాచండి |
| Abstraction | ఒక వస్తువు ఏమి చేస్తుందో బహిర్గతం చేయండి, అది ఎలా చేస్తుందో దాచండి |
| Inheritance | ఒక సబ్క్లాస్ పేరెంట్ క్లాస్ను పునర్వినియోగం చేస్తుంది మరియు విస్తరిస్తుంది |
| Polymorphism | ఒక ఇంటర్ఫేస్, రన్టైమ్లో ఎన్నుకున్న అనేక అమలులు |
abstract class Shape { // ABSTRACTION: "what", not "how"
abstract double area(); // each shape decides its own formula
}
class Circle extends Shape { // INHERITANCE: Circle is a Shape
private double r; // ENCAPSULATION: r is private
Circle(double r) { this.r = r; }
double area() { return Math.PI * r * r; } // POLYMORPHISM: own area()
}
class Square extends Shape {
private double s;
Square(double s) { this.s = s; }
double area() { return s * s; }
}
Shape shape = new Circle(2); // POLYMORPHISM in action:
System.out.println(shape.area()); // calls Circle.area() at runtime
ఇవి సాధనాలు, లక్ష్యాలు కాదు. అవసరం లేని చోట్ల వారసత్వం లేదా సంగ్రహణను బలవంతం చేయడం సంక్లిష్టతను సృష్టిస్తుంది. సమస్యకు సరిపోయే స్తంభం కోసం చేరుకోండి.
ఈ నాలుగు పదాలు OOP డిజైన్ యొక్క భాగస్వామ్య పదకోశం — సంభాషణలు మరియు కోడ్ సమీక్షలు మీరు వాటిని తెలుసుకుందని ఆశ్రయిస్తాయి.
ప్రతిটి స్తంభం ఒక నిర్దిష్ట ప్రయోజనకు మ్యాప్ చేస్తుంది: encapsulation అస్థిరాలను రక్షిస్తుంది, shurukt్ను అర్థం చేసుకోవలసిన దాన్ని తగ్గిస్తుంది, వారసత్వం మరియు బహుళ వస్తువత్వం పునర్వినియోగం మరియు విస్తృతిని ప్రారంభిస్తాయి.
జూనియర్ నుండి సీనియర్ వరకు వివరణాత్మక సమాధానాలతో IT ఇంటర్వ్యూ ప్రశ్నల లైబ్రరీ.
విరాళం