El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència

HOME

El polimorfisme és un dels quatre pilars de la Programació Orientada a Objectes (POO), juntament amb l'encapsulació, l'herència i l'abstracció. El terme "polimorfisme" prové del grec i significa "moltes formes". En el context de la programació, el polimorfisme permet que una interfície única sigui utilitzada per a representar diferents tipus d'objectes.

Conceptes Clau

Polimorfisme en temps de compilació (sobrecàrrega de mètodes):
- Permet tenir múltiples mètodes amb el mateix nom però amb diferents signatures (paràmetres).
- La resolució del mètode adequat es fa en temps de compilació.
Polimorfisme en temps d'execució (sobreescriptura de mètodes):
- Permet que una subclasse proporcioni una implementació específica d'un mètode que ja està definit en la seva superclasse.
- La resolució del mètode adequat es fa en temps d'execució.

Exemples Pràctics

Polimorfisme en Temps de Compilació (Sobrecàrrega de Mètodes)

class PolimorfismeCompilacio {
    // Mètode sobrecarregat amb un paràmetre
    public void mostrar(int a) {
        System.out.println("Nombre enter: " + a);
    }

    // Mètode sobrecarregat amb dos paràmetres
    public void mostrar(int a, int b) {
        System.out.println("Nombre enter: " + a + ", " + b);
    }

    // Mètode sobrecarregat amb un paràmetre de tipus diferent
    public void mostrar(String a) {
        System.out.println("Cadena: " + a);
    }

    public static void main(String[] args) {
        PolimorfismeCompilacio obj = new PolimorfismeCompilacio();
        obj.mostrar(5);
        obj.mostrar(5, 10);
        obj.mostrar("Hola");
    }
}

Polimorfisme en Temps d'Execució (Sobreescriptura de Mètodes)

class Animal {
    void ferSo() {
        System.out.println("L'animal fa un so");
    }
}

class Gos extends Animal {
    @Override
    void ferSo() {
        System.out.println("El gos borda");
    }
}

class Gat extends Animal {
    @Override
    void ferSo() {
        System.out.println("El gat miola");
    }
}

public class PolimorfismeExecucio {
    public static void main(String[] args) {
        Animal meuAnimal;

        meuAnimal = new Gos();
        meuAnimal.ferSo();  // Sortida: El gos borda

        meuAnimal = new Gat();
        meuAnimal.ferSo();  // Sortida: El gat miola
    }
}

Exercicis Pràctics

Exercici 1: Sobrecàrrega de Mètodes

Crea una classe Calculadora amb mètodes sobrecarregats per sumar dos, tres i quatre nombres.

class Calculadora {
    // Implementa els mètodes aquí
}

public class TestCalculadora {
    public static void main(String[] args) {
        Calculadora calc = new Calculadora();
        System.out.println(calc.sumar(2, 3));          // Sortida esperada: 5
        System.out.println(calc.sumar(2, 3, 4));       // Sortida esperada: 9
        System.out.println(calc.sumar(2, 3, 4, 5));    // Sortida esperada: 14
    }
}

Solució

class Calculadora {
    public int sumar(int a, int b) {
        return a + b;
    }

    public int sumar(int a, int b, int c) {
        return a + b + c;
    }

    public int sumar(int a, int b, int c, int d) {
        return a + b + c + d;
    }
}

Exercici 2: Sobreescriptura de Mètodes

Crea una classe Vehicle amb un mètode moure(). Després, crea subclasses Cotxe i Bicicleta que sobreescriguin el mètode moure().

class Vehicle {
    // Implementa el mètode moure aquí
}

class Cotxe extends Vehicle {
    // Sobreescriu el mètode moure aquí
}

class Bicicleta extends Vehicle {
    // Sobreescriu el mètode moure aquí
}

public class TestVehicle {
    public static void main(String[] args) {
        Vehicle meuVehicle;

        meuVehicle = new Cotxe();
        meuVehicle.moure();  // Sortida esperada: El cotxe es mou

        meuVehicle = new Bicicleta();
        meuVehicle.moure();  // Sortida esperada: La bicicleta es mou
    }
}

Solució

class Vehicle {
    void moure() {
        System.out.println("El vehicle es mou");
    }
}

class Cotxe extends Vehicle {
    @Override
    void moure() {
        System.out.println("El cotxe es mou");
    }
}

class Bicicleta extends Vehicle {
    @Override
    void moure() {
        System.out.println("La bicicleta es mou");
    }
}

Resum

El polimorfisme és una característica fonamental de la POO que permet que un mateix mètode pugui tenir diferents comportaments segons el context en què s'utilitzi. Això es pot aconseguir mitjançant la sobrecàrrega de mètodes (polimorfisme en temps de compilació) i la sobreescriptura de mètodes (polimorfisme en temps d'execució). Aquests conceptes permeten escriure codi més flexible i reutilitzable.

Polimorfisme

Conceptes Clau

Exemples Pràctics

Polimorfisme en Temps de Compilació (Sobrecàrrega de Mètodes)

Polimorfisme en Temps d'Execució (Sobreescriptura de Mètodes)

Exercicis Pràctics

Exercici 1: Sobrecàrrega de Mètodes

Solució

Exercici 2: Sobreescriptura de Mètodes

Solució

Resum

Curs de Programació en Java

Mòdul 1: Introducció a Java

Mòdul 2: Flux de Control

Mòdul 3: Programació Orientada a Objectes

Mòdul 4: Programació Orientada a Objectes Avançada

Mòdul 5: Estructures de Dades i Col·leccions

Mòdul 6: Gestió d'Excepcions

Mòdul 7: Entrada/Sortida de Fitxers

Mòdul 8: Multithreading i Concurrència

Mòdul 9: Xarxes

Mòdul 10: Temes Avançats

Mòdul 11: Frameworks i Llibreries de Java

Mòdul 12: Construcció d'Aplicacions del Món Real