Java ના accesss modifiers શું છે?

Question

Accepted Answer

**Access modifiers** વર્ગો, પદ્ધતિઓ, અને ક્ષેત્રોની **દૃશ્યતા** નિયંત્રણ કરે છે — તેમને કોણ અ્যાક્સેસ કરી શકે છે. તેઓ 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           ✓            ✗                ✗                  ✗
```

ટીપ: modifier છોડી દેવાથી **package-private** (ડિફૉલ્ટ) મળે છે — શુધ્ધ તે જ પેકેજમાં દૃશ્યમાન. આ એક અલગ સ્તર છે, 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`** પદ્ધતિઓ જાહેર કરો. આ અપરિવર્તનીયતાઓ રક્ષણ આપે છે અને તમને આંતરિક પ્રતિનિધિત્વ બદલવાની અનુમતિ આપે છે કોઈપણ વર્તમાન વ્યક્તિને વિના તોડાયા — 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)
```

સિદ્ધાંત: **સૌથી પ્રતિબંધક** modifier વાપરો કે જે હજી કામ કરે (ઓછામાં ઓછું વિશેષાધિકાર) — private થી શરૂ કરો અને શુધ્ધ જરૂર હોય તો જ ખોલો.

## શા માટે તે મહત્વપૂર્ણ છે

Access modifiers એ રીતે છે કે Java **encapsulation** અમલમાં મૂકે છે — OOP નો મૂળભૂત સિદ્ધાંત આંતરિક વિગતો છુપાવવા અને નિયંત્રિત ઇન્ટરફેસ ઉજાગર કરવા પાછળ.

યોગ્ય modifier પસંદ કરવો (ક્ષેત્રો માટે `private` ડિફૉલ્ટ, `public` શુધ્ધ બુદ્ધિમત્તાપૂર્ણ API માટે) ડેટા અખંડતા રક્ષણ આપે છે, બાહ્ય કોડને આંતરિકો પર આધારિત થવાથી રોકે છે (તમે મુક્તપણે રીફેક્ટર કરી શકો), અને વર્ગનો બુદ્ધિમત્તાપૂર્ણ વપરાશ સ્પષ્ટ કરે છે.

ચાર સ્તર સમજવું — ખાસ કરીને વારંવાર-ભૂલી જાય તેવો package-private ડિફૉલ્ટ અને subclass-spanning `protected` — સારી રીતે encapsulated, સાધ્ય વર્ગો અને APIs ડિઝાઇન કરવા માટે આવશ્યક છે, અને નિયંત્રણ કરવા આપનો કોડ કેટલો સિસ્ટમના બાકી ભાગમાં ઉજાગર છે.