Toutes les personnes. C'est le dernier jour de l'année. J'ai déclaré sur mon blog il y a environ un mois que je publierais à nouveau sur Qiita dans l'année, et j'ai finalement décidé de publier à la toute fin de l'année: sweat_smile:
J'étudie généralement C # principalement, mais la plupart des livres de modèles de conception étaient JAVA, alors j'ai fait de mon mieux pour écrire en JAVA.
En tant que personne inexpérimentée, j'ai finalement appris les «modèles de conception» cette année.
Le modèle de conception m'a choqué, tout comme l'attaque big bang de Vegita. Je n'ai pas vraiment compris la différence entre État et Stratégie, je vais donc la résumer moi-même. désolé si ce n'est pas juste.
L'État est un État et se déplace à l'extérieur ou à l'intérieur. La stratégie est une stratégie qui décide en externe quelle stratégie adopter
Je me sentais comme ça.
Donc, cette fois, j'ai acheté ces deux modèles avec une personne nommée Kyosuke Shindo. Veuillez noter que cela peut être un peu plus long.
Tout d'abord, à propos du programme.
Il n'y a qu'une seule personne, Kyosuke Shindo. Kyosuke Shindo choisit de travailler normalement ou dur. (Stratégie) Et vous obtenez une valeur d'expérience par le travail, et Kyosuke Shindo monte en grade par cette valeur d'expérience. (Etat)
C'est un programme idiot.
Tout d'abord, écrivez à partir de Main pour être exécuté.
Main.java
package Kyosuke;
public class Main {
public static void main(String[] args) {
Human kyosuke = new Kyosuke();
//Travaillez et obtenez 1 expérience
kyosuke.DoWork();
//Travaillez dur et obtenez 3 points d'expérience
kyosuke.ChangeWorkStyle(new HardWork());
kyosuke.DoWork();
//Après tout je travaille normalement
kyosuke.ChangeWorkStyle(new NomalWork());
kyosuke.DoWork();
kyosuke.DoWork();
kyosuke.DoWork();
//Je suis sérieux à partir d'aujourd'hui w
kyosuke.ChangeWorkStyle(new HardWork());
kyosuke.DoWork();
kyosuke.DoWork();
kyosuke.DoWork();
kyosuke.DoWork();
kyosuke.DoWork();
kyosuke.DoWork();
}
}
Le rang est maintenant le rang B
J'ai 1 expérience car je travaillais normalement
J'ai obtenu 3 points d'expérience parce que j'ai travaillé dur
J'ai 1 expérience car je travaillais normalement
J'ai 1 expérience car je travaillais normalement
J'ai 1 expérience car je travaillais normalement
J'ai obtenu 3 points d'expérience parce que j'ai travaillé dur
Le rang est maintenant un rang
J'ai obtenu 3 points d'expérience parce que j'ai travaillé dur
J'ai obtenu 3 points d'expérience parce que j'ai travaillé dur
J'ai obtenu 3 points d'expérience parce que j'ai travaillé dur
J'ai obtenu 3 points d'expérience parce que j'ai travaillé dur
J'étais capable de
J'ai obtenu 3 points d'expérience parce que j'ai travaillé dur
J'étais capable de
Le premier rang est le rang B. Et le travail est également normal. Je travaille dur sur le chemin et le rang monte, et enfin je peux frapper
Jetons un coup d'œil à une personne nommée Kyosuke Shindo.
Human.java
package Kyosuke;
interface Human {
void DoWork();
void SetRank(Rank newRank);
void ChangeWorkStyle(Work style);
int GetExperiencepoint();
}
Kyosuke.java
package Kyosuke;
public class Kyosuke implements Human{
private Rank rank;
private Work work;
private int experiencepoint;
public Kyosuke() {
this.rank = new BRank(this);
this.work = new NomalWork();
//Expérimentez la valeur 1 dans un premier temps
this.experiencepoint = 1;
}
@Override
public void DoWork() {
int point = work.DoWork();
this.experiencepoint += point;
//Vérifiez le classement ici
rank.CheckNextRank();
}
@Override
public void SetRank(Rank newRank) {
this.rank = newRank;
}
@Override
public void ChangeWorkStyle(Work style) {
this.work = style;
}
@Override
public int GetExperiencepoint() {
return this.experiencepoint;
}
}
Il a un rang qui représente le rang actuel, un travail qui représente un travail (ce qui signifie inconnu) et un point d'expérience.
Initialisez tout cela dans le constructeur. Actions qui fonctionnent réellement, actions qui changent de rang, actions qui changent les styles de travail, actions qui renvoient des valeurs d'expérience Remplacez-les.
Maintenant, j'écrirai sur le style de travail.
Work.java
package Kyosuke;
public abstract class Work {
public abstract int DoWork();
}
NomalWork.java
package Kyosuke;
public class NomalWork extends Work{
private final int experiencePoint =1;
@Override
public int DoWork() {
System.out.println("J'ai 1 expérience car je travaillais normalement");
return experiencePoint;
}
}
HardWork.java
package Kyosuke;
public class HardWork extends Work{
private final int experiencePoint = 3;
@Override
public int DoWork() {
System.out.println("J'ai obtenu 3 points d'expérience parce que j'ai travaillé dur");
return experiencePoint;
}
}
Eh bien, si vous travaillez simplement, cela vous rendra votre expérience. Si vous n'utilisez pas ce modèle, vous aurez besoin d'une instruction if et d'une instruction switch. Un traitement spécifique peut être facilement commuté en l'implémentant dans une sous-classe.
Rank.java
package Kyosuke;
public abstract class Rank {
protected int experinencepoint;
protected int nextLeve;
protected Human human;
public Rank(Human human){
this.human = human;
}
protected void SetExperinencepoint(){
this.experinencepoint =human.GetExperiencepoint();
}
protected abstract void CheckNextRank();
}
Et Rank. C'est l'État. La valeur d'expérience de Kyosuke Shindo est exprimée dans l'état de rang. Le constructeur reçoit Kyosuke Shindo.
BRank.java
package Kyosuke;
public class BRank extends Rank{
public BRank(Human human){
super(human);
this.nextLeve = 8;
System.out.println("Le rang est maintenant le rang B");
}
@Override
protected void CheckNextRank() {
//Tout d'abord, vérifiez la valeur de l'expérience
SetExperinencepoint();
//Montez de niveau si la valeur d'expérience dépasse le niveau suivant
if (experinencepoint > nextLeve){
human.SetRank(new ARank(this.human));
}
}
}
La sous-classe Rank remplace la méthode requise. Dans le constructeur, appelez le constructeur de la classe parent et définissez Kyosuke Shindo. Et définissez nextLeve que vous avez besoin de 8 valeurs d'expérience jusqu'au niveau suivant (Qu'est-ce que Next Leve)
Le point est la méthode CheckNextRank. Nous lisons la valeur d'expérience de Kyosuke Shindo et changeons l'état en conséquence. En particulier SetExperinencepoint(); Si la valeur d'expérience est lue avec et que la condition du niveau suivant défini dans le constructeur est dépassée, le rang est élevé au rang A. (Modifie l'état)
Du côté de la méthode principale, il n'est pas du tout impliqué dans ce changement d'état. Tout bouge en interne.
ARank.java
package Kyosuke;
public class ARank extends Rank{
public ARank(Human human){
super(human);
nextLeve = 20;
System.out.println("Le rang est maintenant un rang");
}
@Override
protected void CheckNextRank() {
//Tout d'abord, vérifiez la valeur de l'expérience
SetExperinencepoint();
//Montez de niveau si la valeur d'expérience dépasse le niveau suivant
if (experinencepoint > nextLeve){
System.out.println("J'étais capable de");
}
}
}
Et ARank reçoit également Kyosuke Shindo dans le constructeur. Le contenu du traitement est le même que BRank. Si vous souhaitez retourner à BRank sans encombre ou passer à un niveau supérieur, vous pouvez remettre Kyosuke Shindo de la même manière.
Je l'ai mis en place très facilement, mais c'est tout.
Le modèle de conception était magique. C'est aussi un tel professeur qui me fait penser que je devrais apprendre de plus en plus.
Eh bien, tout à coup L'année prochaine sera un début de chômage: grave:
Quoi qu'il en soit, je vais m'entraîner et faire de mon mieux pour pouvoir manger par programmation.
Recommended Posts