[JAVA] J'ai écrit un modèle de conception dans l'édition Kotlin Factory
Pour apprendre le concept d'interface et la réutilisabilité des objets, qui sont importants dans l'orientation des objets ["Introduction aux modèles de conception appris en langage Java"](https://www.amazon.co.jp/%E5%A2%97% E8% A3% 9C% E6% 94% B9% E8% A8% 82% E7% 89% 88Java% E8% A8% 80% E8% AA% 9E% E3% 81% A7% E5% AD% A6% E3% 81% B6% E3% 83% 87% E3% 82% B6% E3% 82% A4% E3% 83% B3% E3% 83% 91% E3% 82% BF% E3% 83% BC% E3% 83% B3% E5% 85% A5% E9% 96% 80-% E7% B5% 90% E5% 9F% 8E-% E6% B5% A9 / dp / 4797327030 / ref = sr_1_1? __Mk_ja_JP =% E3% 82% AB % E3% 82% BF% E3% 82% AB% E3% 83% 8A & mots-clés = java% E8% A8% 80% E8% AA% 9E% E3% 81% A7% E5% AD% A6% E3% 81% B6 % E3% 83% 87% E3% 82% B6% E3% 82% A4% E3% 83% B3% E3% 83% 91% E3% 82% BF% E3% 83% BC% E3% 83% B3% E5 J'ai appris à propos de% 85% A5% E9% 96% 80 & qid = 1559563427 & s = gateway & sr = 8-1) et j'ai décidé d'écrire en kotlin pendant que j'étais en Java. Cette fois, j'écrirai sur Factory.
Qu'est-ce que l'usine
Modèle de modèle est conçu pour que la superclasse définisse le cadre de traitement (traitement partagé similaire) et la sous-classe définit le contenu spécifique. Bien qu'il s'agisse d'un modèle, c'est un modèle de conception qui définit le cadre de l'instanciation. Ce qui suit implémentera le cadre de création d'instances et la sous-classe qui "crée une carte d'identité (instance)".
Classe de produit
Cette classe est une classe abstraite qui définit le «produit», et la méthode d'utilisation est définie en partant du principe que le produit est «utilisé». De plus, l'abstraction peut la forcer à être «utilisée» comme un rôle de produit. (J'ai ressenti l'intention.)
Dans kotlin, même si vous ne spécifiez pas Unit comme void, le type de la fonction qui ne spécifie pas la valeur de retour sera Unit. Il a également été souligné qu'il est redondant dans l'IDE.
Référence: Connaître le type de Kotlin ~ Partie 1 ~
Product.java
abstract class Product {
public abstract void use();
}
Product.kt
abstract class Product {
abstract fun use()
}
Classe d'usine
Ici, nous allons implémenter le cadre d'instanciation. Le fait est que «créer un produit» et «s'enregistrer auprès d'un produit» sont laissés à l'implémentation de la sous-classe, mais la procédure de la méthode create peut lire l'intention que «la définition est décidée» comme finale dans la classe Factory. Je vais.
La différence entre Kotlin et java protected est que Java est accessible à partir d'une sous-classe ou d'une classe du même package, tandis que Kotlin n'est accessible qu'à partir d'une sous-classe. Ici, nous utilisons kotlin protected, qui n'est accessible qu'à partir des sous-classes.
Référence: Relation entre les modificateurs d'accès kotlin et java
De plus, en Java, il s'agit d'une méthode de création finale publique, mais kotlin est «default» et est une méthode finale publique, elle n'est donc pas spécifiée.
Factory.java
abstract class Factory {
public final Product create(String owner) {
Product p = createProduct(owner);
registerProduct(p);
return p;
}
protected abstract Product createProduct(String owner);
protected abstract void registerProduct(Product product);
}
Factory.kt
abstract class Factory {
fun create(owner: String): Product {
val p = createProduct(owner)
registerProduct(p)
return p
}
protected abstract fun createProduct(owner: String): Product
protected abstract fun registerProduct(product: Product)
}
Classe IDCard
Nous définirons les sous-classes comme des produits réels qui héritent de la classe Product.
Définissez ʻinit` lors de l'initialisation du constructeur avec kotlin.
Référence: [Kotlin] Comment écrire un constructeur
IDCard.java
class IDCard extends Product {
private String owner;
public IDCard(String owner) {
System.out.println(owner + "Faites une carte.");
this.owner = owner;
}
public void use() {
System.out.println(owner + "Utilisez la carte.");
}
public String getOwner() {
return owner;
}
}
IDCard.kt
class IDCard (private val owner: String): Product() {
init { println(owner + "Faites une carte.") }
override fun use() = println(owner + "Utilisez la carte.")
fun getOwner() = owner
}
Classe IDCardFactory
Il hérite de la classe Factory, qui est le cadre de création d'une instance, et implémente un traitement spécifique. La méthode createProduct qui crée une instance et crée réellement le produit, et la méthode registerProduct qui réalise l'enregistrement dans le champ des propriétaires sont implémentées.
Dans Kotlin, List semble être en lecture seule et utilise mutableList qui peut être ajouté.
Référence: Kotlin and List
De plus, Kotlin n'utilise pas new lors de l'instanciation.
De plus, au lieu d'instanceof dans la distribution, nous avons implémenté une distribution intelligente que le compilateur gérera bien.
Référence: Là où les programmeurs Java ont tendance à trébucher sur Kotlin
IDCardFactory.java
class IDCardFactory extends Factory {
private List<String> owners = new ArrayList<String>();
@Override
protected Product createProduct(String owner) {
return new IDCard(owner);
}
@Override
protected void registerProduct(Product product) {
owners.add(((IDCard)product).getOwner());
}
public List<String> getOwners() {
return owners;
}
}
IDCardFactory.kt
class IDCardFactory: Factory() {
private var owners: MutableList<String> = mutableListOf()
override fun createProduct(owner: String) = IDCard(owner)
override fun registerProduct(product: Product) {
if(product is IDCard) owners.add(product.getOwner()) //smart cast
}
fun getOwners() = owners
}
Classe principale
Je vais créer une carte d'identité.
FactorySample.java
public class FactorySample {
public static void main(String[] args) {
Factory factory = new IDCardFactory();
Product card1 = factory.create("Sato");
Product card2 = factory.create("Suzuki");
Product card3 = factory.create("Tanaka");
card1.use();
card2.use();
card3.use();
((IDCardFactory)factory).getOwners().stream().forEach(System.out::println);
}
}
FactorySample.kt
fun main(args: Array<String>){
val factory = IDCardFactory()
val card1 = factory.create("Sato")
val card2 = factory.create("Suzuki")
val card3 = factory.create("Tanaka")
card1.use()
card2.use()
card3.use()
factory.getOwners().forEach(System.out::println)
}
Résultat d'exécution
Faites la carte de Sato.
Je vais faire une carte Suzuki.
Fabriquez la carte de Tanaka.
J'utiliserai la carte de Sato.
J'utiliserai la carte de Suzuki.
J'utiliserai la carte de Tanaka.
Sato
Suzuki
Tanaka
Diagramme de classe
Impressions
-
La classe Factory ne décrit pas la classe IDCard qui est réellement générée, et le produit est généré en appelant les méthodes de création de produit et d'instance, j'ai donc appris que c'est un avantage qu'il n'y a pas de liaison par un nom de classe spécifique. Il est.
-
Comme je n'ai pas beaucoup mentionné ci-dessus, si Factory et Product sont dans le même package et que IDCard et IDCardFactory sont définis dans des packages différents (par exemple, package framework et package idcard), il n'y a pas de liaison par une classe ou un package spécifique. J'ai appris à exprimer que "le paquet de framwork ne dépend pas du paquet de carte d'identité".
-
J'ai appris les points suivants sur Kotlin
- Si aucune valeur de retour n'est spécifiée, void ʻUnit` est spécifié par défaut, il n'est donc pas nécessaire de le définir.
- La spécification de «protected» est différente de Java
- La définition de la méthode est «public final» par défaut
- Utilisez ʻinit` pour initialiser le constructeur
Listpeut être en lecture seule,mutableListpeut être ajouté- Ne pas utiliser new lors de la création d'une instance
- «smart cast» est pratique pour le casting
référence
C'était très facile à lire et à comprendre en se référant à ce qui suit.
Connaître le type de Kotlin ~ Partie 1 ~ Relation entre les modificateurs d'accès kotlin et java [Kotlin] Comment écrire un constructeur Kotlin et List Classes de syntaxe Kotlin, héritage, propriétés Là où les programmeurs Java ont tendance à trébucher sur Kotlin