27 - POO - modificadores de acceso private y public

Uno de los principios fundamentales de la programación orientada a objetos es el encapsulamiento, esto se logra agrupando una serie de métodos y propiedades dentro de una clase.

En Kotlin cuando implementamos una clase por defecto todas las propiedades y métodos son de tipo public. Un método o propiedad public se puede acceder desde donde definimos un objeto de dicha clase.

En el caso que necesitemos definir métodos y propiedades que solo se puedan acceder desde dentro de la clase las debemos definir con el modificador private.

Problema 1

Plantear una clase Operaciones que en un método solicite la carga de 2 enteros y posteriormente llame desde el mismo método a otros dos métodos privados que calculen su suma y producto.

Proyecto122 - Principal.kt

class Operaciones {
    private var valor1: Int = 0
    private var valor2: Int = 0

    fun cargar() {
        print("Ingrese primer valor:")
        valor1 = readln().toInt()
        print("Ingrese segundo valor:")
        valor2 = readln().toInt()
        sumar()
        restar()
    }

    private fun sumar() {
        val suma = valor1 + valor2
        println("La suma de $valor1 y $valor2 es $suma")
    }

    private fun restar() {
        val resta = valor1 - valor2
        println("La resta de $valor1 y $valor2 es $resta")
    }
}

fun main(parametro: Array<String>) {
    val operaciones1 = Operaciones()
    operaciones1.cargar()
}

Un método se lo define como privado antecediendo la palabra clave private:

    private fun sumar() {
        val suma = valor1 + valor2
        println("La suma de $valor1 y $valor2 es $suma")
    }

Luego si queremos acceder a dicho método desde donde definimos un objetos se genera un error sintáctico:

Lo mismo si queremos ocultar el acceso de una propiedad desde fuera de la clase debemos anteceder la palabra clave private:

    private var valor1: Int = 0
    private var valor2: Int = 0

La palabra clave public no es necesaria agregarla a un método o propiedad ya que es el valor por defecto que toma el compilador de Kotlin cuando las definimos. No genera error pero es redundante entonces escribir dicho modificador:

Problema 2

Plantear una clase llamada Dado. Definir una propiedad privada llamada valor y tres métodos uno privado que dibuje una línea de asteríscos y otro dos públicos, uno que genere un número aleatorio entre 1 y 6 y otro que lo imprima llamando en este último al que dibuja la línea de asteríscos.

Proyecto123 - Principal.kt

class Dado{
    private var valor: Int = 1
    fun tirar() {
        valor = ((Math.random() * 6) + 1).toInt()
    }

    fun imprimir() {
        separador()
        println("Valor del dado: $valor")
        separador()
    }

    private fun separador() = println("**************************************")
}

fun main(parametro: Array<String>) {
    val dado1 = Dado()
    dado1.tirar()
    dado1.imprimir()
}

Definimos la propiedad valor de tipo private:

    private var valor: Int = 1

El método separador también lo definimos private:

    private fun separador() = println("**************************************")

Desde la función main donde definimos un objeto de la clase Dado solo podemos acceder a los métodos tirar e imprimir:

fun main(parametro: Array<String>) {
    val dado1 = Dado()
    dado1.tirar()
    dado1.imprimir()
}

Problema propuesto

• Desarrollar una clase que defina una propiedad privada de tipo arreglo de 5 enteros. En el bloque init llamar a un método privado que cargue valores aleatorios comprendidos entre 0 y 10.
  Definir otros tres métodos públicos que muestren el arreglo, el mayor y el menor elemento.

Solución

Proyecto124

class Vector {
    private val vec = IntArray(5)
    init {
        cargar()
    }

    private fun cargar() {
        for(i in vec.indices)
            vec[i] = ((Math.random() * 11)).toInt()
    }

    fun imprimir() {
        println("Listado completo del arreglo")
        for(i in vec.indices)
            print("${vec[i]} - ")
        println()
    }

    fun mostrarMayor() {
        var mayor = vec[0]
        for(i in vec.indices)
            if (vec[i] > mayor)
                mayor = vec[i]
        println("El elemento mayor del arreglo es $mayor")
    }

    fun mostrarMenor() {
        var menor = vec[0]
        for(i in vec.indices)
            if (vec[i] < menor)
                menor = vec[i]
        println("El elemento menor del arreglo es $menor")
    }
}

fun main(parametro: Array<String>) {
    val vector1 = Vector()
    vector1.imprimir()
    vector1.mostrarMayor()
    vector1.mostrarMenor()
}