Introducció

Les classes abstractes són una característica fonamental de la programació orientada a objectes (POO) en Java. Permeten definir una estructura comuna per a un conjunt de classes relacionades, però no es poden instanciar directament. En lloc d'això, serveixen com a base per a altres classes que implementen els seus mètodes abstractes.

Conceptes Clau

Classe Abstracta: Una classe que no es pot instanciar i pot contenir mètodes abstractes (sense implementació) i mètodes concrets (amb implementació).
Mètode Abstracte: Un mètode declarat sense implementació, que ha de ser implementat per les subclasses.
Herència: Les classes que hereten d'una classe abstracta han d'implementar tots els mètodes abstractes de la classe base.

Definició d'una Classe Abstracta

Una classe abstracta es defineix utilitzant la paraula clau abstract. Aquí teniu un exemple bàsic:

abstract class Animal {
    // Mètode abstracte (sense implementació)
    abstract void makeSound();

    // Mètode concret (amb implementació)
    void sleep() {
        System.out.println("Sleeping...");
    }
}

Implementació de Mètodes Abstractes

Les subclasses d'una classe abstracta han d'implementar tots els mètodes abstractes. Aquí teniu un exemple:

class Dog extends Animal {
    // Implementació del mètode abstracte
    void makeSound() {
        System.out.println("Bark");
    }
}

class Cat extends Animal {
    // Implementació del mètode abstracte
    void makeSound() {
        System.out.println("Meow");
    }
}

Exemple Complet

A continuació, es mostra un exemple complet que inclou una classe abstracta i les seves subclasses:

abstract class Animal {
    abstract void makeSound();

    void sleep() {
        System.out.println("Sleeping...");
    }
}

class Dog extends Animal {
    void makeSound() {
        System.out.println("Bark");
    }
}

class Cat extends Animal {
    void makeSound() {
        System.out.println("Meow");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal dog = new Dog();
        Animal cat = new Cat();

        dog.makeSound(); // Output: Bark
        dog.sleep();     // Output: Sleeping...

        cat.makeSound(); // Output: Meow
        cat.sleep();     // Output: Sleeping...
    }
}

Exercicis Pràctics

Exercici 1

Descripció: Crea una classe abstracta Shape amb un mètode abstracte calculateArea(). Implementa dues subclasses Circle i Rectangle que calculin l'àrea corresponent.

Solució:

abstract class Shape {
    abstract double calculateArea();
}

class Circle extends Shape {
    double radius;

    Circle(double radius) {
        this.radius = radius;
    }

    double calculateArea() {
        return Math.PI * radius * radius;
    }
}

class Rectangle extends Shape {
    double length, width;

    Rectangle(double length, double width) {
        this.length = length;
        this.width = width;
    }

    double calculateArea() {
        return length * width;
    }
}

public class Main {
    public static void main(String[] args) {
        Shape circle = new Circle(5);
        Shape rectangle = new Rectangle(4, 6);

        System.out.println("Area of Circle: " + circle.calculateArea());
        System.out.println("Area of Rectangle: " + rectangle.calculateArea());
    }
}

Exercici 2

Descripció: Defineix una classe abstracta Employee amb un mètode abstracte calculateSalary(). Implementa dues subclasses FullTimeEmployee i PartTimeEmployee que calculin el salari corresponent.

Solució:

abstract class Employee {
    String name;
    int id;

    Employee(String name, int id) {
        this.name = name;
        this.id = id;
    }

    abstract double calculateSalary();
}

class FullTimeEmployee extends Employee {
    double monthlySalary;

    FullTimeEmployee(String name, int id, double monthlySalary) {
        super(name, id);
        this.monthlySalary = monthlySalary;
    }

    double calculateSalary() {
        return monthlySalary;
    }
}

class PartTimeEmployee extends Employee {
    double hourlyRate;
    int hoursWorked;

    PartTimeEmployee(String name, int id, double hourlyRate, int hoursWorked) {
        super(name, id);
        this.hourlyRate = hourlyRate;
        this.hoursWorked = hoursWorked;
    }

    double calculateSalary() {
        return hourlyRate * hoursWorked;
    }
}

public class Main {
    public static void main(String[] args) {
        Employee fullTime = new FullTimeEmployee("John", 1, 3000);
        Employee partTime = new PartTimeEmployee("Jane", 2, 20, 80);

        System.out.println("Full Time Employee Salary: " + fullTime.calculateSalary());
        System.out.println("Part Time Employee Salary: " + partTime.calculateSalary());
    }
}

Errors Comuns

No Implementar Mètodes Abstractes: Si una subclasse no implementa tots els mètodes abstractes de la seva classe base, es produirà un error de compilació.
Intentar Instanciar una Classe Abstracta: Intentar crear una instància directa d'una classe abstracta també produirà un error de compilació.

Resum

Les classes abstractes són una eina poderosa en Java per definir una estructura comuna per a un conjunt de classes relacionades. Permeten declarar mètodes abstractes que han de ser implementats per les subclasses, proporcionant així una manera de garantir que certes funcionalitats siguin implementades de manera consistent.

Classes Abstractes

Introducció

Conceptes Clau

Definició d'una Classe Abstracta

Implementació de Mètodes Abstractes

Exemple Complet

Exercicis Pràctics

Exercici 1

Exercici 2

Errors Comuns

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