Cet article décrit le modèle de méthode de modèle. Vous devez absolument comprendre la différence entre une classe abstraite et une interface. Même si vous ignorez cette étape et entrez le modèle de conception, vous ne pourrez pas le maîtriser. Ici Je pense que l'article sera très utile, alors jetez un œil.
En japonais, c'est ** type **. Je pense que ce travail sera amélioré en créant un ** modèle ** dans une certaine mesure lors de la rédaction d'un e-mail. La même chose peut être dite pour les programmes.
Méthode d'extraction de la partie commune du traitement dans une classe abstraite et d'implémentation d'un traitement unique dans une classe concrète. Pour le dire plus simplement, il peut être utilisé lorsque vous souhaitez ** partager un traitement de flux similaire **. Je pense que ce * flux * est important. Au lieu d'apporter simplement le traitement qui peut être partagé à la classe abstraite La meilleure partie de ce modèle est d'extraire le ** flux de traitement ** dans une classe abstraite en tant que modèle (type).
Je pense que vous pouvez utiliser ce modèle dans les cas suivants. ** Lorsque le flux de traitement de plusieurs classes concrètes est similaire, comme "pré-traitement, traitement principal, post-traitement" **
Il est difficile de déterminer quand cela peut être utilisé, et c'est la partie la plus importante, donc le programme que vous avez écrit une fois, Je pense que vous devriez y réfléchir en regardant le code source publié.
Utilisons le modèle de méthode de modèle comme exemple d'un jour pour les étudiants et d'un jour pour les adultes qui travaillent.
| étudiant | société | |
|---|---|---|
| Se lever | Se lever | ← Même comportement |
| Dormez deux fois | Préparation | ← Comportement différent |
| jouer | travaux | ← Comportement différent |
| Aller au lit | Aller au lit | ← Même comportement |
J'ai écrit les modèles de comportement quotidiens (types) d'étudiants et de travailleurs. Vous pouvez utiliser le modèle de méthode de modèle lorsque les modèles (types) sont similaires comme ça! Si vous écrivez le flux de la vie humaine dans une classe abstraite (implémentez des actions communes) et implémentez différentes actions dans chaque classe concrète, c'est facile, mais le modèle de méthode modèle est terminé.
Implémentons-le en fait en utilisant celui montré ci-dessus comme exemple.
Implémentez le flux de la vie humaine avec une classe abstraite. Se réveiller et se coucher sont les mêmes actions, nous allons donc les implémenter dans une classe abstraite.
Human.java
public abstract class Human {
public void startDay(){
getUp();
preAction();
mainAction();
sleep();
}
protected abstract void mainAction();
protected abstract void preAction();
private void getUp(){
System.out.println("Se lever");
}
private void sleep(){
System.out.println("Aller au lit");
}
}
Nous mettrons en œuvre le double sommeil spécifique aux élèves et jouerons dans ce cours concret.
Student.java
public class Student extends Human{
@Override
protected void mainAction() {
System.out.println("Dormez deux fois");
}
@Override
protected void preAction() {
System.out.println("jouer");
}
}
Cette classe concrète met en œuvre la préparation et le travail propres aux travailleurs.
WorkingAdult.java
public class WorkingAdult extends Human{
@Override
protected void mainAction() {
System.out.println("Préparation");
}
@Override
protected void preAction() {
System.out.println("travaux");
}
}
Enfin, créez une classe qui appelle ces classes ci-dessus. Commencez simplement la journée avec de nouveaux étudiants et des travailleurs
Main.java
public class Main {
public static void main(String[] arg){
Human student = new Student();
Human worker = new WorkingAdult();
System.out.println("**étudiant**");
student.startDay();
System.out.println("**société**");
worker.startDay();
}
}
/*
**étudiant**
Se lever
jouer
Dormez deux fois
Aller au lit
**société**
Se lever
travaux
Préparation
Aller au lit
*/
comment était-ce? C'était étonnamment facile! Au contraire, je viens d'apporter un traitement commun à une classe abstraite!? ** Ce que j'aimerais que vous compreniez ici, c'est que le flux de traitement est amené à la classe abstraite. ** **
De là, c'est un peu avancé.
Il existe un modèle de méthode composée, mais il extrait simplement la méthode et Améliorons la lisibilité jusqu'à ce que vous puissiez lire le processus! !! La technique. Combinaison de ce modèle de méthode composée avec le modèle de méthode de modèle A quoi bon?
Par exemple, le traitement est similaire, mais il est légèrement différent et ne peut pas être partagé. .. .. Par conséquent, lorsque le modèle de méthode modèle ne peut pas être utilisé, il devient possible de combiner cette méthode.
Prenons comme exemple le processus de préparation du café et du thé.
Cours pour faire du café
Coffee.java
public class Coffee {
public void makeCoffee(){
createHotWater();
System.out.println("Ajouter du café en poudre");
waiting();
}
private void createHotWater() {
System.out.println("Faire bouillir de l'eau");
}
private void waiting(){
System.out.println("attendre");
}
}
Cours pour faire du thé
Tea.java
public class Tea {
public void makeCoffee(){
createHotWater();
System.out.println("Ajouter du thé en poudre");
waiting();
}
private void createHotWater() {
System.out.println("Faire bouillir de l'eau");
}
private void waiting(){
System.out.println("attendre");
}
}
Oh! !! !! "Faire bouillir de l'eau, faire du café ou du thé, attendre" C'est un processus similaire! !! Utilisons le modèle de méthode de modèle! !! !! !! Je veux que vous l'essayiez. Vous pouvez le remarquer.
Les parties non méthodisées, "Mettre dans la poudre de copi" et "Mettre dans la poudre de thé", sont laissées telles quelles Ne peut pas être normalisé. Voici le modèle de méthode composée!
Réécrivons la classe de café comme suit. Je viens d'extraire un morceau de code dans la méthode putPowder
Coffee.java
public class Coffee {
public void makeCoffee(){
createHotWater();
putPowder();
waiting();
}
protected void putPowder() {
System.out.println("Ajouter du café en poudre");
}
private void createHotWater() {
System.out.println("Faire bouillir de l'eau");
}
private void waiting(){
System.out.println("attendre");
}
}
Réécrivons la classe de thé comme suit. Je viens d'extraire un morceau de code dans la méthode putPowder
Tea.java
public class Tea {
public void makeCoffee(){
createHotWater();
putPowder();
waiting();
}
protected void putPowder() {
System.out.println("Ajouter du café en poudre");
}
private void createHotWater() {
System.out.println("Faire bouillir de l'eau");
}
private void waiting(){
System.out.println("attendre");
}
}
À ce stade, tout ce que vous avez à faire est d'élever la méthode à une méthode abstraite et d'implémenter le traitement spécifique dans une classe concrète.
Avez-vous compris le but du modèle de méthode modèle? C'est très simple à utiliser lors de la création d'un nouveau code, mais lors de la refactorisation du code existant, Il est étonnamment difficile de déterminer que «quelque part peut être partagé».
De plus, dans les classes abstraites, il est préférable d'utiliser autant que possible des noms de méthodes abstraites. Si vous écrivez un nom unique lorsque le nombre de classes concrètes augmente régulièrement, Le contenu du traitement et le nom de la méthode ne correspondent pas.
Recommended Posts