Guida pratica al polimorfismo in informatica


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.

Annuncio:

Cerchi un hosting economico per il tuo sito o blog? Tophost ti aspetta (clicca qui) – Puoi anche usare il coupon sconto esclusivo 7NSS5HAGD5UC2 per spendere di meno ;-)

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

👇 Da non perdere 👇



Questo portale web esiste da 4549 giorni (12 anni), e contiene ad oggi 4117 articoli (circa 3.293.600 parole in tutto) e 18 servizi online gratuiti. – Leggi un altro articolo a caso
Privacy e termini di servizio / Cookie - Il nostro network è composto da Lipercubo , Pagare.online e Trovalost
Seguici su Telegram, ne vale la pena ❤️ ➡ @trovalost
Questo sito contribuisce alla audience di sè stesso.