PL/SQL - Programmazione Orientata agli Oggetti

Ciao a tutti, aspiranti programmatori! Oggi ci imbarchiamo in un viaggio emozionante nel mondo della Programmazione Orientata agli Oggetti (OOP) in PL/SQL. Non preoccupatevi se siete nuovi alla programmazione - sarò il vostro guida amichevole, spiegando tutto passo per passo. Allora, entriamo nel vivo!

Cos'è la Programmazione Orientata agli Oggetti?

Prima di iniziare, capiamo di cosa si occupa l'OOP. Immagina di costruire una casa con i mattoncini Lego. Ogni mattoncino rappresenta un oggetto, e puoi combinare questi mattoncini in vari modi per creare strutture più complesse. Questo è essenzialmente ciò che fa l'OOP nella programmazione - ci permette di creare e manipolare oggetti che rappresentano entità del mondo reale.

Istanziare un Oggetto

Ora, impariamo come creare (o "istanziare") un oggetto in PL/SQL. Pensate a questo come portare un personaggio Lego alla vita nel vostro mondo di programmazione!

CREATE OR REPLACE TYPE person AS OBJECT (
name VARCHAR2(50),
age NUMBER,
MEMBER FUNCTION say_hello RETURN VARCHAR2
);

CREATE OR REPLACE TYPE BODY person AS
MEMBER FUNCTION say_hello RETURN VARCHAR2 IS
BEGIN
RETURN 'Ciao, mi chiamo ' || name || ' e ho ' || age || ' anni.';
END;
END;

DECLARE
john person;
BEGIN
john := person('John Doe', 30);
DBMS_OUTPUT.PUT_LINE(john.say_hello());
END;

In questo esempio, abbiamo creato un tipo oggetto person con due attributi (name e age) e un metodo (say_hello). Poi abbiamo istanziato un oggetto john e chiamato il suo metodo say_hello.

Metodi Membri

I metodi membri sono come speciali capacità che i nostri oggetti possiedono. Aggiungiamo un altro metodo al nostro oggetto person:

CREATE OR REPLACE TYPE person AS OBJECT (
name VARCHAR2(50),
age NUMBER,
MEMBER FUNCTION say_hello RETURN VARCHAR2,
MEMBER PROCEDURE have_birthday
);

CREATE OR REPLACE TYPE BODY person AS
MEMBER FUNCTION say_hello RETURN VARCHAR2 IS
BEGIN
RETURN 'Ciao, mi chiamo ' || name || ' e ho ' || age || ' anni.';
END;

MEMBER PROCEDURE have_birthday IS
BEGIN
age := age + 1;
DBMS_OUTPUT.PUT_LINE(name || ' ora ha ' || age || ' anni.');
END;
END;

DECLARE
john person;
BEGIN
john := person('John Doe', 30);
john.have_birthday();
DBMS_OUTPUT.PUT_LINE(john.say_hello());
END;

Qui, abbiamo aggiunto una procedura have_birthday che incrementa l'età della persona di 1. È come dare al nostro personaggio Lego l'abilità di festeggiare i compleanni!

Utilizzo del Metodo MAP

Il metodo MAP viene utilizzato per confrontare oggetti. È come dare ai nostri oggetti una speciale carta d'identità che ci aiuta a ordinare le cose. Vediamo come funziona:

CREATE OR REPLACE TYPE person AS OBJECT (
name VARCHAR2(50),
age NUMBER,
MAP MEMBER FUNCTION get_id RETURN NUMBER
);

CREATE OR REPLACE TYPE BODY person AS
MAP MEMBER FUNCTION get_id RETURN NUMBER IS
BEGIN
RETURN age;
END;
END;

DECLARE
john person := person('John Doe', 30);
jane person := person('Jane Smith', 25);
BEGIN
IF john > jane THEN
DBMS_OUTPUT.PUT_LINE(john.name || ' è più vecchio');
ELSE
DBMS_OUTPUT.PUT_LINE(jane.name || ' è più vecchio');
END IF;
END;

In questo esempio, utilizziamo l'età come ID per il confronto. È come confrontare i personaggi Lego in base alla loro altezza!

Utilizzo del Metodo ORDER

Il metodo ORDER è un altro modo per confrontare oggetti, ma offre maggiore flessibilità rispetto al metodo MAP. È come avere un giudice speciale per confrontare i nostri personaggi Lego:

CREATE OR REPLACE TYPE person AS OBJECT (
name VARCHAR2(50),
age NUMBER,
ORDER MEMBER FUNCTION compare(p person) RETURN INTEGER
);

CREATE OR REPLACE TYPE BODY person AS
ORDER MEMBER FUNCTION compare(p person) RETURN INTEGER IS
BEGIN
IF self.age < p.age THEN
RETURN -1;
ELSIF self.age > p.age THEN
RETURN 1;
ELSE
RETURN 0;
END IF;
END;
END;

DECLARE
john person := person('John Doe', 30);
jane person := person('Jane Smith', 30);
BEGIN
IF john > jane THEN
DBMS_OUTPUT.PUT_LINE(john.name || ' è più vecchio');
ELSIF john < jane THEN
DBMS_OUTPUT.PUT_LINE(jane.name || ' è più vecchio');
ELSE
DBMS_OUTPUT.PUT_LINE('Hanno la stessa età');
END IF;
END;

Questo metodo ci permette di definire una logica di confronto personalizzata. È particolarmente utile quando vogliamo confrontare oggetti in base a più attributi.

Eredità per Oggetti PL/SQL

L'eredità è come creare un albero genealogico per i nostri oggetti. Possiamo creare nuovi tipi oggetto che ereditano proprietà e metodi da quelli esistenti. Vediamo come:

CREATE OR REPLACE TYPE employee UNDER person (
job_title VARCHAR2(50),
salary NUMBER,
MEMBER FUNCTION get_annual_salary RETURN NUMBER
);

CREATE OR REPLACE TYPE BODY employee AS
MEMBER FUNCTION get_annual_salary RETURN NUMBER IS
BEGIN
RETURN salary * 12;
END;
END;

DECLARE
emp employee := employee('Alice Johnson', 35, 'Manager', 5000);
BEGIN
DBMS_OUTPUT.PUT_LINE(emp.say_hello());
DBMS_OUTPUT.PUT_LINE('Stipendio annuale: $' || emp.get_annual_salary());
END;

Qui, employee è un figlio di person, ereditando i suoi attributi e metodi mentre ne aggiunge altri. È come creare un tipo speciale di personaggio Lego che può fare tutto ciò che può fare un personaggio regolare, e di più!

Oggetti Astratti in PL/SQL

Gli oggetti astratti sono come modelli per altri oggetti. Definiscono una struttura ma non possono essere istanziati direttamente. Creiamo un oggetto astratto:

CREATE OR REPLACE TYPE shape AS OBJECT (
name VARCHAR2(50),
MEMBER FUNCTION get_area RETURN NUMBER
) NOT INSTANTIABLE NOT FINAL;

CREATE OR REPLACE TYPE circle UNDER shape (
radius NUMBER,
OVERRIDING MEMBER FUNCTION get_area RETURN NUMBER
);

CREATE OR REPLACE TYPE BODY circle AS
OVERRIDING MEMBER FUNCTION get_area RETURN NUMBER IS
BEGIN
RETURN 3.14159 * radius * radius;
END;
END;

DECLARE
c circle := circle('My Circle', 5);
BEGIN
DBMS_OUTPUT.PUT_LINE('Area di ' || c.name || ': ' || c.get_area());
END;

In questo esempio, shape è un oggetto astratto che definisce una struttura comune per tutte le forme. circle è una implementazione concreta di shape. È come avere un manuale generale di Lego (l'oggetto astratto) e poi creare modelli Lego specifici basati su di esso!

Ecco tutto! Abbiamo coperto le basi della Programmazione Orientata agli Oggetti in PL/SQL. Ricorda, la pratica rende perfetti, quindi non aver paura di sperimentare con questi concetti. Buon coding!

Credits: Image by storyset