[GO] [Gang of Four] Apprentissage des modèles de conception - Composite

Composite-composite

** Table des matières ** ** Assemblez la classe avec une structure en bois. Cela semble être un motif composé d'objets appelés composites et feuilles, comme dans **.

Objectif

Assemblez des objets dans une structure arborescente pour représenter la hiérarchie entière. Le modèle composite permet au client de traiter des objets individuels et des composites d'objets de manière uniforme.

Composant

· Racine de composant, nœud, classe abstraite de feuille ・ Feuille de feuille ・ Racine ou nœud composite ・ Utilisateur client

la mise en oeuvre

Lorsque vous entendez le mot «arborescence», vous pouvez penser à une arborescence de répertoires. Par conséquent, implémentez un programme capable de gérer et de générer l'arborescence de répertoires.

Le répertoire est composite et le fichier est feuille.

Composant racine, nœud, classe abstraite de feuille

interface de répertoire et de fichier

Element.kt

package composite

interface Element {
    enum class ElementType(val type: String) {
        DIRECTORY("Direcotry"),
        FILE("File")
    }

    fun getType(): ElementType
    fun getName(): String
}

Racine ou nœud composite

classe abstraite d'annuaire

Ayez un elementList pour pouvoir gérer les éléments sous votre contrôle.

AbstractDirectory.kt

package composite

abstract class AbstractDirectory: Element {
    var elementList: MutableList<Element> = mutableListOf()

    abstract fun addElement(element: Element)
}

répertoire classe de béton

Directory.kt

package composite

class Directory(private val name: String): AbstractDirectory() {

    override fun getType(): Element.ElementType {
        return Element.ElementType.DIRECTORY
    }

    override fun addElement(element: Element) {
        elementList.add(element)
    }

    override fun getName(): String {
        return name
    }
}

Feuille feuille

fichier classe de béton

File.kt

package composite

class File(private val name: String): Element {

    override fun getType(): Element.ElementType {
        return Element.ElementType.FILE
    }

    override fun getName(): String {
        return name
    }
}

Utilisateur client

La personne qui gère l'arborescence des répertoires

DirectoryManager.kt

package composite

class DirectoryManager {
    init {
        //Dossier racine
        val rootDirectory = Directory("/")
        rootDirectory.addElement(File("sample.config"))
        rootDirectory.addElement(File("gof.env"))

        //Dossier pour les applications iOS
        val iosDirectory = Directory("iOS")

        val iosAppDirectory = Directory("GofiOSApp")
        iosAppDirectory.addElement(File("xcode.project"))

        val iosAppSourceDirectory = Directory("Source")
        iosAppSourceDirectory.addElement(File("hoge.swift"))
        iosAppSourceDirectory.addElement(File("fuga.swift"))

        iosDirectory.addElement(iosAppDirectory)
        iosAppDirectory.addElement(iosAppSourceDirectory)
        rootDirectory.addElement(iosDirectory)

        //Dossier pour les applications Android
        val androidDirectory = Directory("AndroidOS")

        val androidAppDirectory = Directory("GofAndroidApp")
        androidAppDirectory.addElement(File("AndroidManifest.xml"))

        val androidAppSourceDirectory = Directory("Source")
        androidAppSourceDirectory.addElement(File("moge.kt"))
        androidAppSourceDirectory.addElement(File("unbaba.kt"))

        androidDirectory.addElement(androidAppDirectory)
        androidAppDirectory.addElement(androidAppSourceDirectory)
        rootDirectory.addElement(androidDirectory)

        show(rootDirectory, 0)
    }

    private fun show(element: Element, indent: Int) {

        if (element is Directory) {
            println("${"----".repeat(indent)}【${element.getType().type}】${element.getName()}")
            element.elementList.forEach {
                show(it, indent + 1)
            }
        } else {
            println("${"----".repeat(indent)}【${element.getType().type}】${element.getName()}")
        }
    }
}

Ceci complète l'arborescence de répertoires en utilisant le modèle composite.

Résultat de sortie

[output]
【Direcotry】/
----【File】sample.config
----【File】gof.env
----【Direcotry】iOS
--------【Direcotry】GofiOSApp
------------【File】xcode.project
------------【Direcotry】Source
----------------【File】hoge.swift
----------------【File】fuga.swift
----【Direcotry】AndroidOS
--------【Direcotry】GofAndroidApp
------------【File】AndroidManifest.xml
------------【Direcotry】Source
----------------【File】moge.kt
----------------【File】unbaba.kt

Si vous souhaitez dupliquer le dossier / iOS / GofIosApp / Source dans la même hiérarchie, ajoutez ```iosAppDirectory.addElement (iosAppSourceDirectory) `` `.

[output]
【Direcotry】/
----【File】sample.config
----【File】gof.env
----【Direcotry】iOS
--------【Direcotry】GofiOSApp
------------【File】xcode.project
------------【Direcotry】Source
----------------【File】hoge.swift
----------------【File】fuga.swift
------------【Direcotry】Source
----------------【File】hoge.swift
----------------【File】fuga.swift
Abréviation

Vous pouvez manipuler le répertoire librement.

• Kotlin peut être utilisé pour écrire des opérations de chaîne de manière concise.