Clases en Kotlin

A continuación os dejo como es el funcionamiento de la creación de clases y constructores en Kotlin, ya que dista un poco de cómo se trabaja en Java:

package com.albrivas.kotlin.clases

import android.util.Log

// DOC: #https://kotlinlang.org/docs/reference/classes.html
// DOC: #https://kotlinlang.org/docs/reference/properties.html
// DOC: #https://kotlinlang.org/docs/reference/data-classes.html
// DOC: #https://kotlinlang.org/docs/reference/enum-classes.html
// DOC: #https://kotlinlang.org/docs/reference/object-declarations.html

// Clases son públicas y final por defecto
// Si queremos que una clase se pueda ser heredada, usaremos open (open class XXX)

class Clases {

    private fun showCase1() {
        // Clases en Kotlin pueden tener un constructor PRIMARIO y uno o más constructores SECUNDARIOS.
        // PRIMARIO se encuentra en la firma de la declaración de la clase.
        // SECUNDARIO se encuentra dentro de la declaración de la clase.

        // CONSTRUCTORES PRIMARIOS
        class Person1

        class Person2 constructor(var firstName: String) // constructor PRIMARIO
        class Person3(var firstName: String) // "constructor" puede ser omitido
        class Person4(val firstName: String, val lastName: String, var age: Int) {
            init {
                age = 10
            }
        }

        class Person5(val firstName: String = "Alberto", val lastName: String = "Sanchez", var age: Int = 27)

        // Para crear instancias de objetos, no usamos la palabra "new"
        val p1 = Person1()
        val p2 = Person2("Alberto")
        val p3 = Person3("Alberto")
        val p4 = Person4("Alberto", "Sanchez", 27)
        val p5_1 = Person5("Roberto", "Perez", 50)
        val p5_2 = Person5()
        val p5_3 = Person5("Roberto")
        val p5_4 = Person5(age = 50)
    }

    private fun showCase2() {
        // Clases en Kotlin pueden tener un constructor PRIMARIO y uno o más constructores SECUNDARIOS.
        // PRIMARIO se encuentra en la firma de la declaración de la clase.
        // SECUNDARIO se encuentra dentro de la declaración de la clase.

        // CONSTRUCTORES SECUNDARIOS (son menos usados en Kotlin)
        open class Person {
            constructor(firstName: String, lastName: String) {
                Log.w("CLASSES-2", "Welcome $firstName $lastName!")
            }
        }

        class Person1 : Person {
            constructor(firstName: String) : super(firstName, "Sanchez")
            constructor(firstName: String, lastName: String) : super(firstName, lastName)
        }

        val p = Person1("Alberto", "Sanchez")
        // No tenemos acceso a person.firstName, ver showCase numero 5
    }

    private fun showCase3() {
        // Diferencia entre INIT Y CONSTRUCTOR secundario

        class Person1 {

            // Init se va a ejecutar antes que el constructor secundario y después que el constructor primario
            init {
                Log.w("CLASSES-3", "Welcome from INIT!") // No puedes acceder a firstName o lastName
            }

            constructor(firstName: String, lastName: String) {
                Log.w("CLASSES-3", "Welcome from SECONDARY CONSTRUCTOR!")
            }

        }

        class Person2(firstName: String, lastName: String) {
            init {
                // Aquí si podemos acceder a las propiedades, conservando init y constructor secundario
            }

            constructor() : this("Alberto", "Sanchez")
        }

        val p1 = Person1("Alberto", "Sanchez")
        val p2 = Person2("Roberto", "Perez")
        val p3 = Person2() // Alberto Sanchez
    }

    private fun showCase4() {
        // ¿VAL, VAR O NADA EN EL CONSTRUCTOR?
        class Person1(firstName: String) // No puedes acceder a firstName cuando crees la instancia

        class Person2(var firstName: String) // Puedes acceder a firstName cuando crees la instancia. Puedes cambiar su valor
        class Person3(val firstName: String) // Puedes acceder a firstName cuando crees la instancia. No Puedes cambiar su valor

        val p1 = Person1("")
        val p2 = Person2("")
        val p3 = Person3("")

        // p1.firstName // Error
        p2.firstName
        p3.firstName
    }

    private fun showCase5() {
        // PROPIEDADES - GETTERS & SETTERS

        class Person1(var firstName: String)

        val p1 = Person1("Alberto")
        p1.firstName // Sería el equivalente a getFirstName()
        p1.firstName = "Antonio" // Sería el equivalente a setFirstName("Antonio")

        class Person2 {
            // field - representa a la propiedad, nunca usar this.propiedad
            var firstName: String
                get() = field.capitalize()
                set(value) {
                    field = value.capitalize()
                }

            constructor(firstName: String, lastName: String) {
                this.firstName = firstName
            }
        }
    }

    private fun showCase6() {

        // HERENCIA E INTERFACES

        open class Person1(var name: String)
        open class Person2(open var name: String)
        open class Person3(open var name: String)

        // Si heredamos de Person1, las propiedades no se pueden llamar de igual forma entre padre e hijo
        // class Person11(var name: String) : Person1(name)

        // Podemos mantener ambas con el mismo nombre, peor tenemos que añadir open y override
        class Person22(override var name: String) : Person2(name)

        // Todo junto
        class Person33(override var name: String, override var age: Int) : Person3(name), IPerson {
            override fun hello() {}
        }
    }

    private fun showCase7() {
        // OVERRIDE y SUPER
        abstract class Person(open var firstName: String, open var lastName: String) {
            abstract fun hello()

            fun welcomeKotlin() {
                Log.w("CLASSES-7", "Welcome to Kotlin!")
            }

            open fun welcomeDevelopers() {
                Log.w("CLASSES-7", "Welcome Developers!")
            }
        }

        class Man(override var firstName: String, override var lastName: String) : Person(firstName, lastName) {
            override fun hello() {
                Log.w("CLASSES-7", "Hello, I am $firstName $lastName.")
            }
            override fun welcomeDevelopers() {
                super.welcomeDevelopers()
                super.welcomeKotlin()
                Log.w("CLASSES-7", "YaY!!")
            }

        }

        val man = Man("Alberto", "Sanchez")
        man.hello()
        man.welcomeKotlin()
        man.welcomeDevelopers()
    }

    private fun showCase8() {
        // DATA CLASSES
        // Según la documentación oficial, para hacer uso correcto de Data Classes debe:
        // El constructor primario necesita tener al menos 1 parámetro
        // Todos los parámetros del constructor primario deben ser marcados como "val" o "var"
        // Data classes no pueden ser "abstract, open, sealed or inner"

        data class Person(var firstName: String, var lastName: String)

        val p = Person("Alberto", "Sanchez")
        val p2 = p
        val personString = p.toString()
        val personCopy = p.copy()
        val clone = p.copy(firstName = "Antonio")
        val (firstName, lastName) = p // Destructuring

        Log.w("CLASSES-8", "Data class toString() => $personString")
        Log.w("CLASSES-8", "Data class copy() => $personCopy")
        Log.w("CLASSES-8", "p must be same reference than p2 => ${p === p2}") // True, Referential Equality
        Log.w("CLASSES-8", "p must be different reference than personCopy => ${p !== personCopy}") // True, Referential Equality
        Log.w("CLASSES-8", "p must have same property values than personCopy => ${p == personCopy}") // True, Structural Equality
        Log.w("CLASSES-8", "p must be different reference than clone => ${p !== clone}") // True, Referential Equality
        Log.w("CLASSES-8", "p must have different property values than clone => ${p != clone}") // True, Structural Equality
        Log.w("CLASSES-8", "firstName by destructuring must be 'Alberto' => $firstName")
        Log.w("CLASSES-8", "lastName by destructuring must be 'Sanchez' => $lastName")
    }

    private fun showCase9() {
        // ENUM CLASSES

        Log.w("CLASSES-9", "ENUM DayOfWeek.MONDAY should be MONDAY => ${DayOfWeek.MONDAY.name}")
        Log.w("CLASSES-9", "ENUM DayOfWeek.MONDAY should be 0 => ${DayOfWeek.MONDAY.ordinal}")
        Log.w("CLASSES-9", "ENUM DayOfWeek.FRIDAY should be FRIDAY => ${DayOfWeek.FRIDAY.name}")
        Log.w("CLASSES-9", "ENUM DayOfWeek.FRIDAY should be 4 => ${DayOfWeek.FRIDAY.ordinal}")
    }


    fun showCases() {
        showCase1()
        showCase2()
        showCase3()
        showCase4()
        showCase5()
        showCase6()
        showCase7()
        showCase8()
        showCase9()
    }
}

interface IPerson {
    var age: Int
    fun hello()
}

enum class DayOfWeek { MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY }

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

package com.albrivas.kotlin.clases

import android.util.Log

// DOC: #https://kotlinlang.org/docs/reference/classes.html

// DOC: #https://kotlinlang.org/docs/reference/properties.html

// DOC: #https://kotlinlang.org/docs/reference/data-classes.html

// DOC: #https://kotlinlang.org/docs/reference/enum-classes.html

// DOC: #https://kotlinlang.org/docs/reference/object-declarations.html

// Clases son públicas y final por defecto

// Si queremos que una clase se pueda ser heredada, usaremos open (open class XXX)

class Clases {

private fun showCase1() {

// Clases en Kotlin pueden tener un constructor PRIMARIO y uno o más constructores SECUNDARIOS.

// PRIMARIO se encuentra en la firma de la declaración de la clase.

// SECUNDARIO se encuentra dentro de la declaración de la clase.

// CONSTRUCTORES PRIMARIOS

class Person1

class Person2 constructor(var firstName: String) // constructor PRIMARIO

class Person3(var firstName: String) // "constructor" puede ser omitido

class Person4(val firstName: String, val lastName: String, var age: Int) {

init {

age = 10

}

class Person5(val firstName: String = "Alberto", val lastName: String = "Sanchez", var age: Int = 27)

// Para crear instancias de objetos, no usamos la palabra "new"

val p1 = Person1()

val p2 = Person2("Alberto")

val p3 = Person3("Alberto")

val p4 = Person4("Alberto", "Sanchez", 27)

val p5_1 = Person5("Roberto", "Perez", 50)

val p5_2 = Person5()

val p5_3 = Person5("Roberto")

val p5_4 = Person5(age = 50)

}

private fun showCase2() {

// Clases en Kotlin pueden tener un constructor PRIMARIO y uno o más constructores SECUNDARIOS.

// PRIMARIO se encuentra en la firma de la declaración de la clase.

// SECUNDARIO se encuentra dentro de la declaración de la clase.

// CONSTRUCTORES SECUNDARIOS (son menos usados en Kotlin)

open class Person {

constructor(firstName: String, lastName: String) {

Log.w("CLASSES-2", "Welcome $firstName $lastName!")

}

class Person1 : Person {

constructor(firstName: String) : super(firstName, "Sanchez")

constructor(firstName: String, lastName: String) : super(firstName, lastName)

}

val p = Person1("Alberto", "Sanchez")

// No tenemos acceso a person.firstName, ver showCase numero 5

}

private fun showCase3() {

// Diferencia entre INIT Y CONSTRUCTOR secundario

class Person1 {

// Init se va a ejecutar antes que el constructor secundario y después que el constructor primario

init {

Log.w("CLASSES-3", "Welcome from INIT!") // No puedes acceder a firstName o lastName

}

constructor(firstName: String, lastName: String) {

Log.w("CLASSES-3", "Welcome from SECONDARY CONSTRUCTOR!")

}

class Person2(firstName: String, lastName: String) {

init {

// Aquí si podemos acceder a las propiedades, conservando init y constructor secundario

}

constructor() : this("Alberto", "Sanchez")

}

val p1 = Person1("Alberto", "Sanchez")

val p2 = Person2("Roberto", "Perez")

val p3 = Person2() // Alberto Sanchez

}

private fun showCase4() {

// ¿VAL, VAR O NADA EN EL CONSTRUCTOR?

class Person1(firstName: String) // No puedes acceder a firstName cuando crees la instancia

class Person2(var firstName: String) // Puedes acceder a firstName cuando crees la instancia. Puedes cambiar su valor

class Person3(val firstName: String) // Puedes acceder a firstName cuando crees la instancia. No Puedes cambiar su valor

val p1 = Person1("")

val p2 = Person2("")

val p3 = Person3("")

// p1.firstName // Error

p2.firstName

p3.firstName

}

private fun showCase5() {

// PROPIEDADES - GETTERS & SETTERS

class Person1(var firstName: String)

val p1 = Person1("Alberto")

p1.firstName // Sería el equivalente a getFirstName()

p1.firstName = "Antonio" // Sería el equivalente a setFirstName("Antonio")

class Person2 {

// field - representa a la propiedad, nunca usar this.propiedad

var firstName: String

get() = field.capitalize()

set(value) {

field = value.capitalize()

}

constructor(firstName: String, lastName: String) {

this.firstName = firstName

}

private fun showCase6() {

// HERENCIA E INTERFACES

open class Person1(var name: String)

open class Person2(open var name: String)

open class Person3(open var name: String)

// Si heredamos de Person1, las propiedades no se pueden llamar de igual forma entre padre e hijo

// class Person11(var name: String) : Person1(name)

// Podemos mantener ambas con el mismo nombre, peor tenemos que añadir open y override

class Person22(override var name: String) : Person2(name)

// Todo junto

class Person33(override var name: String, override var age: Int) : Person3(name), IPerson {

override fun hello() {}

}

private fun showCase7() {

// OVERRIDE y SUPER

abstract class Person(open var firstName: String, open var lastName: String) {

abstract fun hello()

fun welcomeKotlin() {

Log.w("CLASSES-7", "Welcome to Kotlin!")

}

open fun welcomeDevelopers() {

Log.w("CLASSES-7", "Welcome Developers!")

}

class Man(override var firstName: String, override var lastName: String) : Person(firstName, lastName) {

override fun hello() {

Log.w("CLASSES-7", "Hello, I am $firstName $lastName.")

}

override fun welcomeDevelopers() {

super.welcomeDevelopers()

super.welcomeKotlin()

Log.w("CLASSES-7", "YaY!!")

}

val man = Man("Alberto", "Sanchez")

man.hello()

man.welcomeKotlin()

man.welcomeDevelopers()

}

private fun showCase8() {

// DATA CLASSES

// Según la documentación oficial, para hacer uso correcto de Data Classes debe:

// El constructor primario necesita tener al menos 1 parámetro

// Todos los parámetros del constructor primario deben ser marcados como "val" o "var"

// Data classes no pueden ser "abstract, open, sealed or inner"

data class Person(var firstName: String, var lastName: String)

val p = Person("Alberto", "Sanchez")

val p2 = p

val personString = p.toString()

val personCopy = p.copy()

val clone = p.copy(firstName = "Antonio")

val (firstName, lastName) = p // Destructuring

Log.w("CLASSES-8", "Data class toString() => $personString")

Log.w("CLASSES-8", "Data class copy() => $personCopy")

Log.w("CLASSES-8", "p must be same reference than p2 => ${p === p2}") // True, Referential Equality

Log.w("CLASSES-8", "p must be different reference than personCopy => ${p !== personCopy}") // True, Referential Equality

Log.w("CLASSES-8", "p must have same property values than personCopy => ${p == personCopy}") // True, Structural Equality

Log.w("CLASSES-8", "p must be different reference than clone => ${p !== clone}") // True, Referential Equality

Log.w("CLASSES-8", "p must have different property values than clone => ${p != clone}") // True, Structural Equality

Log.w("CLASSES-8", "firstName by destructuring must be 'Alberto' => $firstName")

Log.w("CLASSES-8", "lastName by destructuring must be 'Sanchez' => $lastName")

}

private fun showCase9() {

// ENUM CLASSES

Log.w("CLASSES-9", "ENUM DayOfWeek.MONDAY should be MONDAY => ${DayOfWeek.MONDAY.name}")

Log.w("CLASSES-9", "ENUM DayOfWeek.MONDAY should be 0 => ${DayOfWeek.MONDAY.ordinal}")

Log.w("CLASSES-9", "ENUM DayOfWeek.FRIDAY should be FRIDAY => ${DayOfWeek.FRIDAY.name}")

Log.w("CLASSES-9", "ENUM DayOfWeek.FRIDAY should be 4 => ${DayOfWeek.FRIDAY.ordinal}")

}

fun showCases() {

showCase1()

showCase2()

showCase3()

showCase4()

showCase5()

showCase6()

showCase7()

showCase8()

showCase9()

}

interface IPerson {

var age: Int

fun hello()

}

enum class DayOfWeek { MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY }

Publicado por Alberto en 28 agosto 201828 agosto 2018

0 comentarios

Deja una respuesta Cancelar la respuesta

Android

Accediendo a las vistas con ViewBinding

Android

Utilizando Anko para pasar entre actividades

Android

Unable to connect to ADB in Android Studio

Clases en Kotlin

Publicado por Alberto en 28 agosto 201828 agosto 2018

0 comentarios

Deja una respuesta Cancelar la respuesta

Entradas relacionadas

Android

Accediendo a las vistas con ViewBinding

Android

Utilizando Anko para pasar entre actividades

Android

Unable to connect to ADB in Android Studio