OOPের నాలుగు స్తంభాలు ఏవి?

Question

Accepted Answer

Object-oriented programming నాలుగు ప్రధాన సూత్రాలపై ఆధారపడి ఉంటుంది — **Encapsulation, Inheritance, Polymorphism, మరియు Abstraction**. Java ఈ సూత్రాల చుట్టూ నిర్మితమైనది, మరియు వాటిని అర్థం చేసుకోవడం Java ప్రోగ్రామ్‌లను రూపకల్పన చేయడానికి ఆధారమైనది.

## 1. Encapsulation — డేటా + అంతర్గత వివరాలను లুకానికి చేయండి

```java
public class Account {
    private double balance;          // hidden — can't be accessed directly outside

public void deposit(double amount) {   // controlled access via methods
        if (amount > 0) balance += amount;  // can enforce rules
    }
    public double getBalance() { return balance; }
}
```

Encapsulation అంతర్గత స్థితిని (`private`) దాచిపెట్టి, నియంత్రిత ప్రవేశాన్ని (public methods/getters/setters) బహిర్గతం చేస్తుంది. ఇది అస్థిరతలను రక్షిస్తుంది — మీరు ప్రత్యక్ష ప్రతికూల నిల్వను సెట్ చేయలేరు — మరియు కాల్‌చేసేవారిని విచ్ఛిన్నం చేయకుండా అంతర్గతమైన విషయాలను మార్చడానికి మిమ్మల్ని అనుమతిస్తుంది.

## 2. Inheritance — "is-a" సంబంధం ద్వారా పునర్వినియోగం

```java
class Animal {
    void eat() { System.out.println("eating"); }
}
class Dog extends Animal {   // Dog IS-A Animal — inherits eat()
    void bark() { System.out.println("woof"); }
}
```

Inheritance సబ్‌క్లాసను సూపర్‌క్లాస్ యొక్క ప్రవర్తనను పునర్వినియోగం చేయడానికి మరియు విస్తరించడానికి అనుమతిస్తుంది, "is-a" సంబంధాలను మోడలింగ్ చేస్తుంది మరియు కోడ్ పునరావృత్తిని నివారిస్తుంది.

## 3. Polymorphism — ఒక ఇంటర్‌ఫేస్, అనేక రూపాలు

```java
Animal a = new Dog();     // a Dog treated as an Animal
a.makeSound();            // calls Dog's overridden version at RUNTIME (dynamic dispatch)

// the same method behaves differently depending on the actual object:
List<Animal> animals = List.of(new Dog(), new Cat());
for (Animal animal : animals) animal.makeSound(); // each makes its own sound
```

Polymorphism వివిధ సబ్‌క్లాస్‌లను సాధారణ రకం ద్వారా ఏకరీతిగా చికిత్స చేయడానికి మిమ్మల్ని అనుమతిస్తుంది, రানటైమ్‌లో **వాస్తవ** ఆబ్జెక్ట్ యొక్క ఓవర్‌రైడ్ చేసిన పద్ధతి పిలువబడుతుంది — సరళమైన, విస్తరించదగిన కోడ్‌ను ప్రారంభించడం.

## 4. Abstraction — బహిర్గతం చేయండి ఎవరు, దాచిపెట్టండి ఎలా

```java
interface PaymentProcessor {
    void pay(double amount);   // WHAT it does, not HOW
}
class StripeProcessor implements PaymentProcessor {
    public void pay(double amount) { /* complex implementation hidden */ }
}
// callers depend on the abstraction, not the concrete implementation
PaymentProcessor processor = new StripeProcessor();
```

Abstraction (interfaces/abstract classes ద్వారా) సరళమైన ఒప్పందాన్ని బహిర్గతం చేస్తుంది సంక్లిష్ట అమలును దాచిపెట్టేటప్పుడు — మీరు అమలులను విస్థాపనం చేయడానికి మరియు సంযోగాన్ని తగ్గించడానికి అనుమతిస్తుంది.

## ఇది ఎందుకు ముఖ్యమైనది

నాలుగు స్తంభాలు object-oriented డిజైన్ మరియు Java కూడా చాలా ఆధారం.

Encapsulation డేటా సమగ్రతను రక్షిస్తుంది మరియు సురక్షితమైన మార్పును ప్రారంభించి; inheritance పునర్వినియోగాన్ని ప్రోత్సహిస్తుంది; polymorphism సరళత మరియు విస్తరణను (అనేక రకాలను ఏకరీతిగా చికిత్స చేయండి, ప్రవర్తన రানటైమ్‌లో పరిష్కరించబడుతుంది) అందిస్తుంది; abstraction సంయోగం మరియు సంక్లిష్టతను తగ్గిస్తుంది.

వాటిని అర్థం చేసుకోవడం కేవలం పదజాలం కాదు — కక్ష‌లను ఎలా నిర్మించాలో, APIs ను ఎలా రూపకల్పన చేయాలో, మరియు నిర్వహణీయమైన, విస్తరించదగిన సిస్టమ్‌లను ఎలా నిర్మించాలో మార్గనిర్దేశం చేస్తుంది.

వారు చాలా సాధారణ साক్షాత్కార విషయాలలో కూడా ఎందుకంటే అవి డెవలపర్ సరిగ్గా OOP పదాలలో ఆలోచిస్తుందో ఇవ్వాటా, ఇది Java యొక్క class-centric ఈకోసిస్టమ్‌లో సమర్థవంతంగా పని చేయడానికి అవసరం.