Pratique des modèles de conception d'interfaces et de classes abstraites en Java

Interfaces et modèles de conception de classes abstraites dans l'interface Java : Interface Mark : indique que la classe a des attributs spécifiques et ne déclare pas de méthodes. Interface fonctionnelle : déclare une seule méthode abstraite, disponible pour Lambdas et Streams. Interface de service : définit la logique métier et la classe d'implémentation fournit une implémentation spécifique. Classe abstraite : modèle de classe abstraite : définit les méthodes et les attributs qui ne peuvent pas être instanciés, et les sous-classes doivent implémenter des méthodes abstraites. Modèle de méthode de modèle : définissez les étapes de l'opération et les sous-classes peuvent remplacer certaines étapes.

Pratique des modèles de conception d'interfaces et de classes abstraites en Java

Introduction

Les interfaces et les classes abstraites sont deux mécanismes d'abstraction importants en Java. Ils peuvent être utilisés efficacement en suivant des modèles de conception spécifiques. Cet article approfondira les différents modèles de conception d'interfaces et de classes abstraites et fournira des exemples de code pratiques.

Interface

1. Marker Interface

L'interface Marker ne déclare aucune méthode et est utilisée pour indiquer que la classe a des attributs spécifiques. Par exemple :

public interface Vehicle {
}

2. Interface fonctionnelle

L'interface fonctionnelle ne déclare qu'une seule méthode abstraite. Ils peuvent être utilisés dans les expressions Lambdas et l'API Streams. Par exemple :

@FunctionalInterface
public interface Calculate {
    int calculate(int a, int b);
}

3. Interface de service

L'interface de service définit la logique métier, tandis que d'autres classes d'implémentation fournissent l'implémentation réelle. Par exemple :

public interface UserService {
    User getUserById(int id);
    void createUser(User user);
}

Classe abstraite

1. Modèle de classe abstraite

Les classes abstraites peuvent définir des méthodes et des propriétés, mais ne peuvent pas être instanciées. Les sous-classes doivent implémenter des méthodes abstraites pour utiliser des classes abstraites. Par exemple :

public abstract class Animal {
    public abstract void makeSound();
}

2. Modèle de méthode modèle

Le modèle de méthode modèle définit les étapes d'une opération, dont certaines peuvent être remplacées par des sous-classes. Par exemple :

public abstract class Template {
    public final void execute() {
        step1();
        step2();
        step3();
    }

    protected abstract void step1();
    protected abstract void step2();
    protected abstract void step3();
}

Cas pratique

Montrons comment appliquer l'interface et les modèles de conception de classe abstraite à travers un cas pratique.

Question spécifique au produit :

Concevez une application pour gérer différents types de véhicules, chacun avec des fonctionnalités différentes.

Solution :

• Interface de marqueur : Créez une interface de marqueur Véhicule pour identifier tous les types de véhicules. Vehicle 标记接口来标识所有车辆类型。
• 功能接口：创建 CalculateMileage 功能接口以计算车辆的里程。
• 抽象类：创建 AbstractVehicle 抽象类来定义车辆的通用功能，如 make 和 model。
• 服务接口：创建 VehicleService

Interface fonctionnelle :

Créez une interface fonctionnelle CalculateMileage pour calculer le kilométrage du véhicule.

Classe abstraite :

Créez une classe abstraite AbstractVehicle pour définir les fonctions communes du véhicule, telles que la marque et le modèle.

Interface de service :

Créez une interface de service VehicleService pour définir la logique métier de la gestion des véhicules.

🎜🎜🎜Exemple de code🎜🎜

// 标记接口
public interface Vehicle {}

// 功能接口
@FunctionalInterface
public interface CalculateMileage {
    double calculate(Vehicle vehicle);
}

// 抽象类
public abstract class AbstractVehicle implements Vehicle {
    protected String make;
    protected String model;

    public String getMake() {
        return make;
    }

    public String getModel() {
        return model;
    }
}

// 服务接口
public interface VehicleService {
    List<Vehicle> getAllVehicles();
    Vehicle getVehicleById(int id);
    void createVehicle(Vehicle vehicle);
    void deleteVehicle(int id);
}

🎜🎜Conclusion🎜🎜🎜En tirant parti des modèles de conception d'interfaces et de classes abstraites, vous pouvez implémenter des solutions flexibles et évolutives dans les applications Java. Cet article donne un aperçu des différents modèles et de leurs applications pratiques pour aider les développeurs à mieux comprendre et utiliser ces mécanismes d'abstraction. 🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!