Exemple détaillé de définition de propriétés abstraites en Java

Cet article vous présente principalement des informations pertinentes sur la façon de définir un exemple d'attribut abstrait en Java. Les amis qui en ont besoin peuvent s'y référer

Avant-propos<.>

Cet article vous présente principalement le contenu pertinent de la définition d'un attribut abstrait en Java. Il est partagé pour votre référence et votre apprentissage. Je ne dirai pas grand-chose ci-dessous, jetons un œil à l'introduction détaillée :

Le mot-clé Abstract est généralement utilisé dans les classes et les méthodes pour déléguer la mise en œuvre de certains comportements à des sous-classes. Étant donné que Java ne prend pas en charge les propriétés abstraites, vous obtiendrez une erreur de compilation si vous essayez de marquer une propriété de classe comme abstraite.

Dans ce tutoriel, nous présenterons deux méthodes de définition de propriétés abstraites qui peuvent être définies par des sous-classes sans utiliser le mot-clé Abstract.

Cas pratique
Supposons que nous souhaitions implémenter un module de journal des transactions pour enregistrer des informations de transaction spécifiques. Nous voulons que ce module soit abstrait afin que nous puissions implémenter différentes méthodes de journalisation, telles que la journalisation dans un fichier ou une base de données.

Notre moteur utilise des délimiteurs prédéfinis pour concaténer les informations dans le journal et les stocker dans une chaîne. Le délimiteur à utiliser dépend des règles de journalisation. Par exemple, le caractère "," peut être utilisé pour séparer différentes parties des informations dans l'enregistrement du journal.

Par conséquent, les délimiteurs semblent abstraits pour notre moteur et doivent être explicitement définis par chaque règle de journalisation.

Ci-dessous, je propose deux façons de déléguer la définition des séparateurs aux sous-classes.

Définir un constructeur avec des paramètres dans une classe abstraite
La première façon de définir des propriétés dynamiques dans une classe abstraite est : Définir un constructeur avec un paramètre.

Nous pouvons donc implémenter ce moteur comme ceci :

Lors de la définition d'un constructeur avec des paramètres dans une classe abstraite, les sous-classes seront forcées. Définissez votre propre constructeur et appelez

// TransactionManager.java

public abstract class TransactionManager {
 private String separator;
 
 public TransactionManager(String separator) {
 this.separator = separator;
 }
 
 public abstract void writeTransaction(String result);
 
 public Transaction startTransaction()
 {
 Transaction transaction = new Transaction(System.currentTimeMillis());
 return transaction;
 }
 
 public void endTransaction(Transaction t) {
 long processingTime = System.currentTimeMillis() - t.getStartTime();
 
 StringBuilder logBuilder = new StringBuilder();
 logBuilder.append(t.getStartTime());
 // Notice the use of this.separator
 logBuilder.append(this.separator);
 logBuilder.append(processingTime);
 logBuilder.append(this.separator);
 logBuilder.append(t.getData());
 
 String result = logBuilder.toString();
 writeTransaction(result);
 }
}

. De cette façon, nous pouvons forcer l'attribut séparateur à dépendre du mécanisme de journalisation utilisé.

super()

Remarque : Notre moteur implémente les comportements statiques communs à tous les mécanismes de journalisation : , , tout en laissant le comportement dynamique startTransaction() à Subclass à mettre en œuvre. endTransaction() writeTransaction()Maintenant, si nous voulons créer un gestionnaire de transactions et l'utiliser pour enregistrer le contenu du journal dans un fichier, alors nous pouvons le définir comme ceci :

Ensuite, faites un test pour voir comment fonctionne le code

public class TransactionManagerFS extends TransactionManager{
 
 // The IDE forces you to implement constructor.
 public TransactionManagerFS(String separator) {
 super(separator);
 }
 
 @Override
 public void writeTransaction(String result) {
 System.out.println("The following transaction has just finished: " );
 System.out.println(result);
 }
}

Sortie :

public static void main(String[] args) throws InterruptedException {
 // we pass the separator explicitly in the constructor
 TransactionManager transactionManager = new TransactionManagerFS(",");
 Transaction transaction = transactionManager.startTransaction();
 transaction.setData("This is a test transaction !!");
 Thread.sleep(1500);
 transactionManager.endTransaction(transaction);
 }

The following transaction has just finished: 
1502179140689,1501,This is a test transaction !!

Passez le séparateur via la méthode getter
Une autre façon d'implémenter des propriétés dynamiques consiste à définir une méthode getter abstraite, quelle méthode pour récupérer le requis délimiteur basé sur le mécanisme de journalisation actuel. Dans notre moteur, lorsqu'un délimiteur est nécessaire, il peut être obtenu en appelant cette méthode getter.

Ensuite, nous modifions le moteur comme ceci :

De plus, modifiez TransactionManagerFS comme suit :

public abstract class TransactionManager {
 
 public abstract String getSeperator();
 public abstract void writeTransaction(String result);
 
 public Transaction startTransaction()
 {
 Transaction transaction = new Transaction(System.currentTimeMillis());
 return transaction;
 }
 
 public void endTransaction(Transaction t) {
 long processingTime = System.currentTimeMillis() - t.getStartTime();
 
 StringBuilder logBuilder = new StringBuilder();
 logBuilder.append(t.getStartTime());
 // Notice the use of getSeparator()
 logBuilder.append(getSeperator());
 logBuilder.append(processingTime);
 logBuilder.append(getSeperator());
 logBuilder.append(t.getData());
 
 String result = logBuilder.toString();
 writeTransaction(result);
 }
}

Ensuite, modifiez main pour utiliser la nouvelle implémentation et assurez-vous d'obtenir les bons résultats.

public class TransactionManagerFS extends TransactionManager{
 
 @Override
 public String getSeperator() {
 return ",";
 }
 
 @Override
 public void writeTransaction(String result) {
 System.out.println("The following transaction has just finished: " );
 System.out.println(result);
 }
}

Sortie :

public static void main(String[] args) throws InterruptedException {
 // The separator is defined implicitly using getSeparator() method of the manager
 TransactionManager transactionManager = new TransactionManagerFS();
 Transaction transaction = transactionManager.startTransaction();
 transaction.setData("This is a test transaction !!");
 Thread.sleep(1500);
 transactionManager.endTransaction(transaction);
 }

The following transaction has just finished: 
1502179140689,1501,This is a test transaction !!

Résumé

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!