Diferencias

Muestra las diferencias entre dos versiones de la página.

--- apuntes:herramientas [12/02/2019 00:00] – [Librerías de clases] Fernando Valdeón
+++ apuntes:herramientas [16/09/2024 19:32] (actual) – editor externo 127.0.0.1
@@ Línea 1: / Línea 1: @@
+====== Herramientas de Desarrollo ======
+===== Entornos de Desarrollo Integrados (IDE) =====
+Un entorno de desarrollo integrado es una aplicación software que ayuda en la tarea de desarrollo de software integrando una serie de herramientas {{ :apuntes:iderank.png?300|}} enfocadas en dicho fin. La cantidad de herramientas incluidas es configurable dependiendo de las características de las aplicaciones que se quieran crear.
+==== Componentes de un IDE ====
+Por lo general los entornos de desarrollo actuales ofrecen:
+  * **Editor de texto**: facilita la escritura organizando las instrucciones atendiendo a un formato, colores, permite la escritura automática, autocompletar, además de las clásicas funciones de buscar, reemplazar cortar, pegar, etc.
+  * **Compilador/Interprete**: normalemente los IDEs incluyen herramientas de compilación y ejecución propias, sin tener necesidad de un jdk.
+  * **Depurador**: Herramienta que permite la ejecución de una aplicacion instrucción a instrucción, y nos ayuda a examinar las distintas situaciones y cambios que se produzcan en las variables del programa.
+  * **Asistente para GUI**: (GUI - Interfaz gráfica de usuario). Normalmente es una paleta de componentes que me permite arrastrar y soltar (drag and drop) componentes gráficos a un panel que corresponde a la ventana que vamos a crear.
+  * **Control de versiones**: permite almacenar cambios en nuestro código y compartirlo con otros desarrolladores.
+  * **Exportar programas**: permitirá exportar nuestra aplicación completa en algún formato de fichero.
+==== Frameworks ====
+Una aplicación informática requiere que su información esté estructurada de un modo que entienda para poder gestionarla.
+Cuando los desarrolladores queremos crear una aplicación usamos y generamos distinto tipo de información: código fuente, ficheros de configuración, ficheros binarios de datos, librerías, ficheros ejecutables, etc. A veces nos centramos únicamente en el tipo de tecnología que vamos a usar pero nos despreocupamos a la hora de crear infinidad de propios recursos, de ficheros y de código fuente para crear nuestra aplicación pero sin ningún orden u organización.
+Un **framework** es un esquema (una estructura, un patrón) para el desarrollo de una aplicación. Se puede entender como una estructura conceptual y tecnológica que nos ayuda a través de un conjunto de herramientas, librerías, módulos, para crear aplicaciones de un tipo concreto. No están ligados a un lenguaje concreto, pero cuando más detallado es el //framework//, más necesidad tendrá de vincularse a un lenguaje concreto.
+Puede ser algo muy sencillo como el patrón MVC, que indica que separemos las clases de nuestro programa en las capas de presentación (vista), los datos(modelo) y las operaciones (controlador). Pero tambien tenemos otros //frameworks// que llegan a definir los nombres de los ficheros, su estructura, las convenciones de programación, etc. También es posible que el framework defina una estructura para una aplicación completa, o bien sólo se centre en un aspecto de ella.
+{{ :apuntes:webframeworks.png?200|}}
+Ejemplos de frameworks:
+  * JUnit es un //framework// para el desarrollo de pruebas unitarias de software. Está formado por una serie de librerias.
+  * Java Server Pages es un //framework// para crear aplicaciones web con Java, principalmente la interfaz de usuario.
+  * Xamarin es un //framework// para crear aplicaciones móviles para Android, IOS en el lenguaje C#.
+  * Hibernate es un //framework// para Java para facilitar el trabajo con bases de datos relacionales desde la programación orientada a objetos.
+  * .NET es un //framework// con soporte para múltiples lenguajes de programación y está enfocado en la creación de aplicaciones para cualquier sistema Windows.
+===== Sistemas de Control de Versiones =====
+El control de versiones es un sistema que registra los cambios realizados sobre un archivo o conjunto de archivos a lo largo del tiempo, de modo que puedas recuperar versiones específicas más adelante.
+Se usan para registrar cualquier tipo de archivos, y comparar cambios a lo largo del tiempo, revertir a un estado anterior del proyecto, ver en qué momento se introdujo un error, etc.
+Tenemos dos arquitecturas principales a través de la que podemos clasificar distintos SCVs:
+**Arquitectura Centralizada**
+{{ :apuntes:centralizedvcs.png?200|}}
+Los desarrolladores usan un repositorio central al que acceden mediante un cliente en su máquina. Tienen un único servidor que contiene todos los archivos versionados, y varios clientes que descargan los archivos desde ese lugar central. Durante muchos años éste ha sido el estándar para el control de versiones.
+La desventaja más obvia es el servidor centralizado como único punto de fallo. Si ese servidor se cae o pierde los datos, se pierde el trabajo.
+  * Subversion SVN (Código Abierto)
+  * Visual SourceSafe (Propietario)
+** Arquitectura Distribuida**
+{{ :apuntes:distributedvcs.png?200|}}
+En un SCV distribuido los clientes no sólo descargan la última instantánea de los archivos: suben completamente el repositorio. Cada vez que se descarga una instantánea (versión del proyecto), en realidad se hace una copia de seguridad completa de todos los datos. Así, si un servidor muere, cualquiera de los repositorios de los clientes puede copiarse en el servidor para restaurarlo.
+  * GIT (Codigo Abierto)
+  * Mercurial (Codigo Abierto)
+===== GIT =====
+Es un SCV distribuido creado como necesidad durante el desarrollo de núcleo de Linux. El creador es Linus Torvalds, creador también del núcleo de Linux.
+==== Servidores de Repositorios ====
+Para almacenar las versiones de nuestro código necesitamos un servidor de control de versiones basado en Git. Actualmente hay distintas opciones que ofrecen servicios comerciales y también servicios gratuitos, con algunas limitaciones, pero perfectamente válidos para trabajar en nuestros pequeños proyectos. Las versiones gratuitas de los siguientes servicios ofrecen:
+  * [[https://github.com/|GitHub]]: repositorios públicos ilimitados.
+  * [[https://bitbucket.org|BitBucket]]: repositorios públicos y privados ilimitados.
+  * [[https://about.gitlab.com|GitLab]]: repositorios públicos y privados ilimitados.
+En nuestro caso usamos //BitBucket// porque permite la creación de repositorios privados, además de públicos como GitHub. Todos los servicios funcionan de forma similar y nos permite crear una cuenta de usuario gratuita.
+==== Funcionamiento de Git====
+Git guarda una copia completa del estado de los ficheros de nuestro proyecto en cada versión (//commit//). Esta información se almacena en la base de datos local (repositorio local), y posteriormente se puede sincronizar con otros repositorios remotos.
+{{ :apuntes:git-lifecycle.png?600 |}}
+En Git, los ficheros tienen 2 estados principales:
+  - Ficheros fuera de seguimiento (//untracked//)
+  - Ficheros bajo seguimiento (//tracked//)
+  * **Ficheros Untracked**. Cuando creo o añado ficheros nuevos a mi repositorio local estos están fuera de seguimiento.  También están fuera de seguimiento los que no estaban bajo seguimiento en la última versión; último //commit// (confirmación).
+Los ficheros que están bajo seguimiento pueden tener 3 estados (unmodified, staged, modified)
+  * **Ficheros Staged (Preparados para confirmación) **: Cuando añado ficheros //untracked// mediante el comando (git add) para que formen parte de la siguiente confirmación, estos pasan a estar pendientes de confirmación, preparados,  (staged). Estos cambios no estarán confirmados hasta que haga //commit//.
+  * **Ficheros unmodified (Sin modificar)**: Justo despues de hacer un //**commit**// (crear una versión), todos los ficheros que estaban pendientes de confirmación (staged), se almacenan en la base de datos local de Git. En ese momento todos los ficheros están sin ninguna modificación, que quiere decir que no hay modificaciones desde la última versión.
+  * **Ficheros modified (Modificados)**: Si modifico un fichero //unmodified//, este pasará a estado //**modified**// indicando que debo de volver a añadirlo (git add) parar prepararlo (staged) para la siguiente confirmación (commit).
+Todo este trabajo se realiza en el repositorio local y se almacena en la base de datos local de Git. Independientemente de esto, puedo sincronizar el estado de mi repositorio local (directorio en mi equipo), con un repositorio remoto (fuera de mi equipo).
+==== Instalación y configuración de Git====
+Al configurar GIT por **primera vez**, como mínimo debemos configurar nuestra identidad para realizar //commits// (Confirmar una version). Esto se debe hacer una sola vez, después de instalar Git. Para ello abrimos un terminal //Bash// y ejecutamos:
+<code bash>
+git config --global user.name "Fernando Valdeon"
+git config --global user.email fvaldeon@email.com
+git config --list  #Nos permite ver todas las propiedades de configuracion de Git.
+</code>
+Si no indico la opción //- - global// la configuración es solo para el repositorio local (Debo haber creado primero el repositorio local)
+En el siguiente video-tutorial podemos ver como instalar y configurar GIT.
+{{ youtube>IcHAKwakopQ?small }}
+==== Manejo de Git ====
+Para entender completamente el funcionamiento de Git debemos leer los capitulos 2 y 3 del libro Pro Git Book. Podemos descargarlo desde su web oficial en inglés o leerlo online en [[https://git-scm.com/book/es/v2|español]].
+En los siguientes dos videos se muestra el uso de las principales operaciones que nos ofrece Git junto con el servidor de repositorio BitBucket.
+**IMPORTANTE**: Al crear un repositorio remoto en bitbucket, indicar no crear el fichero README.md.
+{{vimeo>242144259?small }}
+{{ vimeo>242142587?small }}
+Git ofrece tanto integración en un terminal de Windows (cmd), como en un terminal de Linux (Bash). Los siguientes comandos están centrados en el manejo del __terminal de Linux__ (bash):
+^ Comandos Bash ^ Función ^
+| ls | Muestra el contenido del directorio actual |
+| ls -a| Muestra el contenido del directorio actual con los fichero ocultos|
+| pwd | Muestra la ruta del directorio en el que estoy|
+| cd [directorio]| Me permita cambiar de directorio |
+|directorios . y ..| Representan el directorio actual y su padre, respectivamente|
+| rm [nombre_archivo]| Elimina un archivo|
+|rm -r [nombre directorio]|Elimina un directorio con su contenido|
+|touch [nombre_fichero] | Crea un fichero de texto plano con dicho nombre]|
+|mkdir [nombre_directorio] | Crea un directorio vacío con dicho nombre]|
+|clear | Limpia el terminal de comandos |
+=== Trabajo en repositorio local ===
+  * Crear un repositorio local. Se ejecuta solo una vez, y con ello indico que en dicho directorio se llevará un control de versiones (se convierte en repositorio). Para ello crea un directorio oculto (.git) que contiene la información que Git necesita para registrar las versiones.
+<code bash>
+git init
+</code>
+  * Estado actual del repositorio. Indica los cambios que ha habido en el directorio (repositorio) desde la última versión realizada. Muestra los nuevos ficheros añadidos al repositorio o fuera de seguimiento, los modificados y los eliminados, desde el último //comit//.
+<code bash>
+git status
+</code>
+  * Incluir archivos o directorios para la siguiente versión. Permite añadir archivos que están fuera de seguimiento (untracked) o que han sido modificados (modified) y prepararlos para el siguiente commit.
+<code bash>
+git add [nombre_fichero_o_directorio]
+# Ó si quiero añadir todo el contenido de mi repositorio local:
+git add .
+</code>
+Mientras que no se confirmen (commit) las modificaciones, se puede restaurar el estado inicial con el comando //git reset//.
+  * Confirmar las modificaciones. Crea una nueva versión Con los archivos que están bajo seguimiento dentro de mi repositorio. Debemos indicar siempre un mensaje descriptivo.
+<code bash>
+git commit -m "Descripción del commit"
+</code>
+=== Sincronización repositorio local - remoto ===
+  * Sincronizar con un repositorio remoto. Añade las modificaciones que hay en mi repositorio local a un repositorio remoto, con el fin de tener los dos repositorios sincronizados (identicos). Debemos indicar la dirección de nuestro repositorio remoto (url) o su alias, si le hemos asignado uno.
+<code bash>
+git push [dirección_repositorio_remoto] master
+#Ejemplo
+git push https://bitbucket.org/fvaldeon/repopruebadam1 master
+</code>
+  * Actualizar nuestro repositorio local con los cambios mas recientes que tiene uno remoto. Cuando nuestro repositorio remoto está más actualizado que nuestro mismo repositorio local, debido a que hemos sincronizado desde un repositorio local en otro equipo, debemos descargar los último cambios para incluirlos en nuestro repositorio local.
+<code bash>
+git pull [repositorio_remoto] master
+#Ejemplo
+git pull https://bitbucket.org/fvaldeon/repopruebadam1 master
+</code>
+Cuando hacemos //git pull// se descargan esos nuevos ficheros y se intentan unir con los ficheros de nuestro repositorio local. Desde el terminal de Git se abre el editor de texto de linux (Vi). Para salir de él pulsamos las teclas (:wq!).
+  * Obtener una copia de mi repositorio remoto. Usaré este comando cuando en mi ordenador no tengo una copia de mi repositorio. Uso la url de mi repositorio remoto para traerme una copia en local, y poder seguir trabajando. Esto genera un repositorio local idéntico al remoto.
+<code bash>
+git clone [repositorio_remoto]
+#Ejemplo
+git clone https://bitbucket.org/fvaldeon/repopruebadam1
+</code>
+Una vez que hayamos clonado un repositorio desde una url, dicha url se almacena como el alias ''**origin**''. Desde ese momento puedo omitir la url, y usar el alias ''origin'' para hacer //push o pull//.
+=== Gestión de repositorios remotos ===
+Dentro de cada repositorio local de Git, puedo asociar la dirección de mi repositorio remoto a un alias. Así no necesito recordar la url, sino el alias.
+  * Añadir un repositorio remoto la gestión de Git de mi respositorio local.
+<code bash>
+git remote add [alias] [dirección_remoto]
+</code>
+  * Como norma general en Git, el repositorio remoto con el que tengo pensado trabajar principalmente se llama //**origin**//:
+<code bash>
+git remote add origin [dirección_remoto]
+</code>
+  * Mostrar los repositorios remotos vinculados a mi repositorio local.
+<code bash>
+git remote
+</code>
+  * Además puedo mostrar mis repositorios remotos y mostrar su dirección.
+<code bash>
+git remote -v
+</code>
+=== Obtener versiones anteriores ===
+Cuando queremos obtener una versión anterior de nuestro proyecto podemos consultar el log de nuestro repositorio local. Cada confirmación (commit) crea una versión. Al restaurar a una versión anterior, el estado (ficheros y directorios) de mi repositorio local se cambia por lo que había en el momento de crear dicha versión.
+<code bash>
+git log #Muestra un historial con las versiones
+git log --oneline #Muestra un historial resumido
+</code>
+Obtenemos la siguiente salida, que representa todos los //commits// realizados en mi repositorio local y el mensaje que se incluyó.
+<code bash>
+git log --oneline
+b8b6a2d (HEAD -> master, origin/master, origin/HEAD) Readme y gitignore actualizados
+e8ad0df LoginYFichConf y JListSuprimir subidos
+a46d10 Actualizado README
+d909 Proyecto VehiculosMVC terminado
+ffa9848 Correccion en la organizacion de packages
+dee7c5 Proyecto terminado. No guarda ni carga en fichero.
+</code>
+Si nos fijamos en el código generado en cada confirmación (columna de la izquierda), podemos emplearlos para restaurar una versión anterior:
+<code bash>
+git checkout 3dee7c5
+</code>
+También podemos restaurar únicamente un archivo a una versión anterior:
+<code bash>
+git checkout 3dee7c5 prueba.txt
+</code>
+=== Ignorar archivos en las versiones ===
+Es bastante frecuente que en los proyectos que tengo en mi repositorio local tengo archivos o directorios que no quiero tener en seguimiento(versiones). Es el caso del directorio ///bin// o de los ficheros //.class// de Java.
+El fichero //.gitignore// es un fichero de texto que podemos crear en nuestro repositorio local y que indica qué ficheros se excluirán del seguimiento y sincronización con nuestro repositorio remoto.
+<file bash .gitignore>
+# Ficheros generados Java
+*.class
+# Carpetas que contienen ficheros generados
+bin/
+out/
+</file>
+El fichero //**.gitignore**// debería ser sincronizado con el resto de ficheros del repositorio remoto.
+=== Borrar archivos de las versiones ===
+  * Borrar archivos ya confirmados. Si tengo actualmente ficheros en mis versiones que no quiero que sigan en mi proyecto, debo borrarlos de **git** y posteriormente volver a confirmar. Debo tener en cuenta que dichos archivos también desaparecerán de mi repositorio local.
+<code bash>
+git rm [fichero]
+git rm -r [directorio con archivos]
+git commit -m "Archivos borrados"
+</code>
+  * Eliminar archivos de la versión. Se usa cuando lo que quiero es únicamente eliminar algunos archivos de las versiones de git, pero quiero que permanezcan en mi repositorio local. Es normalmente útil cuando se me olvida incluir algo en mi fichero //.gitignore//
+<code bash>
+git rm -r --cached [fichero o directorio]
+</code>
+=== Trabajar con ramas ===
+  * Crear una nueva rama
+<code bash>
+git branch develop
+</code>
+  * Cambiar de rama
+<code bash>
+git checkout develop
+</code>
+  * Fusionar ramas
+<code bash>
+git checkout master
+git merge develop
+</code>
+Con el siguiente tutorial interactivo podemos practicas todos los conceptos visto aquí y también el manejo con ramas: https://learngitbranching.js.org/
+===== Visual Studio IDE=====
+{{ :apuntes:visuallogo.jpg?70|}}
+Es un IDE creado por Microsoft y usado en plataformas Windows. Tiene licencia propietaria y soporta distintos lenguajes como C#, C++, Visual Basic .NET, Python, etc. Este IDE está preparado para trabajar con todas las tecnologías y lenguajes de la plataforma .NET de Microsoft.
+ ==== Plataforma .NET ====
+{{ :apuntes:cliclr.png?300|}}
+.NET es un framework creado por Microsoft principalmente para sistemas Windows. De forma parecida a la //plataforma Java//, .NET ofrece librerias de clases  y un entorno de ejecución para diferentes lenguajes. A esta plataforma se le conoce como //CLI// [[https://en.wikipedia.org/wiki/Common_Language_Infrastructure|(Common Language Infraestructure)]]. Esta formada de 2 partes:
+  * Todos los programas escritos en el //framework// .NET se compilan a un lenguaje intermedio conocido como //CIL// [[https://en.wikipedia.org/wiki/Common_Intermediate_Language|(Common Intermediate Language)]]
+  * Posteriormente se ejecutan en un entorno de ejecución llamado //CLR// [[https://en.wikipedia.org/wiki/Common_Language_Runtime|(Common Language Runtime)]], parecido a la máquina virtual de Java.
+Esto hace que las aplicaciones .NET puedan ser independientes de la máquina, a través de un enfoque similar al que usa Java.
+ ==== Lenguaje C# ====
+Es un lenguaje de programación de propósito general, orientado a objetos y multiparadigma. Aunque ha sido muy desarrollado por Microsoft para su plataforma .NET, empleado como un Lenguaje de Infraestructura Común (CLI), C# es un lenguaje independiente que trabaja para otras plataformas.
+La sintaxis del lenguaje __C# está basada en la sintaxis de C/C++__, de la misma forma que Java, por lo que la mayor parte de sus instrucciones se escriben y organizan de la misma forma. .NET tambien actua como API para el lenguaje C#.
+Podemos acceder a la documentación de la [[https://msdn.microsoft.com/es-es/library/mt472912(v=vs.110).aspx|biblioteca de clases de .NET]]
+Programa ''Hola Mundo'' en lenguaje C#:
+<code c#>
+class Saludo {
+  static void Main() {
+    System.Console.WriteLine("Hola Mundo!");
+    System.Console.WriteLine("Pulsa una tecla para terminar");
+    System.Console.ReadKey();
+  }
+}
+</code>
+Las instrucciones principales que necesitaremos para crear programas de consola son:
+  * Mostrar mensajes por consola
+<code c#>
+System.Console.Write("Mensaje"); //Escribe por consola, sin salto de linea
+System.Console.WriteLine("Mensaje"); //Escribe por consola, con salto de linea
+</code>
+  * Leer texto por consola
+En C# se leen los datos siempre como String y posteriormente se convierten al tipo necesario. **C# no permite leer int directamente.**
+<code c#>
+System.Console.ReadLine(); //Lee la siguiente linea (String)
+System.Console.ReadKey(); //Lee una tecla pulsada en código unicode.
+</code>
+  * Convertir de String a otro tipo y viceversa
+<code c#>
+int numero = int.Parse("-466");  //Convierto de String a int
+double numeroReal = double.Parse("32.345"); //Convierto de String a double
+String cadena1 = numero.ToString(); //Convierto de int a String
+String cadena2 = numeroReal.ToString(); //Convierto de int a String
+</code>
+  * Espacio de nombres y sentencia //using//
+Las clases en C# se organizan en espacios de nombres (namespaces). Un conjunto de clases que tengan relacion entre si, se agruparán bajo un mismo espacio de nombres. LA idea es similar a los paquetes (packages) en Java.
+Ejemplos de espacios de nombres:
+     * System -> contiene clases como Console, String, y otros tipos de datos muy comunes.
+     * System.IO -> Contiene clases para entreda y salida, manejo de ficheros, etc.
+     * System.Windows.Forms -> Contiene clases para crear interfaces gráficas de usuarios.
+<code c#>
+namespace Aplicacion  //espacio de nombres 'Aplicacion'
+{
+    public class MiClase{   //Puedo acceder a esta clase indicando 'Aplicacion.miClase'
+    }
+}
+</code>
+Por otra parte podemos usar la sentencia //using// al comienzo de una clase para indicar a nuestro compilador los espacios de nombres de las clases que vamos a usar (p.e. clase Console).
+De esta forma podemos acceder a los métodos de la clase //Console// directamente sin necesidad de indicar el espacio de nombres (System):
+<code c#>
+using System;    //espacios de nombres que estoy usando
+using System.IO;
+namespace Aplicacion.parte1 //espacio de nombres de 'miClase'
+{
+    public class miClase{
+       static void main(string[] args)
+       {
+          Console.WriteLine("No necesito escribir System para usar la clase Console");
+          Console.WriteLine("Pulse una tecla para terminar...");
+          Console.ReadKey();
+       }
+    }
+}
+</code>
+=== Crear una aplicación de Consola ===
+Debemos crear un proyecto en C# seleccionando //Aplicación de Consola (.Net Framework)//. Para desarrollar en lenguaje C# necesitamos añadir el componente **Desarrollo de escritorio .NET**.
+{{ :apuntes:aplicacionconsolavs.png?500 |}}
+ ==== Depurador ====
+Para utilizar la herramienta de depuración debo crear antes algún //breakpoint// pulsando doble clic sobre la barra vertical a la izquierda del número de linea. La perspectiva del modo depuración se iniciará en el momento en que mi programa alcance algún breakpoint. {{ :apuntes:vsdebuggercontrols.png?300|}}
+Para iniciar el modo depuración debo ir al menú //Depurar// y pulsar sobre //Iniciar Depuración// o también pusando la tecla F5.
+^Comando ^ Atajo de Teclado^ Descripcion ^
+|**Paso a paso por instrucciones**|**F11**|Si la línea contiene una llamada a un método, entra en el método y se detiene en la primera línea de código incluida en él.|
+|**Paso a paso por procedimientos**|**F10**|Si la línea contiene la llamada a un método, no entra en el método y continua en la siguiente isntrucción.|
+|**Paso a paso pasa salir**|**Shift+F11**|Si estamos depurando un método, sale del método y continua en la siguiente instrucción.|
+ ==== Añadir componentes ====
+Puedo acceder a la herramienta para incorporar extensiones o módulos, desde el menú //Herramientas// con las opciones //Obtener herramientas y características// o con //Extensiones y actualizaciones//.
+  * Obtener herramientas y características
+{{:apuntes:vsherramientas-caracteristicas.png?500|}}
+  * Extensiones y actualizaciones
+{{:apuntes:vsextensiones.png?500|}}
+ ==== Interfaz gráfica de usuario ====
+Lo primero que necesitamos es añadir el componente de "Desarrollo de Escritorio .NET" desde la seccion de componentes y extensiones.
+Para crear una aplicación que ofrezca una interfaz gráfica debemos crear un proyecto de **Aplicacion Windows Forms**.
+{{ :apuntes:windowformsvs.png?500 |}}
+Esto nos creará una clase en C# vinculada a un formulario que nos permite diseñar una ventana. Nos ofrece una paleta con componentes gráficos que podemos arrastrar a un formulario para diseñar nuestra interfaz de usuario (//GUI//).
+{{ :apuntes:vsdesigner.png?700 |}}
+{{ vimeo>247501705?medium }}
+ ==== Librerías de clases ====
+En la plataforma .NET uno de los tipos de ficheros que contienen librerías de clases se conocen como **ficheros .dll** (librerías de enlace dinámico). Para poder crear un proyecto de librerías de clases debo seleccionar un proyecto de Librerías de Clases.
+{{ :apuntes:libreriasdll.png?400|}}
+Después en él crearemos las clases que necesitemos con los métodos que queramos. Y finalmente compilaremos la solución. De este modo en el diretorio //**bin/Debug**// de la carpeta del proyecto tendré el fichero //.dll// con las librerías que he creado.
+Para incluirlas en otro proyecto, en el //Explorador de Soluciones// debo pulsar con el botón derecho sobre el proyecto en el que las quiero incluir. Despues **Agregar -> Referencia** y ahí buscaré el //.dll// dentro de mi equipo y lo incorporaré al proyecto.
+**Todas las clases y los métodos definidos en una librería deben ser públicos (public) si quiero tener acceso a ellos.**
+===== Eclipse ====
+{{ :apuntes:eclipse256.png?70|}}
+Es un entorno de desarrollo integrado de código abierto desarrollado en el lenguaje Java. Ofrece soporte para múltiples lenguajes.
+{{ vimeo>879053209? }}
+==== Workspace / Proyecto ====
+  * Un **workspace** es un tipo de directorio que usa Eclise para almacenar proyectos. __Un workspace no es un proyecto__. Podemos organizar los distintos proyectos en diferentes workspaces. Para cambiar de workspace ire a la pestaña **File -> Switch workspace**. Por defecto, Eclipse abre el último workspace utilizado.
+Es importante entender que todos los proyectos que tengo en un workspace no tienen porqué aparecer en el //Explorador de Paquetes// de Eclipse. Pueden estar en el workspace y no haberlos abierto o importado en Eclipse.
+  * Un **proyecto** es un directorio que contiene subdirectorios para organizar todos los elementos de un programa. Principalmente tenemos la carpeta **src** donde guardamos los ficheros fuente .java, la carpeta **bin** donde se guardan los ficheros .class generados de la compilación de los fuentes. Para abrir un proyecto puedo hacerlo desde la pestaña **File -> Open Projects...** o tambien desde **File -> import -> General -> Existing Projects into workspace**.
+Es importante entender que para abrir un proyecto no es necesario tenerlo en ningún workspace. Puede estar en cualquier lugar de nuestro sistema, y ahí seguirá. Sin embargo es útil almacenarlo en algún workspace.
+ ==== Plantillas (Templates) ====
+Las plantillas son un tipo de herramientas mediante las cuales se puede autogenerar (autocompletar) código a partir de una palabra. Se despliegan en un menu al pulsar la combinación de teclas //ctrl + barra espaciadora//.
+<code java>
+syso -> System.out.println()
+</code>
+Para ver las plantillas que tenemos predefinidas para un lenguaje iremos a Window -> Preferences.
+Ahí accederemos al lenguaje del cual queramos mostrar las plantillas o gestionarlas.
+Para Java: Java -> Editor -> Templates
+{{ :apuntes:eclipsetemplates.png?500 |}}
+Desde la opción //**New**// podremos crear nuestra propia plantilla. Esta se compone de:
+  * Nombre: nombre que aparecerá en mi editor cuando la invoque
+  * Descripción: Para qué se usa
+  * Contexto: Podemos indicar el lenguaje para el que se usa
+  * Patrón: código de la plantilla. Puedo además usar variables de Eclipse
+Podemos consultar algunos aspectos de la creación de plantillas desde la documentacion de eclipse, en concreto sobre las [[https://help.eclipse.org/oxygen/index.jsp?topic=%2Forg.eclipse.jdt.doc.user%2Fconcepts%2Fconcept-template-variables.htm&cp=1_2_6_0|variables]] que podemos usar al crear plantillas.
+Ejemplo de plantilla para Scanner:
+==== Depurador ===
+Para establecer un punto de ruptura en mi código (breakpoint) tan solo debo hacer doble clic en mi editor de código de Eclipse, en la pequeña columna vertical que tenemos a la izquierda del número de linea. Cuando creamos un breakpoint queda marcado un pequeño punto azul. Se eliminan de la misma forma.
+Para acceder al modo depuración: Menu //Run// -> //Debug//, o mediante la tecla //F11//. Mi programa se ejecutará hasta que encuentre un //breakpoint//, momento en el que parará.
+{{ :apuntes:debugging_buttons.png?150|}}
+  * El primer botón (F8), botón "play", hace que continúe la ejecución de nuestro programa hasta el siguiente Breakpoint.
+  * El siguiente botón, parecido al botón de pausa, suspende la ejecución del programa que está corriendo. Es una forma de parar "al vuelo" el programa, esté donde esté en ese momento, haya o no breakpoint.
+  * El cuadrado rojo es el botón de stop, aborta la ejecución de nuestro programa.
+**Botones de avance paso a paso:**
+  * El siguiente botón (F5), una flecha amarilla que se "mete" entre dos puntos, hace que el debugger vaya a la siguiente instrucción y si encuentra un método, se meterá dentro del método y se parará en la primera línea del mismo, de forma que podemos depurar dentro del método.
+  * El siguiente botón (F6), una flecha amarilla que salta sobre un punto negro, avanza un paso la ejecución del programa, y si se encuentra un método no entra dentro de él, sino que salta a la siguiente instrucción.
+  * El último botón (F7) es una flecha saliendo de entre dos puntos negros, cuando nos encontramos dentro de un método, salta hasta la instrucción en la que ha sido llamado el método.
+Además podemos ver el valor que devuelve una instrucción, seleccionado la expresión (método) y ejecutando el atajo del teclado **Ctrl + Shift + i**.
+Por ejemplo, si no se qué puede devolver la instrucción //cadena.charAt(i)//, selecciono dicha instrucción y pulso ctrl+shift+i.
+{{ vimeo>243640684?medium }}
+=== Depurar en las clases internas de Java ===
+Una posibilidad muy interesante del depurador es Eclipse, es poder acceder a los métodos de las clases nativas de Java. Cuando depuramos nuestro código fuente podremos ver el avance de la ejecución de nuestro programa, pero no podremos ver el avance dentro de los métodos de las clases propias de Java (Clase String, Scanner, etc)
+Para que nuestro IDE tenga acceso al código fuente de estas clases necesito indicarle dónde está mi paquete JDK de Java:
+**Window -> Preferences -> Java -> Installed JREs**
+Por defecto tendré el paquete **JRE** (Java runtime Environment) en lugar del paquete de desarrollo **JDK**.
+Debo seleccionar el paquete JRE y pulsar sobre //Remove// para eliminarlo. A continuación añadiré el JDK, tal y como se muestra en la siguiente imagen:
+{{ :apuntes:debugger-with-jdk.png?500 |}}
+Una vez que accedo a la ventana //JRE Definition//, debo buscar la carpeta de mi JDK de Java en mi equipo y seleccionarla. Normalmente estará en C:/Archivos de Programa/Java/Jdk... Acepto los cambios y podré depurar con esta funcionalidad.
+ ==== Añadir componentes ====
+{{ :apuntes:marketplace.png?170|}}
+Desde la pestaña //Help// en Eclipse podemos incorporar elementos a nuestro IDE. Podemos descargarlo desde un servidor repositorio externo desde la opción //Install New Software// o a través del //Eclipse MarketPlace//. Desde este último simplemente tenemos que buscar las etensiones que queremos incluir y pulsar sobre el botón instalar.
+ ==== Interfaz gráfica de usuario ====
+El plugin WindowBuilder nos permite crear ventanas a través de editores de ventanas //drag and drop//. Desde el menu //Nuevo// puedo seleccionar otros tipos de aplicaciones, -> WindowBuilder -> SwingDesigner -> Jframe, por ejemplo. Esto crea una nueva perspectiva en la que puedo diseñar una ventana con un editor, y ver al mismo tiempo como se crea el código Java referente a mi ventana.
+{{ vimeo>246942867?medium }}
+ ==== Librerías de clases ====
+===Ficheros JAR ===
+Jar son las siglas de **J**ava **AR**chive, y es un tipo de fichero en el que podemos empaquetar clases de Java. Son archivos comprimidos en formato **.zip** y cambiada su extensión a //.jar//. En el directorio //bin// del JDK de Java tenemos el programa //jar// para crear estos ficheros, aunque también podemos crearlos desde el IDE con el que trabajemos.
+En Java el fichero estandar para empaquetar librerías de clases es el fichero //**Jar**//. Podemos crear nuestras propias clases con métodos para usarlas en otro proyecto, empaquetándolas en un fichero jar. Así no tenemos que llevar nuestras carpetas y archivos sueltos de un lugar a otro.
+Dentro de un fichero JAR podemos empaquetar todos los recursos que tiene nuestro proyecto: ficheros .class, otras librerías, imágenes, y todo lo que esté en los directorios de nuestro proyecto.
+===Fichero Jar con Clases (Librería de clases)===
+//Todas las clases y los métodos que guardemos en una librería deben ser definidos como públicos **(public)**//
+{{:apuntes:exportjar.png?100 |}}
+Para guardar en un fichero //jar// las clases que necesitamos usar en otros proyectos, debemos seleccionarlas para empaquetarlas.
+En Eclipse desde la pestaña //File//, seleccionaremos la opción //Export//.
+Una vez en esta nueva ventana abriremos la sección //Java//, y pulsarmos sobre //JAR File//.
+Después de pulsar sobre //JAR file//, se abrirá otra ventana en la que podemos seleccionar las clases que queremos guardar en nuestro JAR. Podemos seleccionar clases de distintos proyectos que queramos usar en otro.
+{{:apuntes:exportdialog.png?300 |}}
+{{ :apuntes:jardialog.png?300|}}
+----
+Finalmente seleccionaremos un destino para almacenar nuestro archivo JAR. Podemos usar una carpeta nueva (libs, por ejemplo) en el workspace para almacenarlos.
+**Añadir librerias JAR a otros proyectos **: Para incluir ficheros JAR con clases y poderlas usar en otros proyectos debemos incluirlas en el PATH del proyecto:
+  - Creamos un directorio en nuestro proyecto: por ejemplo //libs//
+  - Añadimos a dicho directorio nuestra libreria //.jar// (Copiamos el fichero Jar de la ubicación y lo pegamos en ese directorio)
+  - Pulsamos con el botón derecho sobre nuestro proyecto en el explorador de paquetes, y seleccionamos //Build Path -> Configure Build Path//
+  - En la nueva ventana iremos a la pestaña //Libraries// -> //Add Jars…// y seleccionaremos la librería Jar.
+{{ :apuntes:add-library.png?400 |}}
+Ahora podemos usar las clases que tenemos en el paquete JAR.
+===== Generación de Ejecutables =====
+==== Ficheros Exe ====
+Desde **Visual Studio** a través de la //Infraestructura de Lenguaje Común// los ejecutables que obtenemos después de construir el proyecto tiene extensión //.exe// y permiten ser ejecutados en cualquier máquina que tenga el framework .NET instalado.
+Los podemos encontrar en la carpeta ''bin'' dentro del directorio del proyecto de Visual Studio.
+==== Ficheros Jar Ejecutables====
+Son contenedores de clases, en los que a la hora de crearlos, indicamos la clase que contiene el método //main//
+En Eclipse: **File → Export → Java -> Runnable JAR File**
+{{ :apuntes:runnablejar.png?200|}}
+  * ** Fichero Jar Ejecutable con programa consola**: Si lo que quiero es obtener mi programa ejecutable en un fichero JAR, debo crear un //Runnable JAR file//, indicando el proyecto y su clase principal (clase con método Main). Guardaremos el fichero Jar en nuestro PC.
+Posteriormente para ejecutar ese programa JAR arrancaré el terminal de Windows (cmd), iré al directorio donde lo tengo almacenado y ejecutaré: // java -jar  archivoJar.jar // (donde //archivoJar.jar// es mi archivo). También puedo ejecutarlo desde cualquier lugar, dando la ruta de mi fichero jar.
+  * ** Fichero Jar Ejecutable con Interfaz gráfica **: Para guardar mi aplicación con interfaz de usuario en un JAR ejecutable, después de pulsar sobre exportar para crear un fichero JAR, debo indicarle que el tipo de JAR será //Runnable JAR file//. Este tipo de ejecutables, pueden lanzarse directamente, sin un terminal de comandos.
+==== Exe Java con JSmooth====
+Cuando tenemos un programa en Java, podemos crear un ejecutable (Exe) en consola a partir de él. Tan solo necesitaremos haber exportado nuestro programa como un archivo Jar.
+**JSmooth** es un programa muy sencillo de usar y con poca configuración, aunque __solo está disponible para Windows__. Actualmente el proyecto ya no tiene continuidad pero el programa sigue funcionando, es gratuito, y descargable desde su [[http://jsmooth.sourceforge.net/|página web]].
+//**Problema al iniciar JSmooth - JSmooth no reconoce Java**//: Al instalar Java hay algunas variables de entorno que no se crean de forma adecuada. Para usar JSmooth necesitamos crear una nueva __variable de sistema__ llamada //JAVA_HOME// (Equipo -> Propiedades -> Configuración Avanzada -> Opciones Avanzadas -> Variables de entorno) y darle el valor de la ruta del JDK que estamos utilizando (p.e. ->  C:\Program Files\Java\jdk1.X.X.X).
+  * **Sección Skeleton**: Aquí indicamos simplemente de qué tipo de aplicación se trata, si de consola (Console Wrapper) o de Ventana (Windowed Wrapper). En esta sección configuramos qué mensaje aparecerá en caso de que el usuario no tenga instalada la máquina virtual de Java. La opción **presskey** es útil en aplicaciones de consola, para que no se cierre la ventana del terminal automáticamente.
+{{ :apuntes:jsmooth3.png?400 |}}
+  * **Sección Executable**: Aquí indicaremos simplemente el nombre y el lugar donde creamos el fichero ejecutable (Executable Binary). También podemos seleccionar una imagen, para el icono de nuestro ejecutable. Debe ser una imagen (p.e. PNG) pequeña, 120x120 o similar. En "Current Directory" indicamos simplemente el directorio por defecto que usará la aplicación cuando la ejecutemos. Podemos marcar el Checkbox ya que en principio no nos importa demasiado.
+{{ :apuntes:jsmooth4.png?400 |}}
+  * **Sección Application**:  En esta sección debemos indicar dónde está nuestro archivo Jar en nuestro ordenador (Embbeded Jar Settings) marcando el checkbox. Después en "Application Settings" pulsaremos sobre Main Class para indicarle cuál es la clase de nuestro JAR que contiene el método //**main**//, desde la que se iniciará el programa. Y está!!
+{{ :apuntes:jsmooth5.png?400 |}}
+  * **Crear nuestro ejecutable**: Pulsaremos sobre la pestaña "Project" y después sobre "Compile". Nos pedirá de nuevo una ruta y un nombre para guardar un archivo de proyecto de JSmooth (no es el exe). También nos creará un fichero .exe en la ruta que le indicamos anteriormente. Ya podemos ejecutar nuestro programa.
+Además también podemos configurar nuestra aplicación a partir de estas secciones:
+  * **Sección JVM Selection**: Podemos indicarle la versión de Java mínima que necesitamos para ejecutar la aplicación. Esto se debe a que hay instrucciones de Java que han salido en una versión concreta. En principio no necesitamos indicar nada, a no ser que sepamos que nuestro programa no funciona en todas las versiones de Java. (Por ejemplo, Scanner está en java desde 1.5v, o “Java 5”). Actualmente usamos Java 8 (1.8v)
+{{ :apuntes:jsmooth6.png?400 |}}
+  * **Sección JVM Configuration**: Aquí podemos indicar la cantidad de memoria que usará nuestra aplicación de Java o la versión mínima que necesitamos.
+==== Exe Java con Launch4J====
+**Launch4J** es un programa similar a JSmooth, aunque permite más detalle en la configuración. El proyecto de desarrollo de Launch4J sigue en activo y es mutiplataforma (Linux, Windows, Mac). Lo podemos descargar desde su [[http://launch4j.sourceforge.net| página web]].
+Para crear un .exe a partir de un JAR con Launch4J necesito indicar algunos parámetros en las siguientes secciones de la aplicación:
+  * **Sección Basic**: Debemos indicar el nombre y la ruta del fichero .exe que vamos a crear en el campo //OutPut File//. También indicaremos donde se encuentra el fichero Jar que vamos a utilizar para crear el exe, en el campo //Jar//. Si queremos que la aplicación tenga un icono lo indicaremos en el campo //Icon//.
+{{ :apuntes:launch4j.png?300 |}}
+  * **Sección Header**: Debemos indicar si la aplicación es de Ventana o de Consola:
+{{ :apuntes:launch4j-2.png?300 |}}
+  * **Sección JRE**: Debemos indicar al menos una versión mínima de Java necesaria para ejecutar el fichero. También podemos configurar los parámetros de Java con lo que quiero ejecutar mi aplicación.
+{{ :apuntes:launch4j-3.png?300 |}}
+{{ :apuntes:launch4j-4.png?150|}}
+  * **Crear el ejecutable .exe**: Una vez configuradas al menos las partes anteriores, pulsamos sobre el botón del engranaje en la barra de herramientas. Nos preguntará donde queremos guardar el archivo del proyecto de Launch4J (es distinto al fichero .exe que queremos generar)
+Además también podemos configurar los siguientes aspectos de la aplicación:
+  * **Splash**: puedo indicar una imagen de inicio antes de arrancar la aplicación.
+  * **Version Info**: información sobre el fichero ejecutable.
+  * **Messages**: Configuro los mensajes que mostraría mi ejecutable ante posibles errores.
+{{ vimeo>905546679? }}
+----
+===== Prácticas =====
+    - Control de versiones, interfaces gráficas de usuario y librerías
+----
+(c) {{date> %Y}} Fernando Valdeón