PrimerosPasosConJava.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"images/logo_ua.jpg\" width=\"100\" style=\"float:left\">\n",
    "<img src=\"images/logo_dlsi.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Primero pasos con Java"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"images/java.png\" width=\"100\" style=\"float:left\"> Este tutorial se puede utilizar para comenzar a trabajar con Java como lenguaje de programación. Veremos una pequeña introducción y cada uno de los puntos más relevantes para empezar a programar con Java."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introducción"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Java es un lenguaje de programación más populares y nació en el año 1995 con Sun Microsystem y posteriormente fue adquirido por Oracle Corporation. Para su ejecución requiere de la máquina virtual que es independiente del sistema donde se esté ejecutando.\n",
    "\n",
    "Java requiere el JDK (Java Development Kit, en español Herramientas de desarrollo para Java) instalado para poder desarrollar aplicaciones en Java. El JDK es el conjunto de librerías, paquetes, clases, métodos, etc. que incluye javac para convertir el código fuente (.java) en bytecode (.class) que será interpretado y ejecutado por la JVM (Java Virtual Machine, en español Máquina Virtual de Java). También incluye javadoc para generar la documentación de nuestro código.\n",
    "\n",
    "El JDK incluye además el JRE (Java Runtime Environment, en español Entorno de Ejecución de Java), que realmente ejecuta los programas de Java. Es posible instalar el JRE por separado, pero el JDK lo incluye."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Comentarios en Java\n",
    "Los comentarios sirven para documentar nuestro código. Java nos permite crear comentarios de una única línea y de varias."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "// Esto es un comentario de una linea\n",
    "\n",
    "/* Esto es \n",
    "   un comentario\n",
    "   de varias líneas\n",
    "*/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Programa en Java básico\n",
    "La estructura básica de un programa desarrollado usando Java es la siguiente. En el ejemplo podemos observar como se crea una clase pública, es decir, que tendrás acceso a esta clase desde cualquier parte del código. El método main es un método que permite la ejecución del programa."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "public class NombreClase {\n",
    "     public static void main (String args[]){\n",
    "        // instrucciones\n",
    "     }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Objetos y clases\n",
    "La base de la Programación Orientada a Objetos es el objeto que a su vez tiene una serie de características y comportamiento. Una clase representa el conjunto de objetos que comparten características y comportamiento. \n",
    "En Java, las clases contienen atributos y métodos. Para cada atributo se crea un método get y set para poder gestionarlos. Además, cada clase cuentra con uno o varios constructores mediante los cuales podemos crear instancias de las clases. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Clases en Java\n",
    "Una clase en Java comienza con la palabra reservada class y a continuación los atributos y métodos. La definición de una clase sigue la siguiente estructura:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```java\n",
    "class <clase>  {\n",
    "   //declaración de atributos\n",
    "  [visibilidad] [modificadores] <tipo> <atributo> [= valor];\n",
    "  ...\n",
    "\n",
    "  //declaración de constructor\n",
    "  public <clase>(<argumentos>) {\n",
    "    <instrucciones>;\n",
    "  }\n",
    "\n",
    "  //declaración de métodos\n",
    "  [visibilidad] [modificadores] <tipo> <método>(<argumentos>) {\n",
    "    <instrucciones>;\n",
    "  }\n",
    "  ...\n",
    "}```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El siguiente ejemplo muestra una clase para describir libros."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "//Ejemplo de clase para almacenar libros\n",
    "public class Libro\n",
    "{\n",
    "    //Atributos de la clase\n",
    "    protected int identificador;\n",
    "    protected String autor;\n",
    "    protected String titulo;\n",
    "\n",
    "    //Constructor con el mismo nombre de la clase\n",
    "    public Libro(){}\n",
    "    \n",
    "    //Constructor con parametros\n",
    "    public Libro(String ptitulo, String pautor){\n",
    "        this.titulo = ptitulo;\n",
    "        this.autor = pautor;\n",
    "    }\n",
    "    \n",
    "    public void setAutor(String pautor)\n",
    "    {\n",
    "        this.autor = pautor;\n",
    "    }\n",
    "    \n",
    "    public void setTitulo(String ptitulo)\n",
    "    {\n",
    "        this.titulo = ptitulo;\n",
    "    }\n",
    "\n",
    "    public String getAutor()\n",
    "    {\n",
    "        return autor;\n",
    "    }\n",
    "\n",
    "    public String getTitulo()\n",
    "    {\n",
    "        return titulo;\n",
    "    }\n",
    "    \n",
    "    public static String metodoEstatico(){\n",
    "        return \"No necesito una instancia para ejecutarme\";\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Una vez tenemos declarada la clase, podemos instanciar objetos llamando al constructor con la instrucción new:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "// declaramos los objetos\n",
    "Libro libro1 = new Libro(\"Don Quijote de la Mancha\", \"Miguel de Cervantes Saavedra\");\n",
    "Libro libro2 = new Libro(\"La Galatea\", \"Miguel de Cervantes Saavedra\");\n",
    "Libro libro3 = new Libro(\"El rufián dichoso\", \"Miguel de Cervantes Saavedra\");\n",
    "Libro libro4 = new Libro(\"El laberinto del amor\", \"Miguel de Cervantes Saavedra\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Y podemos llamar a los métodos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Don Quijote de la Mancha - Miguel de Cervantes Saavedra\n",
      "La Galatea - Miguel de Cervantes Saavedra\n"
     ]
    }
   ],
   "source": [
    "// recuperamos los atributos de los libros y los mostramos por pantalla\n",
    "System.out.println(libro1.getTitulo() + \" - \" + libro1.getAutor());\n",
    "System.out.println(libro2.getTitulo() + \" - \" + libro2.getAutor());"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Los métodos pueden ser declarados como estáticos lo que significa que no requiere de una instancia para poder ejecutarse"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No necesito una instancia para ejecutarme\n"
     ]
    }
   ],
   "source": [
    "System.out.println(Libro.metodoEstatico());"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En el siguiente ejemplo vemos un programa completo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "public class MiPrograma\n",
    "{\n",
    "    public static void main(String[] args)\n",
    "    {\n",
    "        //Creamos un animal cuyo nombré será Falco\n",
    "        Libro miLibro = new Libro(\"El viejo celoso\", \"Miguel de Cervantes\");\n",
    "        \n",
    "        //Mostraremos el titulo del libro por pantalla\n",
    "        System.out.println(\"El titulo es: \" + miLibro.getTitulo());\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Salida de datos\n",
    "Aunque Java proporciona numerosas librerías para guardar los logs en ficheros, la forma más sencilla es mostrarlo por pantalla la información."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World\n"
     ]
    }
   ],
   "source": [
    "System.out.println(\"Hello World\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Paquetes\n",
    "Los paquetes en Java nos permiten agrupar los componentes de nuestra aplicación que estén relacionados entre si. El paquete se declara antes de cualquier otra cosa, es decir, es la primera línea de nuestro código en una clase, por ejemplo. A continuación, añadiremos los imports, clases, etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "//package ejemplo.de.paquete;\n",
    "\n",
    "//public class mi_clase\n",
    "//{\n",
    "\n",
    "//}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Modificadores de acceso\n",
    "Los modificadores de acceso public, protected, default y private en Java nos proporcionan el encapsulamiento en Java que tiene como objetivo gestionar el acceso a los datos de una instancia. El modificador por defecto es default y permite el acceso a la clase como a las clases del mismo paquete. Si un atributo es privado, debemos crear los métodos set y get para poder manipular sus valores."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "public class Revista\n",
    "{\n",
    "    private int numeroArticulos; //Este atributo es privado\n",
    "    private String titulo; //Contador de registro\n",
    "\n",
    "    public void setNumeroArticulos(int n)\n",
    "    {\n",
    "        numeroArticulos = n;//Establecemos el valor del atributo\n",
    "    }\n",
    "\n",
    "    public int getNumeroArticulos()\n",
    "    {\n",
    "        return numeroArticulos;//Retornamos el valor actual del atributo\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variables y tipos de datos \n",
    "Una variable tiene un tipo específico y alberga un valor que puede ser inicializado y modificado durante la ejecución del programa en Java. En Java todas las variables tendrán un tipo de dato y un nombre de identificador."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "int a, b, c; \n",
    "float pi; \n",
    "double d; \n",
    "char a;\n",
    "String cadena = \"Hola\";"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "En Java podemos tener variables estáticas que indica que solo se va a crear una vez aunque tengamos muchas instancias de esa clase."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Número de puertas:4\n"
     ]
    }
   ],
   "source": [
    "class Coche {\n",
    "    public final static int numeroPuertas = 4;\n",
    "}\n",
    "\n",
    "System.out.println(\"Número de puertas:\" + Coche.numeroPuertas);\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Condicionales\n",
    "En Java el operador condicional AND (todas las expresiones evaluadas igual true) es && y el OR (alguna de las expresiones igual a true) operador es ||. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Las dos variables mantienen sus valores iniciales\n",
      "Al menos una variable mantiene su valor inicial\n"
     ]
    }
   ],
   "source": [
    "int vble1 = 10;\n",
    "int vble2 = 20;\n",
    "\n",
    "if ((vble1 == 10) && (vble2 == 20))\n",
    "  System.out.println(\"Las dos variables mantienen sus valores iniciales\");\n",
    "\n",
    "if ((vble1 == 10) || (vble2 ==20))\n",
    "  System.out.println(\"Al menos una variable mantiene su valor inicial\");\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Operador instanceof\n",
    "El operador instanceof es un operador especial para los objetos mediante el cual podemos comprobar si un objeto es de una clase concreta."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Libro\n"
     ]
    }
   ],
   "source": [
    "if (libro1 instanceof Libro)\n",
    "  System.out.println(\"Libro\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sentencias de decisión\n",
    "Son sentencias que permiten tomar una decisión para ejecutar un bloque de instrucciones u otro. Las sentencias de decisión corresponden a: if-then-else y switch."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "El objeto es de tipo Libro\n"
     ]
    }
   ],
   "source": [
    "if (libro1 instanceof Libro) {\n",
    "  System.out.println(\"El objeto es de tipo Libro\");\n",
    "} else {\n",
    "  System.out.println(\"El objeto no es de tipo Libro\");\n",
    "}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Bucles\n",
    "Las sentencias de bucle permiten ejecutar un bloque de sentencias tantas veces como queramos hasta que se cumpla una condición."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "contador:0\n",
      "contador:1\n",
      "contador:2\n",
      "contador:3\n",
      "contador:4\n"
     ]
    }
   ],
   "source": [
    "int contador = 0;\n",
    "while (contador<5) {\n",
    "  System.out.println(\"contador:\" + contador);\n",
    "  contador++;\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "contador:0\n",
      "contador:1\n",
      "contador:2\n",
      "contador:3\n",
      "contador:4\n"
     ]
    }
   ],
   "source": [
    "for(contador=0;contador<5;contador++){\n",
    "  System.out.println(\"contador:\" + contador);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Funciones\n",
    "Java permite la definición de funciones para evitar el código duplicado. Java permite de forma sencilla llamar a las funciones, pasando los parámetros correspondientes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "contador:0\n",
      "contador:1\n",
      "contador:2\n",
      "contador:3\n",
      "contador:4\n"
     ]
    }
   ],
   "source": [
    "void muestraContador(int max){\n",
    "  int i;\n",
    "  for(i=0;i<max;i++){\n",
    "    System.out.println(\"contador:\" + i);\n",
    "  }\n",
    "}\n",
    "\n",
    "muestraContador(5);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Arrays en Java\n",
    "Un array Java es una estructura de datos que permite almacenar un conjunto de datos de un mismo tipo. Es necesario declarar El tamaño de los arrays, no pudiendo cambiar en tiempo de ejecución."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accedemos al primer elemento:a\n"
     ]
    }
   ],
   "source": [
    "// Tenemos un array de 5 elementos.\n",
    "char lista[] = {'a','b','c','d','e'};\n",
    "System.out.println(\"Accedemos al primer elemento:\" + lista[0]);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Java también permite instanciar arrays de dos dimensiones"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30\n",
      "0,0:1\n",
      "0,1:2\n",
      "0,2:3\n",
      "1,0:30\n",
      "1,1:20\n",
      "1,2:10\n"
     ]
    }
   ],
   "source": [
    "int matriz[][] = {{1,2,3},{30,20,10}};\n",
    "System.out.println(matriz[1][0]); //Java empieza a contar objetos desde la posicion 0, fila 1, columna 0\n",
    "\n",
    "for(int x = 0; x < matriz.length; x++) { \n",
    "    for (int y = 0; y < matriz[x].length; y++) { \n",
    "        System.out.println(x + \",\" + y + \":\" + matriz[x][y]); \n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Java permite la creación de listas de objetos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Don Quijote de la Mancha\n",
      "La Galatea\n",
      "El rufián dichoso\n",
      "El laberinto del amor\n"
     ]
    }
   ],
   "source": [
    "List<Libro> lista = new ArrayList<Libro>();\n",
    "lista.add(libro1);\n",
    "lista.add(libro2);\n",
    "lista.add(libro3);\n",
    "lista.add(libro4);\n",
    "\n",
    "for (int i = 0; i < lista.size(); i++) {\n",
    "    System.out.println(lista.get(i).getTitulo());\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Herencia\n",
    "Java permite definir que una clase herede de otra, compartiendo atributos y métodos. Entre las diferentes ventajas de la herencia se encuentra la reutilización del código así como facilitar el mantenimiento del código. La palabra clave en Java para definir la herencia es extends."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Periodico extends Libro{\n",
    "    private String fecha;\n",
    "    \n",
    "    public String getFecha(){\n",
    "        return fecha;\n",
    "    }\n",
    "    \n",
    "    public void setFecha(String pfecha){\n",
    "        this.fecha = pfecha;\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La clase anterior hereda de la clase Libro, que tiene definidos los atributos como protected y por tanto podemos acceder desde nuestra clase Periodico."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "Periodico periodico = new Periodico();\n",
    "periodico.setFecha(\"2020\");\n",
    "periodico.setTitulo(\"Investigaciones geograficas\");\n",
    "periodico.setAutor(\"Universidad de Alicante\");"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Investigaciones geograficas\n"
     ]
    }
   ],
   "source": [
    "System.out.println(periodico.getTitulo());"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Gestión de excepciones\n",
    "Cuando ejecutamos código Java se pueden generar excepciones ya sea por el código o el uso incorrecto de tipos, en la ejecución que debemos tener en cuenta. Cuando se produce un error Java finaliza la ejecución y genera un mensaje de error, que en Java se conoce como excepción.\n",
    "La instrucción **try** permite definir un bloque de instrucciones.\n",
    "La instrucción **catch** permite recoger cada una de las excepciones que se pueden producir y tratarlas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "try {\n",
    "  //  Block of code to try\n",
    "}\n",
    "catch(Exception e) {\n",
    "  //  Block of code to handle errors\n",
    "}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Ficheros en Java\n",
    "Java permite la lectura y escritura de ficheros. Java puede lanzar excepciones que debemos capturar mediante try-catch \n",
    "La siguiente función permite leer un fichero de texto y muestra su contenido."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "import java.io.*;\n",
    "\n",
    "public void leeFichero(String nombreFichero) {\n",
    "    try {\n",
    "        File myObj = new File(nombreFichero);\n",
    "        Scanner myReader = new Scanner(myObj);\n",
    "        while (myReader.hasNextLine()) {\n",
    "            String data = myReader.nextLine();\n",
    "            System.out.println(data);\n",
    "        }\n",
    "        myReader.close();\n",
    "    } catch (FileNotFoundException e) {\n",
    "        System.out.println(\"Ha ocurrido un error.\");\n",
    "        e.printStackTrace();\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "En un lugar de la Mancha, de cuyo nombre no quiero acordarme, no ha mucho tiempo que vivía un hidalgo de los de lanza en astillero, adarga antigua, rocín flaco y galgo corredor. Una olla de algo más vaca que carnero, salpicón las más noches, duelos y quebrantos los sábados, lantejas los viernes, algún palomino de añadidura los domingos, consumían las tres partes de su hacienda. El resto della concluían sayo de velarte, calzas de velludo para las fiestas, con sus pantuflos de lo mesmo, y los días de entresemana se honraba con su vellorí de lo más fino. Tenía en su casa una ama que pasaba de los cuarenta, y una sobrina que no llegaba a los veinte, y un mozo de campo y plaza, que así ensillaba el rocín como tomaba la podadera. Frisaba la edad de nuestro hidalgo con los cincuenta años; era de complexión recia, seco de carnes, enjuto de rostro, gran madrugador y amigo de la caza. Quieren decir que tenía el sobrenombre de Quijada, o Quesada, que en esto hay alguna diferencia en los autores que deste caso escriben; aunque por conjeturas verosímiles se deja entender que se llamaba Quijana. Pero esto importa poco a nuestro cuento: basta que en la narración dél no se salga un punto de la verdad.\n"
     ]
    }
   ],
   "source": [
    "leeFichero(\"fichero-ejemplo.txt\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Java también permite la escritura de ficheros con el método **createNewFile()** que devuelve **True** si puede realizar la operación y **False** en caso contrario."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "File created: filename.txt\n"
     ]
    }
   ],
   "source": [
    "try {\n",
    "    File myObj = new File(\"filename.txt\");\n",
    "    if (myObj.createNewFile()) {\n",
    "        System.out.println(\"Fichero creado: \" + myObj.getName());\n",
    "    } else {\n",
    "        System.out.println(\"El fichero ya existe.\");\n",
    "    }\n",
    "} catch (IOException e) {\n",
    "    System.out.println(\"Ha ocurrido un error.\");\n",
    "    e.printStackTrace();\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para escribir en el fichero debemos usar la clase **FileWriter()** y el método **write()**. Al finalizar debemos llamar a **close()**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "La escritura ha sido correcta.\n"
     ]
    }
   ],
   "source": [
    "try {\n",
    "    FileWriter myWriter = new FileWriter(\"filename.txt\");\n",
    "    myWriter.write(\"Escribo mi primera línea en un fichero.\");\n",
    "    myWriter.close();\n",
    "    System.out.println(\"La escritura ha sido correcta.\");\n",
    "} catch (IOException e) {\n",
    "    System.out.println(\"Ha ocurrido un error.\");\n",
    "    e.printStackTrace();\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Escribo mi primera línea en un fichero.\n"
     ]
    }
   ],
   "source": [
    "leeFichero(\"filename.txt\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Crear ficheros XML"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "import java.io.File;\n",
    "import javax.xml.parsers.DocumentBuilder;\n",
    "import javax.xml.parsers.DocumentBuilderFactory;\n",
    "import javax.xml.parsers.ParserConfigurationException;\n",
    "import javax.xml.transform.Transformer;\n",
    "import javax.xml.transform.TransformerException;\n",
    "import javax.xml.transform.TransformerFactory;\n",
    "import javax.xml.transform.dom.DOMSource;\n",
    "import javax.xml.transform.stream.StreamResult;\n",
    "import org.w3c.dom.Attr;\n",
    "import org.w3c.dom.Document;\n",
    "import org.w3c.dom.Element;\n",
    "\n",
    "try {\n",
    "      DocumentBuilderFactory docFactory = DocumentBuilderFactory.newInstance();\n",
    "      DocumentBuilder docBuilder = docFactory.newDocumentBuilder();\n",
    "      \n",
    "      //Elemento raíz\n",
    "      Document doc = docBuilder.newDocument();\n",
    "      Element rootElement = doc.createElement(\"coleccion\");\n",
    "      doc.appendChild(rootElement);\n",
    "      \n",
    "      //Primer elemento\n",
    "      Element elemento1 = doc.createElement(\"obra1\");\n",
    "      elemento1.setTextContent(\"Contenido de la obra 1\");\n",
    "      rootElement.appendChild(elemento1);\n",
    "      \n",
    "      //Se agrega un atributo al nodo elemento y su valor\n",
    "      Attr attr = doc.createAttribute(\"id\");\n",
    "      attr.setValue(\"10\");\n",
    "      \n",
    "      elemento1.setAttributeNode(attr);\n",
    "      \n",
    "      Element elemento2 = doc.createElement(\"obra2\");\n",
    "      elemento2.setTextContent(\"Contenido de la obra 2\");\n",
    "      rootElement.appendChild(elemento2);\n",
    "      \n",
    "      //Se escribe el contenido del XML en un archivo\n",
    "      TransformerFactory transformerFactory = TransformerFactory.newInstance();\n",
    "      Transformer transformer = transformerFactory.newTransformer();\n",
    "      DOMSource source = new DOMSource(doc);\n",
    "      StreamResult result = new StreamResult(new File(\"ejemplo.xml\"));\n",
    "      transformer.transform(source, result);\n",
    "} catch (ParserConfigurationException pce) {\n",
    "    pce.printStackTrace();\n",
    "} catch (TransformerException tfe) {\n",
    "    tfe.printStackTrace();\n",
    "}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?><coleccion><obra1 id=\"10\">Contenido de la obra 1</obra1><obra2>Contenido de la obra 2</obra2></coleccion>\n"
     ]
    }
   ],
   "source": [
    "leeFichero(\"ejemplo.xml\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Crear ficheros JSON\n",
    "Para trabajar con ficheros JSON necesitamos utilizar una librería externa. Existen muchas librerías y en este ejemplo vamos a utilizar **json-simple**. Si usamos maven, deberemos configurar el fichero *pom.xml* para usar esta librería. En jupyter notebooks se simula de la siguiente forma."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%loadFromPOM\n",
    "<dependency>\n",
    "    <groupId>com.googlecode.json-simple</groupId>\n",
    "    <artifactId>json-simple</artifactId>\n",
    "    <version>1.1.1</version>\n",
    "</dependency>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "ename": "IncompleteSourceException",
     "evalue": "Una vez que tenemos disponible nuestra librería JSON, ya podemos empezar a trabajar con ella.",
     "output_type": "error",
     "traceback": [
      "\u001b[1m\u001b[31mIncomplete input:\u001b[0m",
      "\u001b[1m\u001b[30m|   \u001b[1m\u001b[30mUna vez que tenemos disponible nuestra librería JSON, ya podemos empezar a trabajar con ella.\u001b[0m"
     ]
    }
   ],
   "source": [
    "Una vez que tenemos disponible nuestra librería JSON, ya podemos empezar a trabajar con ella."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\"Categoria\":\"Colecciones digitales\",\"Inicio\":2015,\"Blog\":\"http:\\/\\/data.cervantesvirtual.com\",\"Tags\":[\"Linked Open Data\",\"Jupyter notebooks\",\"Colecciones digitales\"]}"
     ]
    }
   ],
   "source": [
    "import java.io.FileWriter;\n",
    "import java.io.IOException;\n",
    "import org.json.simple.JSONArray;\n",
    "import org.json.simple.JSONObject;\n",
    "\n",
    "JSONObject obj = new JSONObject();\n",
    "obj.put(\"Blog\", \"http://data.cervantesvirtual.com\");\n",
    "obj.put(\"Categoria\", \"Colecciones digitales\");\n",
    "obj.put(\"Inicio\", new Integer(2015));\n",
    "\n",
    "JSONArray list = new JSONArray();\n",
    "list.add(\"Linked Open Data\");\n",
    "list.add(\"Jupyter notebooks\");\n",
    "list.add(\"Colecciones digitales\");\n",
    "\n",
    "obj.put(\"Tags\", list);\n",
    "\n",
    "try {\n",
    "\n",
    "    FileWriter file = new FileWriter(\"ejemplo.json\");\n",
    "    file.write(obj.toJSONString());\n",
    "    file.flush();\n",
    "    file.close();\n",
    "\n",
    "} catch (IOException e) {\n",
    "    //manejar error\n",
    "}\n",
    "\n",
    "System.out.print(obj);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Información adicional\n",
    "https://www.w3schools.com/java/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Java",
   "language": "java",
   "name": "java"
  },
  "language_info": {
   "codemirror_mode": "java",
   "file_extension": ".jshell",
   "mimetype": "text/x-java-source",
   "name": "Java",
   "pygments_lexer": "java",
   "version": "15-ea+16-681"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}