Cad iad na ceithre phoilleir OOP?

Question

Accepted Answer

Tá clár a bhíonn comhdhéanta ar dhá phrionsabal bhunúsach — **Encapsulation, Oidhreachta, Polymorphism agus Abstraction**. Tá Java tógtha ar na prionsabail seo, agus is gá a thuiscint chun cláir Java a dhearadh go deas.

## 1. Encapsulation — sonraí a bhundú + an bhundeaghaidh a cheilt

```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; }
}
```

Ceiltíonn Encapsulation an staid inmheánach (`private`) agus tugann sé rochtain rialaithe (modhanna poiblí/getters/setters). Cosnaíonn sé sin invariants — ní féidir leat iarmhéid dhiúltach a shocraigh go díreach — agus tugann sé deis duit an bhundeaghaidh a athrú gan a bhriseadh.

## 2. Oidhreachta — athúsáid trí ghaol "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"); }
}
```

Tugann Oidhreachta deis don fho-rang an iompar a athúsáid agus a bhraistint ó superclass, agus a bhíonn i bhunuid le "is-a" agus a sheachaint dúblóid chóid.

## 3. Polymorphism — aghaidh amháin, go leor foirmeacha

```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
```

Tugann Polymorphism deis duit fho-ranganna éagsúla a bhreathú go comhionann trí chineál coitíanta, agus an modh forgheal ag an spréachta **iarbhír** ar am rith — ag cruthú cóid foluain agus leantachta.

## 4. Abstraction — a nochtadh cad, a cheilt conas

```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();
```

Nochtann Abstraction (trí dheilbhíní/ranganna teibí) conradh simplíofa agus ceiltíonn sé an fheidhmiú casta — ag solathar deis duit feidhmithe a mhalartú agus an ghreamú a laghdú.

## Cén fáth a bhfuil sé tábhachtach

Is iad na ceithre phoilleir an fhoras ar chóras comhdhéanta OOP agus ar Java féin.

Cosnaíonn Encapsulation slándáil na sonraí agus ceadaíonn sé athrú sábháilte ; tugann Oidhreachta aithris ; tugann Polymorphism solúbthacht agus leantacht (a bhreathú ar iomad chineálta go comhionann, iompar soilsithe ag am rith) ; laghdaíonn Abstraction an ghreamú agus an chastacht.

Níl sé ach i bhfoirm focail an tuiscint ar na coincheapa seo — treorach ar an dóigh ar a struchtúraigh tú na ranganna, ar dhearadh na gcomhéadain agus ar fhógra na gcóras inchomhaireamh agus leantachta.

Is iad sin freisin na hábhair dhifriochta is coitianta toisc go nochtann siad cibé acu a bheith i smaointe an fhorbróra i dtéarmaí ceart OOP, atá riachtanach chun a bheith ag obair go héifeachtach i spásúlacht dhírithe ar ranganna Java.