Introducció a l'Abstracció

L'abstracció és un dels quatre pilars de la Programació Orientada a Objectes (POO), juntament amb l'encapsulació, l'herència i el polimorfisme. L'abstracció permet als programadors centrar-se en el que fa un objecte en lloc de com ho fa. Això es fa amagant els detalls d'implementació i mostrant només les funcionalitats essencials.

Conceptes Clau

Abstracció: El procés de reduir la complexitat ocultant els detalls innecessaris i mostrant només les característiques essencials.
Classes Abstractes: Classes que no poden ser instanciades directament i poden contenir mètodes abstractes (sense implementació) i mètodes concrets (amb implementació).
Interfícies: Contractes que defineixen un conjunt de mètodes que una classe ha d'implementar.

Classes Abstractes

Una classe abstracta és una classe que no es pot instanciar directament. Es defineix utilitzant la paraula clau abstract. Les classes abstractes poden contenir mètodes abstractes, que són mètodes sense implementació, i mètodes concrets, que tenen una implementació.

Exemple de Classe Abstracta

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

    // Mètode concret (amb implementació)
    void breathe() {
        System.out.println("This animal is breathing.");
    }
}

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

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.makeSound(); // Output: Woof
        dog.breathe();   // Output: This animal is breathing.
    }
}

Explicació del Codi

Classe Abstracta Animal:
- Té un mètode abstracte makeSound() que no té implementació.
- Té un mètode concret breathe() que imprimeix un missatge.
Classe Dog:
- Extén la classe Animal i proporciona una implementació per al mètode abstracte makeSound().
Classe Main:
- Crea una instància de Dog i crida als mètodes makeSound() i breathe().

Interfícies

Una interfície és un contracte que defineix un conjunt de mètodes que una classe ha d'implementar. Les interfícies es defineixen utilitzant la paraula clau interface.

Exemple d'Interfície

interface Animal {
    void makeSound();
    void eat();
}

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

    public void eat() {
        System.out.println("Cat is eating");
    }
}

public class Main {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.makeSound(); // Output: Meow
        cat.eat();       // Output: Cat is eating
    }
}

Explicació del Codi

Interfície Animal:
- Defineix dos mètodes: makeSound() i eat().
Classe Cat:
- Implementa la interfície Animal i proporciona implementacions per als mètodes makeSound() i eat().
Classe Main:
- Crea una instància de Cat i crida als mètodes makeSound() i eat().

Exercicis Pràctics

Exercici 1: Classe Abstracta

Crea una classe abstracta Vehicle amb un mètode abstracte move(). Després, crea dues subclasses Car i Bike que implementin el mètode move().

Solució

abstract class Vehicle {
    abstract void move();
}

class Car extends Vehicle {
    void move() {
        System.out.println("Car is moving");
    }
}

class Bike extends Vehicle {
    void move() {
        System.out.println("Bike is moving");
    }
}

public class Main {
    public static void main(String[] args) {
        Vehicle car = new Car();
        Vehicle bike = new Bike();
        car.move();  // Output: Car is moving
        bike.move(); // Output: Bike is moving
    }
}

Exercici 2: Interfície

Crea una interfície Shape amb dos mètodes draw() i area(). Després, crea dues classes Circle i Rectangle que implementin la interfície Shape.

Solució

interface Shape {
    void draw();
    double area();
}

class Circle implements Shape {
    private double radius;

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

    public void draw() {
        System.out.println("Drawing Circle");
    }

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

class Rectangle implements Shape {
    private double width, height;

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

    public void draw() {
        System.out.println("Drawing Rectangle");
    }

    public double area() {
        return width * height;
    }
}

public class Main {
    public static void main(String[] args) {
        Shape circle = new Circle(5);
        Shape rectangle = new Rectangle(4, 6);
        circle.draw();        // Output: Drawing Circle
        System.out.println("Area: " + circle.area()); // Output: Area: 78.53981633974483
        rectangle.draw();     // Output: Drawing Rectangle
        System.out.println("Area: " + rectangle.area()); // Output: Area: 24.0
    }
}

Resum

En aquesta secció, hem après sobre l'abstracció en Java, incloent-hi les classes abstractes i les interfícies. Hem vist com les classes abstractes poden contenir mètodes abstractes i concrets, i com les interfícies defineixen un contracte que les classes han d'implementar. També hem practicat aquests conceptes amb exemples i exercicis pràctics. Ara estàs preparat per aplicar l'abstracció en els teus projectes de programació en Java.

Abstracció

Introducció a l'Abstracció

Conceptes Clau

Classes Abstractes

Exemple de Classe Abstracta

Explicació del Codi

Interfícies

Exemple d'Interfície

Explicació del Codi

Exercicis Pràctics

Exercici 1: Classe Abstracta

Solució

Exercici 2: Interfície

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