PRG_K12_Objetos.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "acefb299",
   "metadata": {
    "toc": true
   },
   "source": [
    "<h1>Table of Contents<span class=\"tocSkip\"></span></h1>\n",
    "<div class=\"toc\"><ul class=\"toc-item\"><li><span><a href=\"#K12.-Objetos\" data-toc-modified-id=\"K12.-Objetos-1\">K12. Objetos</a></span><ul class=\"toc-item\"><li><span><a href=\"#1.-Singletons\" data-toc-modified-id=\"1.-Singletons-1.1\">1. Singletons</a></span><ul class=\"toc-item\"><li><span><a href=\"#Named-Objects\" data-toc-modified-id=\"Named-Objects-1.1.1\">Named Objects</a></span></li><li><span><a href=\"#Comparación-con-las-clases\" data-toc-modified-id=\"Comparación-con-las-clases-1.1.2\">Comparación con las clases</a></span></li></ul></li><li><span><a href=\"#2.-Miembros-estáticos\" data-toc-modified-id=\"2.-Miembros-estáticos-1.2\">2. Miembros estáticos</a></span><ul class=\"toc-item\"><li><span><a href=\"#Companion-objects\" data-toc-modified-id=\"Companion-objects-1.2.1\">Companion objects</a></span></li><li><span><a href=\"#Extensiones-de-los-objetos-compañeros\" data-toc-modified-id=\"Extensiones-de-los-objetos-compañeros-1.2.2\">Extensiones de los objetos compañeros</a></span></li></ul></li><li><span><a href=\"#3.-Ejercicios\" data-toc-modified-id=\"3.-Ejercicios-1.3\">3. Ejercicios</a></span><ul class=\"toc-item\"><li><span><a href=\"#Soluciones\" data-toc-modified-id=\"Soluciones-1.3.1\">Soluciones</a></span></li></ul></li></ul></li></ul></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e52673dd",
   "metadata": {},
   "source": [
    "# K12. Objetos\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "61669eac",
   "metadata": {},
   "source": [
    "Kotlin introduce una nueva palabra reservada que no está disponible en otros lenguajes como Java, la palabra **```object```**\n",
    "\n",
    "<br>Como veremos a continuación, **```object```** nos va a permitir de forma fácil crear clases de las que sólo pueda existir una única instancia en ejecución (patrón **singleton**), así como crear **objetos anónimos**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3ba6cba1",
   "metadata": {},
   "source": [
    "## 1. Singletons\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "848ed2ce",
   "metadata": {},
   "source": [
    "El **singleton** es uno de los patrones de diseño más simples y más empleados en ingeniería del software (aunque hay quien rechaza su uso por la introducción de un **estado global** en la aplicación). Este patrón se usa cuando queremos restringir una clase de forma que sólo pueda existir una **única** instancia en tiempo de ejecución."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b9241962",
   "metadata": {},
   "source": [
    "### Named Objects"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2d3251f9",
   "metadata": {},
   "source": [
    "La palabra reservada **```object```** de Kotlin permite definir un tipo (clase) del que sólo existirá una única instancia u objeto. Lo que en terminología de Kotlin se denomina un **named object**.\n",
    "\n",
    "<br>Un tipo definido con **```object```** no puede tener constructores ya que, al sólo existir una instancia del mismo, no tiene sentido proporcionar uno\n",
    "\n",
    "<br>Supongamos la definición del siguiente objeto en Kotlin:\n",
    "\n",
    "```kotlin\n",
    "object X {\n",
    "    var x = 0\n",
    "}\n",
    "```\n",
    "\n",
    "Su equivalente en Java sería algo como:\n",
    "\n",
    "```java\n",
    "public class X {\n",
    "    private static X instance;\n",
    "    private int x;\n",
    "    \n",
    "    private X(){}\n",
    "    \n",
    "    public static X getInstance() {\n",
    "        if(instance == null) {\n",
    "            instance = new X();\n",
    "        }\n",
    "        return X;\n",
    "    }\n",
    "    \n",
    "    public int getX() {\n",
    "        return x;\n",
    "    }\n",
    "    \n",
    "    public void setX(int x) {\n",
    "        this.x = x;\n",
    "    }\n",
    "}\n",
    "```\n",
    "\n",
    "Podemos apreciar la diferencia en la cantidad de código necesario en uno y otro caso."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "19dacdcb",
   "metadata": {},
   "outputs": [],
   "source": [
    "// named object\n",
    "object X { var x = 0 }\n",
    "\n",
    "// no podemos crear nuevos objetos\n",
    "// la siguiente línea generaría un error\n",
    "//val x1 = X()\n",
    "\n",
    "// podemos obtener múltiples referencias pero siempre al mismo objeto X\n",
    "val x1 = X\n",
    "val x2 = X\n",
    "\n",
    "// siempre estaremos trabajando sobre el mismo (y único) objeto\n",
    "\n",
    "// establecemos el valor de X.x a 5 usando x1\n",
    "x1.x = 5\n",
    "println(X.x)\n",
    "\n",
    "// establecemos el valor de X.x a 10 usando x2\n",
    "x2.x = 10\n",
    "println(X.x)\n",
    "\n",
    "println(x1.x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2fe47968",
   "metadata": {},
   "source": [
    "Veamos otro ejemplo de sus uso. Vamos a crear un repositorio en memoria para un conjunto de datos que, en este caso, serán insancias de alumnos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3d177f5c",
   "metadata": {},
   "outputs": [],
   "source": [
    "data class Alumno(val id: Int, val nombre: String, val apellidos: String)\n",
    "\n",
    "val john = Alumno(1, \"John\", \"Doe\")\n",
    "val jane = Alumno(2, \"Jane\", \"Doe\")\n",
    "val bob = Alumno(3, \"Bob\", \"Sponge\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9566e7f8",
   "metadata": {},
   "source": [
    "Usando **```object```** podemos crear un registro que mantenga una lista de alumnos que nos permita añadir, eliminar así como imprimir los alumnos registrados"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c6a1cf02",
   "metadata": {},
   "outputs": [],
   "source": [
    "object Registro {\n",
    "    val lista = mutableListOf<Alumno>()\n",
    "    \n",
    "    fun add(alumno: Alumno) {\n",
    "        lista += alumno\n",
    "    }\n",
    "    \n",
    "    fun remove(alumno: Alumno) {\n",
    "        lista.remove(alumno)\n",
    "    }\n",
    "    \n",
    "    fun print() {\n",
    "        println(\"Listado de alumnnos:\")\n",
    "        lista.forEach{ \n",
    "            println(\"${it.id}: ${it.nombre} ${it.apellidos}\") \n",
    "        }\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2db84368",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "Registro.add(john)\n",
    "Registro.add(jane)\n",
    "Registro.add(bob)\n",
    "\n",
    "Registro.print()\n",
    "\n",
    "Registro.remove(john)\n",
    "\n",
    "Registro.print()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9c300b1e",
   "metadata": {},
   "source": [
    "### Comparación con las clases"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e2085639",
   "metadata": {},
   "source": [
    "Si bien, como acabamos de comprobar, este tipo de \"objetos\" de kotlin (_named objects_) no pueden tener constructores como las clases, comparten una serie de similaridades:\n",
    "\n",
    "- Pueden tener propiedades y métodos\n",
    "- Las propiedades deben inicializarse antes de su uso, ya sea en la declaración o en un bloque _init_\n",
    "- Pueden heredar de clases e implementar interfaces"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2333bff5",
   "metadata": {},
   "source": [
    "## 2. Miembros estáticos\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7c276a63",
   "metadata": {},
   "source": [
    "En lenguajes como Java, la palabra reservada **```static```** se emplea para definir miembros de la clase que son compartidos por todas sus instancias.\n",
    "\n",
    "<br>En Kotlin **no existen los miembros estáticos** al estilo de Java ni la palabra reservada **```static```**\n",
    "\n",
    "<br>Para poder crear en Kotlin miembros que se comporten de forma similar a estos miembros estáticos, se emplean los denominados **objetos compañeros** o **_companion objetcs_** dentro de la clase."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fe8b9020",
   "metadata": {},
   "source": [
    "### Companion objects"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c574d096",
   "metadata": {},
   "source": [
    "Los **objetos compañeros** o **_companion objects_** son **objetos** (_named objects_) declarados dentro de una clase (declaración anidada). \n",
    "\n",
    "<br>Para su declaración, usaremos la expresión **```companion object <name>```**, seguida por la definición del objeto. A diferencia de los _named objects_, el nombre del objeto compañero es **opcional** por lo que no se suele utilizar.\n",
    "\n",
    "<br>Para acceder a los miembros del objeto compañero, emplearemos el nombre de la clase donde se ha definido"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dc475ea6",
   "metadata": {},
   "outputs": [],
   "source": [
    "class X(var x: Int = 0) {\n",
    "    companion object {\n",
    "        var y = 0\n",
    "        fun incY() { y++ }\n",
    "    }\n",
    "    \n",
    "    fun print() { println(\"x = $x; y = $y\") }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9f9be9d4",
   "metadata": {},
   "source": [
    "En el ejemplo anterior, declaramos una clase **X** con un atributo **x**. Lógicamente, cada instancia de **X** tendrá su propia implementación de dicho atributo.\n",
    "\n",
    "<br>Sin embargo, de forma similar a lo que sería un miembro estático, todas las instancias de X van a compartir el mismo parámetro **y** definido dentro del **_companion object_**. Por tanto, si modificamos el valor de **y** a través de **X**, se modificará para todas sus instancias."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "be4d9b2d",
   "metadata": {},
   "outputs": [],
   "source": [
    "val x1 = X(5)\n",
    "val x2 = X(10)\n",
    "\n",
    "x1.print()\n",
    "x2.print()\n",
    "\n",
    "// accedemos a las propiedades y métodos del objeto compañero de X\n",
    "X.y = 15\n",
    "X.incY()\n",
    "\n",
    "x1.print()\n",
    "x2.print()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f4c9f7be",
   "metadata": {},
   "source": [
    "### Extensiones de los objetos compañeros"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bdb23f18",
   "metadata": {},
   "source": [
    "Como ya vimos, podemos extender una clase existente añadiéndole nuevos miembros (propiedades y/o métodos). También es posible extender la funcionalidad del objeto compañero definido internamente en una clase añadiendo nuevos métodos.\n",
    "\n",
    "<br>Para ello, añadiremos la palabra reservada **```Companion```** o el **nombre del objeto compañero** (en caso de que lo tenga) entre el nombre de la clase y el nombre del nuevo método"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f15cda24",
   "metadata": {},
   "outputs": [],
   "source": [
    "fun X.Companion.doubleY() {\n",
    "    y *= 2\n",
    "}\n",
    "\n",
    "X.doubleY()\n",
    "x1.print()\n",
    "\n",
    "X.doubleY()\n",
    "x2.print()    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4fe78ef4",
   "metadata": {},
   "source": [
    "## 3. Ejercicios\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dce29330",
   "metadata": {},
   "source": [
    "1. \n",
    "Crea un **named object** que te permita chequear si un valor entero está por encima de un umbral. Nombra el objeto **```Umbral```** y añádele el método **```superaUmbral(valor: Int)```**. El **```umbral```** será una propiedad del propio objeto inicializada a 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "428b0bd2",
   "metadata": {},
   "outputs": [],
   "source": [
    "// SOLUCIÓN\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1f8e44dc",
   "metadata": {},
   "outputs": [],
   "source": [
    "// TESTS\n",
    "// --> true\n",
    "println(Umbral.superaUmbral(5))\n",
    "\n",
    "// --> false\n",
    "Umbral.umbral = 5\n",
    "println(Umbral.superaUmbral(6))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9c3c23b6",
   "metadata": {},
   "source": [
    "2. \n",
    "Crea una clase de datos denominada **Articulo** con los siguientes atributos: **id** constante de tipo entero, **desc** variable de tipo cadena de caracteres y **precio** variable de tipo doble\n",
    "\n",
    "<br>Crea una clase **Almacen** que nos permita almacenar todas las instancias de Articulo en una mapa, donde la clave será el artículo y el valor el número de unidades disponibles. Tendrá los siguientes métodos:\n",
    "\n",
    "- **add** que nos permita añadir nuevos artículos al almacén. Tendrá dos parámetros: el artículo y el número de unidades añadidas. Si el artículo ya existe, se incrementará el número de unidades\n",
    "- **remove** que nos permita eliminar unidades de un artículo. No se pueden eliminar más unidades de las existentes. Devuelve el número de unidades eliminadas\n",
    "- **list** que devolverá una lista de los **id** de los productos almacenados y su stock\n",
    "- **clear** que vacía el mapa"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "89e18404",
   "metadata": {},
   "outputs": [],
   "source": [
    "// SOLUCIÓN\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8051238d",
   "metadata": {},
   "outputs": [],
   "source": [
    "// TESTS\n",
    "\n",
    "val a1 = Articulo(1, \"Item 1\", 10.0)\n",
    "val a2 = Articulo(2, \"Item 2\", 15.0)\n",
    "val a3 = Articulo(3, \"Item 3\", 20.0)\n",
    "val storage = Almacen\n",
    "\n",
    "// TEST 1\n",
    "// --> [1: 3]\n",
    "storage.clear()\n",
    "storage.add(a1, 3)\n",
    "println(storage.list())\n",
    "\n",
    "// TEST 2\n",
    "// --> [1: 5, 2: 2, 3: 4]\n",
    "storage.clear()\n",
    "storage.add(a1, 3)\n",
    "storage.add(a1, 2)\n",
    "storage.add(a2, 2)\n",
    "storage.add(a3, 4)\n",
    "println(storage.list())\n",
    "\n",
    "// TEST 3\n",
    "// --> [1: 0, 2: 1]\n",
    "storage.clear()\n",
    "storage.add(a1, 3)\n",
    "storage.remove(a1, 5)\n",
    "storage.add(a2, 2)\n",
    "storage.remove(a2, 1)\n",
    "println(storage.list())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b3206c3a",
   "metadata": {},
   "source": [
    "3. \n",
    "Crea una clase denominada **Fibonacci**. Esta clase definirá un método en un objeto compañero llamado **next()** que nos devolverá el siguiente número de la secuencia, siendo **1** el primero de ellos. Tendrá un segundo método **reset()** que reinicia la secuencia"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7101167a",
   "metadata": {},
   "outputs": [],
   "source": [
    "// SOLUCIÓN\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "945e0a59",
   "metadata": {},
   "outputs": [],
   "source": [
    "// TESTS\n",
    "\n",
    "// --> 1\n",
    "Fibonacci.reset()\n",
    "println(Fibonacci.next())\n",
    "\n",
    "// --> [1, 1, 2, 3, 5, 8, 13, 21, 34, 55]\n",
    "Fibonacci.reset()\n",
    "val result = (1..10).map { Fibonacci.next() }.joinToString(separator=\", \", prefix=\"[\", postfix=\"]\")\n",
    "println(result)\n",
    "\n",
    "// --> 1 1 2 3 1 1 2 3 1 1 \n",
    "Fibonacci.reset()\n",
    "repeat(10) {\n",
    "    if (it %4 == 0)\n",
    "        Fibonacci.reset()\n",
    "    print(Fibonacci.next().toString() + \" \")\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5cbe2ba9",
   "metadata": {},
   "source": [
    "### Soluciones\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "be09bbad",
   "metadata": {},
   "source": [
    "##### 1.\n",
    "```kotlin\n",
    "object Umbral {\n",
    "    var umbral: Int = 0\n",
    "    fun superaUmbral(valor: Int) = valor > umbral\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4acf6f9d",
   "metadata": {},
   "source": [
    "##### 2. \n",
    "```kotlin\n",
    "data class Articulo(val id: Int, var desc: String, var precio: Double)\n",
    "\n",
    "object Almacen {\n",
    "    val stock = mutableMapOf<Int, Int>()\n",
    "    \n",
    "    fun add(articulo: Articulo, unidades: Int) {\n",
    "        if (stock.containsKey(articulo.id))\n",
    "            stock[articulo.id] = stock[articulo.id]!! + unidades\n",
    "        else\n",
    "            stock[articulo.id] = unidades\n",
    "    }\n",
    "    \n",
    "    fun remove(articulo: Articulo, unidades: Int): Int {\n",
    "        if (stock.containsKey(articulo.id)) {\n",
    "            stock[articulo.id] = max(0, stock[articulo.id]!! - unidades)\n",
    "            return stock[articulo.id]?:0\n",
    "        }\n",
    "        \n",
    "        return 0\n",
    "    }\n",
    "    \n",
    "    fun list() = stock.map { \"${it.key}: ${it.value}\" }\n",
    "    \n",
    "    fun clear() { stock.clear() }\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "44444b3b",
   "metadata": {},
   "source": [
    "##### 3.\n",
    "```kotlin\n",
    "class Fibonacci {\n",
    "    companion object {\n",
    "        var _t = 0\n",
    "        var _num = 1\n",
    "        var _prev = 1\n",
    "        fun next(): Int {\n",
    "            _t++\n",
    "            if (_t > 2) {\n",
    "                val oldNum = _num\n",
    "                _num += _prev\n",
    "                _prev = oldNum\n",
    "            }\n",
    "            return _num\n",
    "        } \n",
    "        fun reset() {\n",
    "            _t = 0\n",
    "            _num = 1\n",
    "            _prev = 1\n",
    "        }\n",
    "    }\n",
    "}\n",
    "```"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Kotlin",
   "language": "kotlin",
   "name": "kotlin"
  },
  "language_info": {
   "codemirror_mode": "text/x-kotlin",
   "file_extension": ".kt",
   "mimetype": "text/x-kotlin",
   "name": "kotlin",
   "nbconvert_exporter": "",
   "pygments_lexer": "kotlin",
   "version": "1.8.0-RC"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": false,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": true,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}