PRG_K10_Clases.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "b3d83ac5",
   "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=\"#K10.-Clases\" data-toc-modified-id=\"K10.-Clases-1\">K10. Clases</a></span><ul class=\"toc-item\"><li><span><a href=\"#1.-Creación-de-Clases\" data-toc-modified-id=\"1.-Creación-de-Clases-1.1\">1. Creación de Clases</a></span><ul class=\"toc-item\"><li><span><a href=\"#Identidad-de-Objetos\" data-toc-modified-id=\"Identidad-de-Objetos-1.1.1\">Identidad de Objetos</a></span></li></ul></li><li><span><a href=\"#2.-Métodos\" data-toc-modified-id=\"2.-Métodos-1.2\">2. Métodos</a></span></li><li><span><a href=\"#3.-Clases-de-Datos-(Data-classes)\" data-toc-modified-id=\"3.-Clases-de-Datos-(Data-classes)-1.3\">3. Clases de Datos (<em>Data classes</em>)</a></span><ul class=\"toc-item\"><li><span><a href=\"#Desestructurando-clases-de-datos\" data-toc-modified-id=\"Desestructurando-clases-de-datos-1.3.1\">Desestructurando clases de datos</a></span></li></ul></li><li><span><a href=\"#4.-Ejercicios\" data-toc-modified-id=\"4.-Ejercicios-1.4\">4. Ejercicios</a></span><ul class=\"toc-item\"><li><span><a href=\"#Soluciones\" data-toc-modified-id=\"Soluciones-1.4.1\">Soluciones</a></span></li></ul></li></ul></li></ul></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7453489e",
   "metadata": {},
   "source": [
    "# K10. Clases\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9e78cb6f",
   "metadata": {},
   "source": [
    "## 1. Creación de Clases\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3f4507fe",
   "metadata": {},
   "source": [
    "Las clases son una de las piedras angulares de la programación orientada a objetos. Veamos un ejemplo de definición de clase en Kotlin"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ecb49240",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Persona(var nombre: String, var apellidos: String) {\n",
    "    val nombreCompleto\n",
    "        get() = nombre + \" \" + apellidos\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "166339d6",
   "metadata": {},
   "source": [
    "El código anterior define una clase mediante la palabra reservada **```class```** de nombre **Persona**. Entre paréntesis se establece su **constructor primario**, que en este caso define dos **propiedades** mutables de tipo ```String``` para almacenar el nombre y los apellidos. La clase Persona define otra propiedad no mutable, **```nombreCompleto```** con un **getter** asociado.\n",
    "\n",
    "<br>La misma clase en Java, omitiendo modificadores de acceso, sería algo como:\n",
    "\n",
    "```java\n",
    "class Persona {\n",
    "    String nombre;\n",
    "    String apellidos;\n",
    "    \n",
    "    Persona(String nombre, String apellidos) {\n",
    "        this.nombre = nombre;\n",
    "        this.apellidos = apellidos;\n",
    "    }\n",
    "    \n",
    "    String nombreCompleto() {\n",
    "        return nombre + \" \" + apellidos;\n",
    "    }\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7a44d2e7",
   "metadata": {},
   "source": [
    "Para instanciar un objeto de nuestra nueva clase, haríamos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0aec8492",
   "metadata": {},
   "outputs": [],
   "source": [
    "val john = Persona(\"John\", \"Doe\")\n",
    "john.nombreCompleto"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "22da4087",
   "metadata": {},
   "source": [
    "La constante anterior referencia a un nuevo objeto de tipo **```Persona```** que se habrá creado en el **_heap_** (región de la memoria de la que el sistema puede disponer de forma dinámica para crear las nuevas instancias de los objetos). Así, en el momento de crear el nuevo objeto, se solicita un bloque de memoria del _heap_ para alojarlo, almacenando la dirección de memoria de dicho bloque (referencia) en la constante (o variable).\n",
    "\n",
    "<br>A través de nuestra variable o constante de tipo referencia, podremos acceder a las propiedades o métodos del objeto utilizando el operador punto (**.**)\n",
    "\n",
    "<br>De forma similar a Java, Python y otros lenguajes, la eliminación de los objetos creados dinámicamente en el _heap_, se realiza de forma dinámica por un proceso separado e independiente (_garbage collector_) sin intervención del usuario"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6d7f3de6",
   "metadata": {},
   "source": [
    "### Identidad de Objetos"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7a099e9a",
   "metadata": {},
   "source": [
    "Kotlin introduce el operador **===** para comprobar si dos variables referencia el mismo objeto"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2d8caebc",
   "metadata": {},
   "outputs": [],
   "source": [
    "val fran = Persona(\"Frank\", \"Zappa\")\n",
    "val paco = fran\n",
    "val fuco = Persona(\"Frank\", \"Zappa\")\n",
    "\n",
    "println(fran == paco)\n",
    "println(fran === paco)\n",
    "\n",
    "println(fran == fuco)\n",
    "println(fran === fuco)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7f8555e0",
   "metadata": {},
   "source": [
    "Como veremos más adelante al introducir las **data classes**, esto nos será de gran utilidad. En ese caso, el operador **===** comprobará las referencias de los objetos mientras que el operdaor **==** comprobará el contenido"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "57fcb2ca",
   "metadata": {},
   "source": [
    "## 2. Métodos\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b5e77252",
   "metadata": {},
   "source": [
    "Consideremos las siguientes clases **Nota** y **Estudiante**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a7c26872",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Nota(val letra: String, val puntos: Double, val creditos: Double)\n",
    "\n",
    "class Estudiante(\n",
    "        val nombre: String,\n",
    "        val apellidos: String,\n",
    "        val notas: MutableList<Nota> = mutableListOf(),\n",
    "        var creditos: Double = 0.0) {\n",
    "    \n",
    "    fun nuevaNota(nota: Nota) {\n",
    "        notas += nota \n",
    "        creditos += nota.creditos\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c6988cb7",
   "metadata": {},
   "source": [
    "Vamos a crear ahora un alumno y añadirle algunas notas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "477a440e",
   "metadata": {},
   "outputs": [],
   "source": [
    "val bob = Estudiante(nombre = \"Bob\", apellidos = \"Esponja\")\n",
    "val historia = Nota(letra = \"B\", puntos = 9.0, creditos = 3.0)\n",
    "val mate = Nota(\"A\", 16.0, 4.0)\n",
    "\n",
    "bob.nuevaNota(historia)\n",
    "bob.nuevaNota(mate)\n",
    "\n",
    "println(\"Crédito acumulados de ${bob.nombre}: ${bob.creditos}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b3dce56a",
   "metadata": {},
   "source": [
    "Fíjate como, a pesar de haber declarado **```bob```** como una constante, podemos modificar su contenido (de forma similar a lo que nos pasaba con las colecciones). El hecho de que la definamos como constante simplemente va a impedir que reasignemos su valor a un nuevo objeto de tipo **```Estudiante```**, pero no que accedamos (modifiquemos) el objeto al que referencia\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ca641110",
   "metadata": {},
   "source": [
    "## 3. Clases de Datos (_Data classes_)\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5efe74a3",
   "metadata": {},
   "source": [
    "Las **clases-valor** o **clases de datos** son clases cuya finalidad principal es almacenar datos (definir un estado) y no tanto realizar operaciones. Por ejemplo, una clase Libro que represente los diferentes ejemplares disponibles en una biblioteca.\n",
    "\n",
    "<br>Los objetos de estas clases los consideramos **iguales** si sus atributos contienen los mismos valores (con independencia de que sean objetos independientes y, por tanto, con referencias diferentes). Por tanto, cuando en lenguajes como Java queremos definir una clase de este tipo, estamos obligados a sobreescribir los métodos **```equals()```** y **```hashCode()```** de forma que las comparaciones de tales objetos se realicen de forma correcta.\n",
    "\n",
    "<br>Este tipo de clases son tan comunes que Kotlin nos proporciona un nuevo tipo de clase, las **_data classes_**, que nos evita todo ese código repetitivo.\n",
    "\n",
    "<br>Para crear una clase de datos, lo único que tenemos que hacer es añadir la palabra reservada **```data```** a la declaración de nuestra clase"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2ab19c89",
   "metadata": {},
   "outputs": [],
   "source": [
    "data class Persona(var nombre: String, var apellidos: String) {\n",
    "    val nombreCompleto\n",
    "        get() = nombre + \" \" + apellidos\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "488ef65f",
   "metadata": {},
   "source": [
    "Volviendo a nuestro ejemplo anterior..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ea4e9c92",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "val fran = Persona(\"Frank\", \"Zappa\")\n",
    "val paco = fran\n",
    "val fuco = Persona(\"Frank\", \"Zappa\")\n",
    "\n",
    "println(fran == paco)\n",
    "println(fran === paco)\n",
    "\n",
    "println(fran == fuco)\n",
    "println(fran === fuco)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1ec20aad",
   "metadata": {},
   "source": [
    "Vemos como ahora, al comparar las constantes ```fran``` y ```fuco```con el operador **==**, devuelve **```true```** aunque están referenciado a objetos distintos en memoria (por eso la comprobación con **===** es **```false```**). Al ser objetos de una _data class_, el operador == compara los distintos atributos de los objetos y no sus referencias."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e1d62c70",
   "metadata": {},
   "source": [
    "### Desestructurando clases de datos"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dc730ed5",
   "metadata": {},
   "source": [
    "Kotlin nos permite desestructurar un objeto de una clase de datos en sus atributos, mapeando de forma fácil y efectiva su estado en un conjunto de variables (o constantes). Esto es útil para devolver múltiples valores desde una función, recorrer las entradas de un mapa,..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6f700061",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "val (nom, apel) = fran\n",
    "println(nom)\n",
    "println(apel)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dcf08ca8",
   "metadata": {},
   "source": [
    "## 4. Ejercicios\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ad0b9bfa",
   "metadata": {},
   "source": [
    "1. \n",
    "Supón que estás creando una aplicación de visualización de películas donde los usuarios pueden crear listas de películas y compartirlas con otros ususarios.\n",
    "\n",
    "<br>Crea las clases **```User```** y **```MovieList```** para gestionar los usuarios y sus listas.\n",
    "\n",
    "<br>\n",
    "\n",
    "- **```MovieList```**: tiene un parámetro **```nombre```** y una lista variable de películas. Dispondrá de un método **```print()```** que imprimirá dicha lista\n",
    "\n",
    "- **```User```**: tiene un método **```addList()```** que añade la lista a una mapa de objetos **```MovieList```** usando el **nombre** del **```MovieList```** como clave. Un segundo método **```list(): MovieList?```** devolverá el **```MovieList```** del nombre indicado\n",
    "\n",
    "<br>Crea los usuarios **jane** y  **john** y añade el código necesario para que creen y compartan listas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "79b6b9f2",
   "metadata": {},
   "outputs": [],
   "source": [
    "// SOLUCIÓN\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e85bafaf",
   "metadata": {},
   "source": [
    "2. \n",
    "Necesitamos definir una serie de clases para dar soporte a una tienda on-line de camisetas. Decide si cada una de ellas debe ser una clase o una clase de datos\n",
    "\n",
    "<br>\n",
    "\n",
    "- **```TShirt```**: representa un tipo de camiseta que se puede comprar. Cada camiseta tiene una talla, color, precio y, opcionalmente, una imagen en la parte frontal\n",
    "- **```User```**: usuario registrado de la tienda on-line. Tiene un nombre, e-mail y un carrito (```ShoppingCart```)\n",
    "- **```Address```**: representa direcciones de envío. Incluye un nombre (\"casa\", \"trabajo\",...), calle, ciudad y código postal\n",
    "- **```ShoppingCart```**: carrito u orden de compra, formado por una lista de camisetas que el usuario quiere comprar. Tiene asociada una dirección de envío y un método que permite calcular el costo total"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "54b25bce",
   "metadata": {},
   "outputs": [],
   "source": [
    "// SOLUCIÓN\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9e650e3b",
   "metadata": {},
   "source": [
    "### Soluciones\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dac1965a",
   "metadata": {},
   "source": [
    "##### 1.\n",
    "```kotlin\n",
    "class MovieList(\n",
    "        val name: String,\n",
    "        val list: MutableList<String> = mutableListOf() ) \n",
    "{\n",
    "    fun print() { println(list) }\n",
    "}\n",
    "\n",
    "class User(\n",
    "        val name: String,\n",
    "        val lists: MutableMap<String, MovieList> = mutableMapOf() ) \n",
    "{\n",
    "    fun addList(movieList: MovieList) { lists[movieList.name] = movieList }\n",
    "    fun list(name: String) = lists[name]\n",
    "} \n",
    "\n",
    "// Creamos los ususarios\n",
    "val jane = User(\"Jane\")\n",
    "val john = User(\"John\")\n",
    "\n",
    "// Creamos listas de películas\n",
    "val johnAnime = MovieList(\"John Anime\", mutableListOf(\"Akira\", \"Ghost in the shell\", \"Cowboy Bebop\", \"Samurai Champloo\"))\n",
    "val johnSciFi = MovieList(\"John Sci-Fi\", mutableListOf(\"2001: A Space Odyssey\", \"Blade Runner\", \"Moon\"))\n",
    "\n",
    "// Añadimos las listas a John\n",
    "john.addList(johnAnime)\n",
    "john.addList(johnSciFi)\n",
    "\n",
    "// Imprimimos una de las listas\n",
    "john.list(\"John Anime\")!!.print()\n",
    "\n",
    "// Añadimos una de las listas a Jane\n",
    "jane.addList(johnSciFi)\n",
    "jane.list(\"John Sci-Fi\")!!.print()\n",
    "\n",
    "// Modificamos una de las listas\n",
    "johnSciFi.list += \"Alien\"\n",
    "jane.list(\"John Sci-Fi\")!!.print()\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "36033241",
   "metadata": {},
   "source": [
    "##### 2.\n",
    "```kotlin\n",
    "data class TShirt(val size: String, val color: String, val price: Double, val image: Boolean = false)\n",
    "data class Address(val name: String, val street: String, val city: String, val zip: String)\n",
    "data class User(val name: String, var email:String, var cart: ShoppingCart = ShoppingCart())\n",
    "class ShoppingCart(var address: Address? = null, val tshirts: MutableList<TShirt> = mutableListOf()) {\n",
    "    fun total() = tshirts.fold(0.0) { a, b -> a + b.price }\n",
    "}\n",
    "\n",
    "// Creamos unas camisetas\n",
    "val tshrt1 = TShirt(size = \"M\", color = \"Black\", price = 19.90)\n",
    "val tshrt2 = TShirt(size = \"M\", color = \"White\", price = 22.90, image = true)\n",
    "val tshrt3 = TShirt(size = \"L\", color = \"Black\", price = 19.90)\n",
    "val tshrt4 = TShirt(size = \"XL\", color = \"Red\", price = 22.90, image = true)\n",
    "\n",
    "// Creamos un usuario\n",
    "val user = User(name = \"Joe\", email = \"joe@gmail.com\")\n",
    "\n",
    "// Mostramos el carrito\n",
    "println(\"Carrito de ${user.name}:\\nDirección: ${user.cart.address}\\nCamisetas: ${user.cart.tshirts}\\nTotal: ${user.cart.total()}\")\n",
    "\n",
    "// Añadimos unas cuantas camisetas \n",
    "user.cart.tshirts += tshrt1\n",
    "user.cart.tshirts += tshrt2\n",
    "user.cart.tshirts += tshrt3\n",
    "user.cart.tshirts += tshrt3\n",
    "\n",
    "// Añadimos una dirección\n",
    "user.cart.address = Address(name = \"home\", street = \"Huhu St. 3\", city = \"NY\", zip = \"11201\")\n",
    "\n",
    "// Mostramos el carrito\n",
    "println(\"\\nCarrito de ${user.name}:\\nDirección: ${user.cart.address}\\nCamisetas: ${user.cart.tshirts}\\nTotal: ${user.cart.total()}\")\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
}