Come eliminare i quattro costruttori in una vista…

Puoi usare il metodo factory o il pattern builder invece di usare direttamente i costruttori.

Metodo factory: Permette di creare istanze della vista, astrarre il processo di creazione e nascondere la logica di scelta del costruttore necessario.

class MyCustomView private constructor(
    context: Context,
    attrs: AttributeSet?,
    defStyleAttr: Int,
    defStyleRes: Int
) : View(context, attrs, defStyleAttr, defStyleRes) {

    // Costruttore privato per forzare l'uso dei metodi factory

    companion object {
        fun createDefault(context: Context): MyCustomView {
            // Logica di inizializzazione per il costruttore di default
            return MyCustomView(context, null, 0, 0)
        }

        fun createFromAttrs(context: Context, attrs: AttributeSet?): MyCustomView {
            // Logica di inizializzazione con attributi
            return MyCustomView(context, attrs, 0, 0)
        }

        // Metodi factory aggiuntivi per altre combinazioni di costruttori
    }
}

Pattern builder: È utile quando ci sono molti costruttori o hanno molti parametri opzionali. Permette di creare l'oggetto passo dopo passo.

class MyCustomView private constructor(
    private val context: Context,
    private val attrs: AttributeSet?,
    private val defStyleAttr: Int,
    private val defStyleRes: Int
) : View(context, attrs, defStyleAttr, defStyleRes) {

    // Costruttore privato

    class Builder(private val context: Context) {
        private var attrs: AttributeSet? = null
        private var defStyleAttr: Int = 0
        private var defStyleRes: Int = 0

        fun setAttrs(attrs: AttributeSet?) = apply { this.attrs = attrs }
        fun setDefStyleAttr(defStyleAttr: Int) = apply { this.defStyleAttr = defStyleAttr }
        fun setDefStyleRes(defStyleRes: Int) = apply { this.defStyleRes = defStyleRes }

        fun build(): MyCustomView {
            // Logica di creazione e inizializzazione della vista in base ai parametri
            return MyCustomView(context, attrs, defStyleAttr, defStyleRes)
        }
    }
}

// Uso del builder
val myView = MyCustomView.Builder(context)
    .setAttrs(attrs)
    .build()

La scelta tra metodo factory e pattern builder dipende dalla complessità dell'inizializzazione della vista. Per casi più semplici, i metodi factory sono sufficienti. Per casi complessi con molte opzioni, è preferibile usare il pattern builder.

Come eliminare i quattro costruttori in una vista personalizzata (CustomView)?