01 - Introduzione alla Programmazione Orientata agli Oggetti

Cos'è la Programmazione Orientata agli Oggetti

La Programmazione Orientata agli Oggetti (OOP) è un paradigma di programmazione che organizza il software attorno a oggetti anziché funzioni e logica. Un oggetto combina dati (attributi) e comportamenti (metodi) in un'unica entità, rispecchiando il modo in cui pensiamo al mondo reale.

Dal Procedurale alla OOP

Nella programmazione procedurale, dati e funzioni sono separati. Nella OOP, sono incapsulati insieme, rendendo il codice più modulare e intuitivo.

// Dati separati
let userName = "Mario";
let userAge = 30;

// Funzioni separate
function printUser(name, age) {{ '{' }}
  console.log(name, age);
{{ '}' }}

// Dati e comportamenti insieme
class User {{ '{' }}
  name: string;
  age: number;

  print() {{ '{' }}
    console.log(this.name, this.age);
  {{ '}' }}
{{ '}' }}

I Quattro Pilastri della OOP

1. Incapsulamento

Nasconde i dettagli interni, esponendo solo ciò che è necessario attraverso modificatori di accesso (private, protected, public).

class BankAccount {{ '{' }}
  private balance: number = 0;

  deposit(amount: number) {{ '{' }}
    if (amount > 0) this.balance += amount;
  {{ '}' }}

  getBalance() {{ '{' }}
    return this.balance;
  {{ '}' }}
{{ '}' }}

const account = new BankAccount();
account.deposit(100);
console.log(account.getBalance()); // 100
// account.balance = 999; // ❌ Errore: balance è private

2. Ereditarietà

Permette di creare nuove classi basate su classi esistenti, riutilizzando e estendendo funzionalità.

class Animal {{ '{' }}
  protected name: string;

  constructor(name: string) {{ '{' }}
    this.name = name;
  {{ '}' }}

  move() {{ '{' }}
    console.log(`${{ '{' }}this.name{{ '}' }} si muove`);
  {{ '}' }}
{{ '}' }}

class Dog extends Animal {{ '{' }}
  bark() {{ '{' }}
    console.log(`${{ '{' }}this.name{{ '}' }} abbaia`);
  {{ '}' }}
{{ '}' }}

const dog = new Dog("Rex");
dog.move(); // "Rex si muove"
dog.bark(); // "Rex abbaia"

3. Polimorfismo

Permette di trattare oggetti di classi diverse attraverso un'interfaccia comune, con comportamenti specifici per ogni tipo.

interface Shape {{ '{' }}
  area(): number;
{{ '}' }}

class Circle implements Shape {{ '{' }}
  constructor(private radius: number) {{ '{' }}{{ '}' }}
  area() {{ '{' }} return Math.PI * this.radius ** 2; {{ '}' }}
{{ '}' }}

class Square implements Shape {{ '{' }}
  constructor(private side: number) {{ '{' }}{{ '}' }}
  area() {{ '{' }} return this.side ** 2; {{ '}' }}
{{ '}' }}

// Stesso metodo, comportamenti diversi
function printArea(shape: Shape) {{ '{' }}
  console.log(shape.area());
{{ '}' }}

printArea(new Circle(5));  // ~78.5
printArea(new Square(5));  // 25

4. Astrazione

Nasconde la complessità mostrando solo le caratteristiche essenziali. Definiamo "cosa" fa un oggetto, non "come" lo fa.

Quando Usare la OOP

Esempio Pratico Completo

class Product {{ '{' }}
  constructor(
    public name: string,
    private price: number
  ) {{ '{' }}{{ '}' }}

  getPrice(): number {{ '{' }}
    return this.price;
  {{ '}' }}
{{ '}' }}

class ShoppingCart {{ '{' }}
  private items: Product[] = [];

  addItem(product: Product) {{ '{' }}
    this.items.push(product);
  {{ '}' }}

  getTotal(): number {{ '{' }}
    return this.items.reduce((sum, item) => sum + item.getPrice(), 0);
  {{ '}' }}

  checkout() {{ '{' }}
    console.log(`Totale: €${{ '{' }}this.getTotal(){{ '}' }}`);
    this.items = [];
  {{ '}' }}
{{ '}' }}

// Utilizzo
const cart = new ShoppingCart();
cart.addItem(new Product("Laptop", 999));
cart.addItem(new Product("Mouse", 25));
cart.checkout(); // "Totale: €1024"

Conclusione

La OOP è un paradigma potente che rende il codice più organizzato, riutilizzabile e manutenibile. I quattro pilastri (Incapsulamento, Ereditarietà, Polimorfismo, Astrazione) lavorano insieme per creare software robusto e scalabile. Nei prossimi articoli, esploreremo ciascun pilastro in dettaglio con esempi pratici avanzati.