[JAVA] Vérifiez le fonctionnement de l'interface à travers le thread

Je n'ai pas eu faim d'interfaces Java depuis longtemps. Il y a plusieurs raisons à cela, mais l'une est qu'il est difficile de saisir où la méthode décrite dans la classe d'implémentation de l'interface est exécutée. Alors, essayons de savoir où exécuter avec un programme simple. Le premier programme que j'ai écrit était une animation Java, et j'ai été frappé par le fait que j'utilisais des threads à ce moment-là. Commençons à partir de là (cela peut ne pas être très semblable à Java, car de nombreux sites où Java est utilisé ne semblent pas être des pick-up comme l'animation). Je ne touche pas vraiment au fil lui-même. J'ai pensé que l'explication sur les pages suivantes à laquelle j'ai fait référence dans cet article est facile à comprendre. → Utilisation des threads Il ne mentionne pas non plus les avantages de l'utilisation de ** l'interface **.

Une méthode abstraite non substantielle (interface) ・ [Où est-il implémenté](# Où est-il implémenté), ・ [Quel type de configuration](# De quel type de configuration s'agit-il), ・ Qui (quel objet) ・ À quel moment ·Exécuter Vérifier si.

mot-clé: Méthodes abstraites, modèles de stratégie (stratégie, stratégie concrète, contexte, client), délégué, upcast, objets d'exécution

Contenu de l'exemple de programme

Quand il s'agit d'animation décente, l'accent ne peut pas être concentré sur l'interface, donc un programme qui ne sort qu'en déplaçant le "○" petit à petit sur la console. Un espace est ajouté à plusieurs reprises avant le "○" dans la boucle infinie dans le thread, et il est sorti.

Gère 4 classes (interfaces)

VerySimpleTextAnimationApp.java

/* 
 *Méthode principale uniquement
 *Créer une instance d'une classe qui implémente l'interface Runnable
 *Spécifiez cette instance dans le constructeur de la classe Thread
 *Créez une instance (thread) de Thread.
 *début de la méthode d'instance de thread()Exécuter.
 */

public class VerySimpleTextAnimationApp {

	public static void main(String args[]){
		
		/*Créer un objet qui fonctionne comme un thread distinct*/
		VerySimpleTextAnimation verySimpleTextAnimation = new VerySimpleTextAnimation();
		
		/*Créez un autre fil et démarrez le fil*/
		Thread thread = new Thread(verySimpleTextAnimation);
		thread.start();			
	 }

}

VerySimpleTextAnimation.java

/* 
 *Classe d'implémentation de l'interface Runnable.
 * Run()Implémentez la méthode.
 *Animation qui ○ se déplace progressivement vers la droite (intention)
 */

public class VerySimpleTextAnimation implements Runnable {

	String x = "○";

	public void run() {
		while(true) {
			x = "　" + x;
			System.out.println(x);
			try {
				/*Attendre un peu*/
				Thread.sleep(500);			
			} catch(InterruptedException e) {}			
		}
	}
}

Où il est mis en œuvre

	public void run() {
		while(true) {
			x = "　" + x;
			System.out.println(x);
			try {
				/*Attendre un peu*/
				Thread.sleep(500);			
			} catch(InterruptedException e) {}			
		}
	}

À l'intérieur de la classe VerySimpleTextAnimation. J'implémente la méthode run () qui n'est définie que dans l'interface Runnable. Je ne pense pas que ce soit si difficile. Cependant, je me sens mal à l'aise avec les points suivants dans le contenu de la mise en œuvre.

Thread.sleep(500);

Pourquoi est-ce une méthode statique? J'y réfléchirai à ma manière plus tard. [À propos de # Thread.sleep ()](À propos de # Thread.sleep ())

De quel type de configuration s'agit-il?

Ensuite, jetons un coup d'œil à VerySimpleTextAnimationApp. Tout d'abord, une instance de la classe VerySimpleTextAnimation (classe d'implémentation d'interface Runnable) est créée. Une classe qui implémente la méthode d'exécution que nous avons vue précédemment.

VerySimpleTextAnimation verySimpleTextAnimation = new VerySimpleTextAnimation();

Au fait, cela fonctionne même si vous écrivez comme suit.

Runnable verySimpleTextAnimation = new VerySimpleTextAnimation();

Cette façon d'écrire est appelée upcast. Comme je le vois souvent, c'était aussi une pierre d'achoppement pour moi, alors je l'ai écrit dans un article plus tôt. Upcast et Super Type / Sub Type

Je pense que la difficulté de fixer l'interface est qu'il y a de nombreux cas où plusieurs éléments sont combinés de manière complexe dans la situation d'utilisation.

Thread thread = new Thread(verySimpleTextAnimation);

Il est également possible d'écrire ** nouveau nom de classe ** directement dans l'argument sans déclarer une instance de la classe d'implémentation d'interface comme variable.

Thread thread = new Thread(new VerySimpleTextAnimation());

Ici, créez une instance de la classe Thread. À ce moment-là, le verySimpleTextAnimation créé précédemment est inclus dans l'argument du constructeur, mais quel est le type de cet argument en premier lieu?

Jetons donc un coup d'œil au constructeur de classe Thread dans la documentation Java.

public Thread(Runnable target) Paramètres: target: objet contenant la méthode d'exécution appelée au démarrage de ce thread.

** Défini pour prendre une instance (cible) de type Runnable comme argument **. De plus, la description du paramètre indique ** un objet contenant la méthode d'exécution **. Cette fois, verySimpleTextAnimation est inclus dans l'argument du constructeur de Thread. La méthode d'exécution ** que cette instance contient ** est une fausse animation implémentée ici. Je me sentais assez mal à l'aise avec la méthode ** qui définit le type d'interface dans l'argument, comme ce constructeur. Je n'ai pas compris le sens de l'utilisation d'une méthode abstraite comme argument, et l'interface elle-même n'aurait pas dû être instanciée en premier lieu. Cela implique le upcast mentionné précédemment. Si l'argument d'une méthode est de type interface, il est destiné à être une instance de classe d'implémentation de cette interface. Il m'a fallu un certain temps pour le remarquer.

thread.start();			

Jetez un œil à la méthode start () dans la documentation

public void start() Démarre l'exécution de ce fil. La machine virtuelle Java appelle la méthode d'exécution de ce thread.

Il dit ** appelez la méthode d'exécution de ce fil **. Il s'appelle ** Delegate ** qui confie le contenu de traitement spécifique à la méthode d'exécution.

Voyons donc l'explication de la méthode run ().

public void run() Si ce thread a été créé à l'aide d'un objet d'exécution Runnable distinct, la méthode d'exécution de cet objet Runnable est appelée.

** Si créé à l'aide d'un objet d'exécution Runnable distinct **, il doit l'être lorsque l'instance a été créée avec une cible de type Runnable spécifiée dans le constructeur. run () est exécuté par la méthode start (). Le contenu de la méthode run () est le contenu implémenté dans l'instance saisie par le constructeur. Au fait, le nom ** Objet d'exécution exécutable ** est intéressant. Appelez-vous une instance de la classe d'implémentation d'interface de cette façon?

Qui (quel objet)

Classe VerySimpleTextAnimationApp

À quel moment

Lorsque thread.start () est appelé dans la méthode Main. Dans cet exemple, il est facile de suivre le timing d'exécution, mais il est préférable de laisser le bon timing au Client (voir [Table de modèle de stratégie](modèle #Strategy)) qui a confié l'objet d'exécution tel que le traitement des événements et le traitement asynchrone.

Autre

Modèle de stratégie

La structure de la classe est la suivante en termes de modèle de stratégie.

Référence: Modèle de stratégie Étant donné que le contenu de cet article ne considère pas les choses de type stratégie, il est très douteux qu'il puisse être appelé un modèle de stratégie, mais comme il a la même forme, il est facile à appliquer s'il existe un tel modèle dans le coin de ma tête. Pourrait devenir. Vous devrez suivre le code pour comprendre le contenu du programme. C'est facile à suivre si vous suivez les accords de manière linéaire, profondément et profondément, mais jusqu'à ce que vous vous y habituiez, vous serez dérangé en allant encore et encore et en vous retirant, et votre concentration sera réduite. Je pense que la seule façon de surmonter cela est de s'y habituer, mais je pense que la compréhension du modèle de conception améliorera les perspectives (même si c'est difficile à comprendre).

À propos de Thread.sleep ()

À propos du traitement Sleep de la classe Java Thread Je comprends l'inconfort de ce questionneur, et pour moi, la réponse ici ne le résout pas. Il semble étrange que l'instruction d'exécution de la méthode statique contrôle le fonctionnement de chaque instance individuelle. Après tout, je ne connais pas la raison exacte, mais probablement parce que cette méthode statique est appelée sur des instances individuelles (ici l'instance VerySimpleTextAnimation), vous pouvez déterminer à quelle instance de Thread l'instruction de sommeil est destinée. Je pense que ce sera. S'il vous plaît laissez-moi savoir si quelqu'un sait.

Dans le passé, j'avais l'image que Thread animait, mais quand je suis à nouveau le flux de processus, c'est la boucle while de la méthode run qui réalise l'animation. J'ajuste la fréquence d'images avec Thread.sleep ().

Penser à la confusion de l'interface (non coordonnée ...)

Pour implémenter une interface, écrivez simplement des implémentations entre le nom de la classe et le nom de l'interface, et le contenu de l'implémentation est le même que l'écriture d'autres méthodes. Dans cet article, j'ai utilisé l'interface existante (Runnable), mais si vous pouvez écrire une classe même si vous la faites vous-même, ce n'est pas particulièrement difficile. En d'autres termes, ce n'est pas difficile à écrire, mais plutôt facile. Comme le nom «interface» l'indique, le rôle est ** de connecter les objets **, et d'être comme une ** convention ** inexistante (en Swift, elle joue un rôle similaire). Il existe un objet appelé ** Protocol **). Puisqu'il n'y a pas de substance, rien ne peut être compris en regardant uniquement l'interface. Pour comprendre l'interface, il est nécessaire de pouvoir imaginer ** entre ** objets, ce qui nécessite d'imaginer une combinaison de plusieurs objets. Il est difficile de penser à des combinaisons compliquées sans s'y habituer, donc si vous pensez que c'est simple, la composition est simple, mais je ne comprends pas à quel point elle est reconnaissante (comme on peut le dire dans cet article), et cela ressemble juste à une manière désordonnée d'écrire. Dans la situation d'utilisation réelle, la combinaison devient compliquée et d'autres facteurs (génériques, etc.) sont impliqués, ce qui rend difficile la concentration. De plus, je pense que cela est dû à la position du langage Java plutôt qu'à l'interface, mais ce n'est pas très attrayant pour les débutants (peut-être que cela me met en colère), et il y a beaucoup d'explications d'un point de vue SIer. Java a un descendant appelé Processing, donc une fois que je me serai installé, j'aimerais écrire un autre article sur l'interface dans cette perspective.