Guide

Guida pratica al polimorfismo in informatica

Trovalost.it

Il polimorfismo permette di scrivere codice più flessibile e generico, facilitando la manutenzione e l’estensione delle applicazioni. In C++, il polimorfismo è implementato attraverso l’uso di metodi virtuali e l’ereditarietà. In Python, il polimorfismo è più dinamico grazie alla natura flessibile del linguaggio stesso.

Il polimorfismo è un concetto fondamentale della programmazione orientata agli oggetti (OOP) che permette a oggetti di classi diverse di essere trattati come se fossero oggetti della stessa classe. Questo è possibile attraverso l’uso di metodi e proprietà comuni che le classi condividono. Ci sono due principali tipi di polimorfismo:

  1. Polimorfismo a tempo di compilazione (Statico): Ottiene attraverso il sovraccarico dei metodi e degli operatori.
  2. Polimorfismo a tempo di esecuzione (Dinamico): Ottiene attraverso l’ereditarietà e l’uso di metodi virtuali.

Di seguito, mostrerò esempi di polimorfismo in C++ e Python. Un primo esempio semplice di polimorfismo può essere quello di una funzione speak che viene implementata da diverse classi di animali. Ogni animale ha un modo diverso di “parlare”, ma possiamo chiamare il metodo speak su qualsiasi animale e ottenere il comportamento appropriato.

class Animal:
 def speak(self):
  print("Some generic animal sound")
class Dog(Animal):
 def speak(self):  
  print("Woof!")
class Cat(Animal):
 def speak(self):
  print("Meow!")
def make_animal_speak(animal):
  animal.speak()
dog = Dog()
cat = Cat()
animal = Animal()
make_animal_speak(dog) # Output: Woof!
make_animal_speak(cat) # Output: Meow!
make_animal_speak(animal) # Output: Some generic animal sound

Polimorfismo in C++

1. Polimorfismo a tempo di compilazione (Sovraccarico dei metodi)

#include <iostream>
using namespace std;
class Print {
public:
void show(int i) {
cout << "Intero: " << i << endl;
}
void show(double f) {
cout << "Float: " << f << endl;
}
void show(string s) {
cout << "Stringa: " << s << endl;
}
};
int main() {
Print p;
p.show(10);
p.show(10.5);
p.show("Ciao");
return 0;
}

2. Polimorfismo a tempo di esecuzione (Metodi virtuali)

#include <iostream>
using namespace std;
class Base {
public:
virtual void show() {
cout << "Base class" << endl;
}
};
class Derived : public Base {
public:
void show() override {
cout << "Derived class" << endl;
}
};
int main() {
Base* b;
Derived d;
b = &d;
b->show(); // Questo chiamerà il metodo show() della classe Derived
return 0;
}

Polimorfismo in Python

1. Polimorfismo a tempo di compilazione (Sovraccarico dei metodi)

In Python, il sovraccarico dei metodi non è supportato direttamente come in C++. Tuttavia, si può ottenere un comportamento simile usando valori predefiniti o *args.

class Print:
def show(self, *args):
if len(args) == 1:
if isinstance(args[0], int):
print(f"Intero: {args[0]}")
elif isinstance(args[0], float):
print(f"Float: {args[0]}")
elif isinstance(args[0], str):
print(f"Stringa: {args[0]}")
p = Print()
p.show(10)
p.show(10.5)
p.show("Ciao")

Poliformismo a run time

class Base:
def show(self):
print("Base class")
class Derived(Base):
def show(self):
print("Derived class")
b = Base()
d = Derived()
b.show() # Questo chiamerà il metodo show() della classe Base
d.show() # Questo chiamerà il metodo show() della classe Derived
b = d
b.show() # Questo chiamerà il metodo show() della classe Derived grazie al polimorfismo

👇 Contenuti da non perdere 👇

Questo sito esiste da 4832 giorni (13 anni), e contiene 6020 articoli (circa 4.816.000 parole in tutto), con la bellezza di 32 tool gratuiti.