PL/SQL - Programmation Orientée Objet

Salut à toi, aspirant·e programmeur·euse ! Aujourd'hui, nous allons entreprendre un voyage passionnant dans le monde de la Programmation Orientée Objet (POO) en PL/SQL. Ne t'inquiète pas si tu es nouveau·elle en programmation – je serai ton guide amical, expliquant tout pas à pas. Alors, mettons-nous à l'eau !

Qu'est-ce que la Programmation Orientée Objet ?

Avant de commencer, comprenons ce qu'est la POO. Imagine que tu construis une maison avec des blocs Lego. Chaque bloc représente un objet, et tu peux combiner ces blocs de différentes manières pour créer des structures plus complexes. C'est essentiellement ce que fait la POO en programmation – elle nous permet de créer et de manipuler des objets qui représentent des entités du monde réel.

Instanciation d'un Objet

Maintenant, apprenons comment créer (ou "instancier") un objet en PL/SQL. Penses-y comme si tu donnes vie à un personnage Lego dans ton monde de programmation !

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 'Bonjour, mon nom est ' || name || ' et j'ai ' || age || ' ans.';
END;
END;

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

Dans cet exemple, nous avons créé un type d'objet person avec deux attributs (name et age) et une méthode (say_hello). Ensuite, nous avons instancié un objet john et appelé sa méthode say_hello.

Méthodes Membres

Les méthodes membres sont comme des compétences spéciales que nos objets possèdent. Ajoutons une autre méthode à notre objet 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 'Bonjour, mon nom est ' || name || ' et j'ai ' || age || ' ans.';
END;

MEMBER PROCEDURE have_birthday IS
BEGIN
age := age + 1;
DBMS_OUTPUT.PUT_LINE(name || ' a maintenant ' || age || ' ans.');
END;
END;

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

Ici, nous avons ajouté une procédure have_birthday qui augmente l'âge de la personne de 1. C'est comme donner à notre personnage Lego la capacité de fêter ses anniversaires !

Utilisation de la Méthode MAP

La méthode MAP est utilisée pour comparer les objets. C'est comme donner à nos objets une carte d'identité spéciale qui nous aide à les trier. Voyons comment cela fonctionne :

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 || ' est plus âgé');
ELSE
DBMS_OUTPUT.PUT_LINE(jane.name || ' est plus âgée');
END IF;
END;

Dans cet exemple, nous utilisons l'age comme identifiant pour la comparaison. C'est comme comparer des personnages Lego en fonction de leur taille !

Utilisation de la Méthode ORDER

La méthode ORDER est une autre façon de comparer les objets, mais elle nous offre plus de flexibilité que la méthode MAP. C'est comme avoir un juge spécial pour comparer nos personnages 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 || ' est plus âgé');
ELSIF john < jane THEN
DBMS_OUTPUT.PUT_LINE(jane.name || ' est plus âgée');
ELSE
DBMS_OUTPUT.PUT_LINE('Ils ont le même âge');
END IF;
END;

Cette méthode nous permet de définir une logique de comparaison personnalisée. Elle est particulièrement utile lorsque nous voulons comparer des objets en fonction de plusieurs attributs.

Héritage pour les Objets PL/SQL

L'héritage est comme créer un arbre généalogique pour nos objets. Nous pouvons créer de nouveaux types d'objets qui héritent des propriétés et des méthodes des existants. Voyons comment :

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('Salaire annuel : $' || emp.get_annual_salary());
END;

Ici, employee est un enfant de person, héritant de ses attributs et méthodes tout en ajoutant les siens. C'est comme créer un type de personnage Lego spécial qui peut faire tout ce qu'un personnage régulier peut faire, plus encore !

Objets Abstraits en PL/SQL

Les objets abstraits sont comme des plans pour d'autres objets. Ils définissent une structure mais ne peuvent pas être instanciés directement. Créons un objet abstrait :

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('Mon Cercle', 5);
BEGIN
DBMS_OUTPUT.PUT_LINE('Aire de ' || c.name || ' : ' || c.get_area());
END;

Dans cet exemple, shape est un objet abstrait qui définit une structure commune pour toutes les formes. circle est une implémentation concrète de shape. C'est comme avoir un manuel Lego général (l'objet abstrait) et puis créer des modèles Lego spécifiques basés dessus !

Et voilà ! Nous avons couvert les bases de la Programmation Orientée Objet en PL/SQL. Souviens-toi, la pratique rend parfait, donc n'ayez pas peur d'expérimenter avec ces concepts. Bonne programmation !

Méthode	Description
Constructeur	Crée et initialise un objet
Méthode Membre	Retourne une valeur et peut être utilisée dans des instructions SQL
Procédure Membre	Effectue une action mais ne retourne pas de valeur
Méthode MAP	Utilisée pour comparer les objets, basée sur une seule valeur
Méthode ORDER	Utilisée pour comparer les objets, permet une logique de comparaison personnalisée
Méthode FINAL	Ne peut pas être surchargée dans un sous-type
Méthode NON INSTANTIABLE	Doit être surchargée dans un sous-type avant que les objets puissent être instanciés

Credits: Image by storyset