Java యొక్క యాక్సెస్ మోడిఫైయర్‌లు ఏవి?

Question

Accepted Answer

**యాక్సెస్ మోడిఫైయర్‌లు** తరగతులు, పద్ధతులు మరియు ఫీల్డ్‌ల **దృశ్యమానతను** నియంత్రిస్తాయి — వారు దానిని ఎవరు యాక్సెస్ చేయవచ్చు. అవి encapsulation ల వెనుక ఉన్న మెకানిజం. Java కు నాలుగు స్థాయిలు ఉన్నాయి, చాలా నిబంధనలు నుండి కనిష్ట నిబంధనల వరకు.

## నాలుగు స్థాయిలు

```java
public class Example {
    public int a;        // accessible from ANYWHERE
    protected int b;     // same package + SUBCLASSES (even in other packages)
    int c;               // package-private (DEFAULT, no keyword) — same package only
    private int d;       // accessible ONLY within THIS class
}
```

## దృశ్యమానత పట్టిక

```text
Modifier      Same class  Same package  Subclass (other pkg)  Everywhere
────────────────────────────────────────────────────────────────────────
public            ✓            ✓                ✓                  ✓
protected         ✓            ✓                ✓                  ✗
(default)         ✓            ✓                ✗                  ✗
private           ✓            ✗                ✗                  ✗
```

గమనిక: మోడిఫైయర్‌ను వదిలివేయడం **package-private** (డిఫాల్ట్) ఇస్తుంది — అదే package లో మాత్రమే కనిపిస్తుంది. ఇది ఒక విభిన్న స్థాయి, public లానికి సమానమైనది కాదు.

## అవి encapsulation ను ఎలా ఉపయోగపడతాయి

```java
public class BankAccount {
    private double balance;          // hidden — protect the data

public void deposit(double amt) { // public API — controlled access
        if (amt > 0) balance += amt;
    }
    public double getBalance() {      // read-only access to private data
        return balance;
    }
}
// outside code CANNOT do account.balance = -1000 (it's private)
```

ప్రామాణిక నమూనా: ఫీల్డ్‌లను **`private`** చేసి నియంత్రిత **`public`** పద్ధతులను బహిర్గతం చేయండి. ఇది invariants ను రక్షిస్తుంది మరియు కాలర్‌లను విచ్ఛిన్నం చేయకుండా అంతర్గత ప్రాతినిధ్యాన్ని మార్చడానికి అనుమతిస్తుంది — encapsulation యొక్క సారాంశం.

## ఆచరణ మార్గదర్శకత్వం

```text
✓ Fields → private (almost always); expose via methods if needed
✓ Public API methods → public
✓ Internal helpers → private
✓ For subclasses to access/override → protected
✓ Classes → public (usable anywhere) or package-private (internal to a module)
```

సూత్రం: ఇప్పటికీ పని చేసే **అత్యంత నిబంధన** మోడిఫైయర్‌ను ఉపయోగించండి (కనీస అధికారం) — private తో ప్రారంభించండి మరియు అవసరమైనప్పుడు మాత్రమే తెరవండి.

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

యాక్సెస్ మోడిఫైయర్‌లు Java **encapsulation** ను ఎలా అమలు చేస్తుంది — అంతర్గత వివరాలను దాచడానికి మరియు నియంత్రిత ఇంటర్‌ఫేస్‌లను బహిర్గతం చేసే OOP యొక్క ప్రాథమిక సూత్రం.

సరైన మోడిఫైయర్‌ను ఎంచుకోవడం (ఫీల్డ్‌ల కోసం `private` ను ఉపయోగించండి, ఉద్దేశిత API కోసం మాత్రమే `public`) డేటా సమగ్రతను రక్షిస్తుంది, బాహ్య కోడ్ ఇంటర్నల్‌ల నుండి ఆధారపడటాన్ని నిరోధిస్తుంది (కాబట్టి మీరు స్వేచ్ఛగా refactor చేయవచ్చు), మరియు తరగతి యొక్క ఉద్దేశ్య ఉపయోగాన్ని స్పష్టం చేస్తుంది.

నాలుగు స్థాయిలను అన్నీ అర్థం చేసుకోవడం — ముఖ్యంగా తరచుగా విస్మరించిన package-private డిఫాల్ట్ మరియు subclasses లో విస్తరించిన `protected` —잘 encapsulated, నిర్వహణీయమైన తరగతులు మరియు APIs ను రూపకల్పన చేయడానికి మరియు మీ కోడ్ యొక్క ఎంత భాగం సిస్టమ్ యొక్క మిగిలిన భాగానికి బహిర్గతమవుతుందో నియంత్రించడానికి అవసరం.