Au lieu de créer une instance à partir d'une classe, créez une autre instance à partir de celle-ci. Créez une nouvelle instance basée sur le prototype et l'instance de modèle.
Définissez une méthode pour copier une instance et en créer une nouvelle.
package framework;
public interface Product extends Cloneable {
//Méthode pour «utiliser». C'est à l'implémentation de la sous-classe de l'utiliser mais ce que cela signifie
public abstract void use(String s);
//Dupliquer l'instance
public abstract Product createClone();
}
Implémentez en fait la méthode qui copie l'instance et crée une nouvelle instance.
import framework.Product;
public class MessageBox implements Product {
private char decochar;
public MessageBox(char decochar) {
this.decochar = decochar;
}
@Override
public void use(String s) {
int length = s.getBytes().length;
for (int i = 0; i < length + 4; i++) {
System.out.print(decochar);
}
System.out.println("");
System.out.println(decochar + " " + s + " " + decochar);
for (int i = 0; i < length + 4; i++) {
System.out.print(decochar);
}
System.out.println("");
}
@Override
public Product createClone() {
Product p = null;
try {
p = (Product)clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return p;
}
}
import framework.Product;
public class UnderlinePen implements Product {
private char ulchar;
public UnderlinePen(char ulchar) {
this.ulchar = ulchar;
}
@Override
public void use(String s) {
int length = s.getBytes().length;
System.out.println("\"" + s + "\"");
System.out.print(" ");
for (int i = 0; i < length; i++) {
System.out.print(ulchar);
}
System.out.println("");
}
@Override
public Product createClone() {
Product p = null;
try {
p = (Product)clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return p;
}
}
Créez une nouvelle instance à l'aide de la méthode qui copie l'instance.
package framework;
import java.util.HashMap;
/**
*Une classe qui duplique une instance à l'aide de l'interface Produit
*/
public class Manager {
private HashMap<String, Product> showcase = new HashMap<>();
public void register(String name, Product proto) {
showcase.put(name, proto);
}
public Product create(String protoname) {
Product p = showcase.get(protoname);
return p.createClone();
}
}
import framework.Manager;
import framework.Product;
public class Main {
public static void main(String[] args) {
//Préparation
Manager manager = new Manager();
UnderlinePen upen = new UnderlinePen('~');
MessageBox mbox = new MessageBox('*');
MessageBox sbox = new MessageBox('/');
manager.register("strong message", upen);
manager.register("warning box", mbox);
manager.register("slash box", sbox);
//produire
Product p1 = manager.create("strong message");
p1.use("Hello, world");
Product p2 = manager.create("warning box");
p2.use("Hello, world");
Product p3 = manager.create("slash box");
p3.use("Hello, world");
}
}
// "Hello, world"
// ~~~~~~~~~~~~
// ****************
// * Hello, world *
// ****************
// ////////////////
// / Hello, world /
// ////////////////
Si vous souhaitez créer une instance, vous pouvez simplement utiliser new Something (), mais il est efficace dans les cas suivants.
Trois modèles sont apparus dans ce programme. Qu'est-ce qui utilise '~' pour souligner une chaîne Utilisez '*' pour encadrer une chaîne Utilisez '/' pour encadrer une chaîne
Comme cet exemple est simple, il existe trois modèles, mais si vous en avez envie, vous pouvez créer autant de types que vous le souhaitez. Si vous les mettez tous dans des classes séparées, le nombre de classes sera trop grand et il sera difficile de gérer la source.
Si vous souhaitez créer la même instance qui représente la figure créée par l'utilisateur, il est plus facile de copier l'instance au lieu d'utiliser la classe.
Dans l'exemple de programme, la partie qui copie l'instance (cloner) est confinée dans le package framework. Dans la méthode create de la classe Manager, une chaîne de caractères telle que "message fort" est donnée comme nom pour l'instanciation au lieu du nom de classe. On peut dire que cela rend le nouveau format Something (), qui est le mécanisme d'instanciation fourni par le langage Java, plus général, et sépare le framework de la liaison des noms de classe.
Recommended Posts