MPLS MULTI PROTOCOL LABEL SWITCHING. Una Arquitectura de Backbone para la Internet del Siglo XXI

Universidad Nacional del Nordeste Facultad deciencias Exactas, Naturales yagrimensura Trabajo Final de Aplicación MPLS MULTI PROTOCOL LABEL SWITCHING Una Arquitectura de Backbone para la Internet del Siglo XXI por María Sol Canalis Prof. Coordinador: Agr. Castor Herrmann Prof. Orientador: Lic. Ricardo Monzón Licenciatura en Sistemas Corrientes Argentina Corrientes 2003

A mis padres, por el apoyo incondicional, y a la luz que hoy ilumina mi vida.

Prefacio El protocolo TCP / IP es hoy día una solución clásica y estándar al transporte de información en las redes. Aceptado por toda la comunidad de Internet, ha sido hasta hoy una solución aceptable para el envío de información, utilizando Routing de paquetes conciertas garantías de entrega. Asu vez, los avances en el hardware y en las metodologías de ingeniería del trá co están dando lugar al empleo creciente de las tecnologías de Conmutación, encabezadas por la tecnología ATM. Aportando velocidad, calidad de servicio y facilitando la gestión de los recursos en la red. El principal objetivo de este Trabajo es analizar y dar a conocer las soluciones que existen actualmente al problema de integrar trá co IP dentro de la tecnología ATM. Para ello, se comienza estudiando el protocolo IP, la tecnología ATM y las diferencias entre ellos. También se verán las necesidades crecientes por parte de proveedores y administradores de redes de mantener un control sobre el trá co, gestión de recursos, ancho de banda disponible y calidad de servicio (QoS). Comprobando cómo el protocolo de Internet actual, IP, puede bene ciarse de las características que aportan las nuevas tecnologías, principalmente ATM. Tras esto, se estudian a fondo las soluciones IP - ATM más destacadas, y se desarrolla una simulación sobre MPLS, la solución más sólida de todas las estudiadas, a mi parecer. Este simulador nos proporcionará una idea más clara de las ventajas, inconvenientes, costes de implantación del nuevo sistema, etc. El Simulador utilizado fue desarrollado en el Área Telemática del Departamento de Informática de la Universidad de Extremadura, agradeciéndose muy especialmente a Miguel Ángel Martín Tardío, Miguel Gaspar Rodríguez y José Luis Gonzalez Sánchez. Sobre el mismo se ha desarrollado una Interfaz de Captura de Datos de Entrada. Se ha optado por el lenguaje Java para realizar la implementación. Los motivos: su orientación a objetos, la posibilidad de manejar hilos de ejecución y la ejecución multiplataforma. A continuación pasamos a describir cada uno de los capítulos de los que consta este texto: ² Lenguaje Java. Debido a que se utilizó este lenguaje en la elaboración del Simulador de Redes MPLS y de la interfaz de Captura de Datos de Entrada, se dedicó

vi este capítulo a Java, lenguaje orientado a objetos (OO)y multiparadigma. ² Preparación de Documentos con Latex. Esta sección explica como se hace un libro con Latex; un sistema de composiciónprofesional que consiste en unconjunto de macrocomandos creado por Donald Knuth de la Universidad de Stanford en los años 1970s. También se utilizó para confeccionar este libro el editor Scienti c WorkPlace, que utiliza Latex como lenguaje de composición del texto. ² Introducción a MPLS. Esta sección nos introduce a la esencia misma del MPLS, explicando el porqué esta arquitectura es apta para la convergencia de las redes de altas prestaciones. También en este apartado se describen las diferentes alternativas que existen para mejorar la perfomance de las grandes redes, conluyendo que MPLS es la mejor opción. ² MPLS MultiProtocol Label Switching. Nos sumergidos por completo en el MPLS, explicando en detalle sutecnología, arquitectura, principales aplicaciones, etc. ² Simulador de Redes MPLS. Esta sección explica el desarrollo completo del Simulador de Redes MPLS, haciendo un estudio del sistema actual y del sistema propuesto aplicando MPLS. Se divide en las siguientes fases: Análisis, Diseño e Implementación. ² Interfaz de Captura de Datos de Entrada. Se desarrolló esta herramienta para hacer una interfaz más amigable con el usuario a la hora de cargar los datos del archivo de con guración que necesita el Simulador de Redes MPLS para su correcta ejecución. ² Ampliaciones y Conclusiones. Y por último, este apartado se re ere a las ampliaciones del Simulador de Redes MPLS, y de la Interfaz de Captura de Datos, nalizando con las conclusiones acerca de esta arquitectura. María Sol Canalis Licenciatura en Sistemas Universidad Nacional del Nordeste

Índice General 1 Java 1 1.1 Introducción al Lenguaje...................... 1 1.1.1 Bibliotecas de Clases Estándares de Java........ 3 1.1.2 Java es Multiplataforma.................. 3 1.1.3 Características del Lenguaje Java............. 4 1.2 Estructura General de un Programa Java............ 6 1.3 Conceptos Básicos......................... 7 1.3.1 Clase............................ 7 1.3.2 Herencia........................... 8 1.3.3 Interface........................... 8 1.3.4 Package........................... 9 1.3.5 La jerarquía de clases de Java (API)........... 10 1.4 Variables dentro del Lenguaje Java................ 10 1.4.1 Visibilidad y vida de las variables............. 13 1.5 Operadores en Java........................ 14 1.5.1 Operadores aritméticos.................. 14 1.5.2 Operadores de asignación................. 14 1.5.3 Operadores unarios..................... 15 1.5.4 Operadores incrementales................. 15 1.5.5 Operadores relacionales.................. 15 1.5.6 Operador de concatenación de cadenas de caracteres (+) 17 1.5.7 Precedencia de operadores................. 17 1.6 Estructuras de Programación................... 17 1.6.1 Sentencias o expresiones.................. 18 1.6.2 Comentarios........................ 19 1.6.3 Bifurcaciones........................ 20 1.6.4 Bucles............................ 21 1.7 Clases en Java........................... 24 vii

viii ÍNDICE GENERAL 1.7.1 Características importantes de las clases........ 24 1.7.2 Métodos o Funciones Miembros.............. 25 1.8 Algunas Clases de Utilidad.................... 27 1.8.1 Clase Arrays........................ 27 1.8.2 Clases String y StringBu er................ 28 1.8.3 Clase Double........................ 29 1.8.4 Clase Integer........................ 30 1.9 El AWT (Abstract Windows Toolkit)............... 30 1.9.1 Qué es el AWT....................... 30 1.9.2 Creación de una Interface Grá ca de Usuario...... 30 1.9.3 Objetos event source y objetos event listener.... 31 1.9.4 Proceso a seguir para crear una aplicación interactiva (orientada a eventos).................... 32 1.10 Errores Frecuentes de Programación............... 33 1.10.1 Scheduling de Hilos de Ejecución............. 33 1.10.2 Errores en el Uso de las Características de Portabilidad de Java........................... 35 1.10.3 Uso de directorios de nidos................ 35 1.10.4 Carga de Drivers JDBC.................. 38 1.10.5 Terminación de Líneas................... 39 1.10.6 Entrada/Salida por Archivo................ 40 1.10.7 Fuentes de Caracteres................... 40 2 Preparación de documentos con LATEX 41 2.1 Introducción............................. 41 2.1.1 Forma de trabajo con LATEX................ 42 2.1.2 Modo de trabajo en LATEX................. 46 2.2 Documentos en L A TEX....................... 46 2.2.1 El Preámbulo........................ 47 2.2.2 Especi cación y Estilo de Documento.......... 47 2.2.3 Estilo de Página...................... 50 2.2.4 La página del Título.................... 53 2.2.5 El Documento Propiamente Dicho............ 55 2.2.6 División de un documento en partes........... 57 2.2.7 Documento Tipo Libro................... 58 2.2.8 Trabajo en Modo Texto.................. 63 2.3 Partes Flotantes.......................... 67 2.3.1 Referencia Cruzada e Índice de Palabras......... 71 2.3.2 Bibliografía......................... 74

ÍNDICE GENERAL ix 3 Introducción al MPLS 77 3.1 Presentación de una Nueva Arquitectura............. 77 3.2 Estudio del Sistema Actual.................... 78 3.2.1 Protocolo IP........................ 79 3.2.2 Tecnología ATM...................... 82 3.2.3 El Protocolo IP sobre la estructura ATM........ 84 3.2.4 Modelo lógico del sistema existente............ 86 3.3 Evaluación de alternativas..................... 88 3.3.1 LANE............................ 89 3.3.2 IP clásico sobre ATM................... 90 3.3.3 NHRP............................ 90 3.3.4 MPOA............................ 92 3.3.5 Arequipa.......................... 92 3.3.6 IP Switching........................ 93 3.3.7 Tag Switching........................ 94 3.3.8 MPLS............................ 94 3.4 Selección de una alternativa.................... 96 3.4.1 Viabilidad técnica..................... 96 3.4.2 Viabilidad operacional................... 96 3.4.3 Viabilidad económica................... 97 4 MPLS Multi Protocol Label Switching 99 4.1 Introducción a MPLS....................... 99 4.1.1 Objetivos.......................... 100 4.2 Arquitectura............................ 102 4.2.1 Visión general........................ 102 4.2.2 Protocolo de Intercambio de Etiquetas LDP...... 133 4.3 Aplicaciones MPLS......................... 139 4.3.1 Ingienería de Trá co.................... 139 4.3.2 Clases de Servicios (CoS)................. 141 4.3.3 Redes Virtuales Privadas (VPNs)............. 142 5 Simulador de Redes MPLS 147 5.1 Fase de Análisis........................... 147 5.1.1 Diagrama de Contexto.................. 149 5.1.2 Descripción de las entidades externas........... 151 5.1.3 Descripción de los almacenes de datos.......... 151 5.1.4 Descripción de los procesos................ 152 5.1.5 Descripción de los ujos de datos............. 153 5.1.6 Componentes de un LSR................. 154

x ÍNDICE GENERAL 5.1.7 Diccionario de Datos.................... 155 5.2 Diseño del Sistema......................... 162 5.2.1 Diseño de las salidas.................... 162 5.3 Implementación........................... 166 5.3.1 Creación de las Clases en Java.............. 167 5.3.2 Implementación de los Procedimientos.......... 169 5.4 Ejemplos de Funcionamiento................... 181 5.4.1 Ejemplo 1. Entrada de datos IP sin clasi car....... 181 5.4.2 Ejemplo 2. Dos ujos de datos en la red......... 189 5.4.3 Ejemplo 3. Dos tipos de datagramas asociados a un ujo de datos........................... 196 6 Captura de Datos de Entrada 209 6.1 Reglas de codi cación del Archivo de Con guración...... 209 6.2 Bloques del Archivo de Con guración.............. 209 6.2.1 Datos Generales de la Red................. 210 6.2.2 Datos Especí cos para cada Nodo............ 211 6.3 Interfaz con el Usuario....................... 215 6.4 Código Fuente........................... 225 6.4.1 Clase principal MPLS.java............... 225 6.4.2 Clase FrPosiciones.java................. 234 6.4.3 Clase FrEnlaces.java................... 246 6.4.4 Clase FrLIB.java..................... 255 6.4.5 Clase FrRuteo.java.................... 271 6.4.6 Clase FrameConsola.java................ 280 6.4.7 Clase FiltroCFG.java.................. 282 6.4.8 Clase FrAyuda.java................... 283 6.4.9 Clase FrAcerca.java................... 285 7 Ampliaciones y Conclusiones 289 7.1 Ampliaciones y mejoras para el Simulador de Redes MPLS.. 289 7.2 Mejoras para la Interfaz de Captura de datos de Entrada... 290 7.3 Mejoras sobre la arquitectura MPLS............... 290 7.4 Conclusiones............................ 291 Bibliografía 293 Índice de Materias 295

Índice de Figuras 2.1 Algunos de los cheros resultantes del proceso de edición y composición de un documento con LATEX.............. 44 2.2 Niveles y comportamiento por defecto de las distintas unidades de seccionamiento, y según las clases de documento (se ha tomado art. y rep. como abreviatura de article y report).. 57 2.3 Esquema de un chero para preparar libros............ 62 3.1 Formato del Datagrama IP..................... 80 3.2 Cabecera de una célula ATM.................... 82 3.3 Diagrama de Contexto del Sistema Actual............ 87 3.4 DFD de Primer Nivel........................ 88 4.1 Esquema funcional de MPLS.................... 103 4.2 Componente de Control y Envío de Etiquetas........... 105 4.3 Detalle de la tabla de envío de un LSR.............. 106 4.4 Ejemplo de envío de un paquete por un LSP........... 107 4.5 Estructura de la cabecera genérica MPLS............ 107 4.6 Ejemplo de las distribución de etiquetas.............. 116 4.7 Distribución DownStream bajo demanda............. 117 4.8 DownStream sin Solicitar..................... 117 4.9 Funcionamiento de los LSP..................... 122 4.10 Comparación entre camino más corto IGP con Ingienería de Trá co................................ 140 4.11 Modelo superpuesto (túneles/pvcs) vs. modelo acoplado (MPLS)................................ 145 5.1 Diagrama de Contexto del Nuevo Sistema............. 149 5.2 Diagrama de Nivel Superior..................... 150 5.3 Entrada de Datos Genéricos.................... 164 5.4 Datos de la tabla NHLFE...................... 164 xi

xii ÍNDICE DE FIGURAS 5.5 Disposición de la red del Ejemplo 1................ 185 5.6 Disposición de la red del Ejemplo 2................ 195 5.7 Disposición de la red del Ejemplo 3................ 202 6.1 Disposición de las ventanas..................... 216 6.2 Menú Archivo............................ 216 6.3 Submenú Guardar.......................... 217 6.4 Submenú Posiciones......................... 218 6.5 Mensaje de Error.......................... 219 6.6 Datos de los nodos internos..................... 219 6.7 Datos de los nodos externos..................... 220 6.8 Submenú Enlaces.......................... 221 6.9 Ventana de Enlaces......................... 221 6.10 Submenú Tabla LIB......................... 222 6.11 Datos de Entrada de la LIB:.................... 223 6.12 Información de Salida........................ 224 6.13 Información general......................... 224 6.14 Submenú Tabla de Ruteo...................... 225 6.15 Información de la Tabla de Ruteo................. 226

Índice de Tablas 1.1 Tipos de Variables.......................... 11 1.2 Categorías de Variables....................... 12 1.3 Tipos Primitivos de Variables.................... 12 1.4 Operadores de asignación...................... 14 1.5 Operadores relacionales....................... 16 1.6 Precedencia de Operadores..................... 18 2.1 Programas implicados en la preparación de un documento con LaTeX................................ 42 2.2 Programas implicados en la preparación de un documento con LaTeX................................ 52 5.1 Dirección IP............................. 156 5.2 Pre jo de Dirección......................... 156 5.3 Siguiente Salto............................ 156 5.4 Etiqueta de Entrada......................... 156 5.5 Etiqueta de Salida.......................... 157 5.6 Clase de Envio Equivalente..................... 157 5.7 Número Interfaz Salida....................... 157 5.8 Número Interfaz Entrada...................... 157 5.9 Interfaz de Entrada......................... 158 5.10 Interfaz de Salida.......................... 158 5.11 Número Interfaz de Salida..................... 158 5.12 Número Interfaz de Entrada.................... 158 5.13 Interfaz de Entrada......................... 159 5.14 Interfaz de Salida.......................... 159 5.15 Etiqueta de Entrada......................... 159 5.16 Etiqueta de Salida.......................... 159 xiii

Capítulo 1 Java 1.1 Introducción al Lenguaje Java es un lenguaje orientado a objetos. Esto signi ca que posee ciertas características que hoy día se consideran estándares en los lenguajes OO: ² Objetos ² Clases ² Métodos ² Subclases ² Herencia simple ² Enlace dinámico ² Encapsulamiento Para programar orientado a objetos es necesario primero diseñar un conjunto de clases. La claridad, e ciencia y mantenibilidad del programa resultante dependerá principalmente de la calidad del diseño de clases. Un buen diseño de clases signi cará una gran economía en tiempo de desarrollo y mantención. Lamentablemente se necesita mucha habilidad y experiencia para lograr diseños de clases de calidad. Un mal diseño de clases puede llevar a programas OO de peor calidad y de más alto costo que el programa equivalente no OO. 1

2 CAPÍTULO 1. JAVA Por qué entonces la ventaja de programar en un lenguaje OO, si se requiere una experiencia que probablemente una persona nunca tendrá el tiempo de práctica para llegar a obtenerla. La respuesta a este interrogante es que Java es un lenguaje multiparadigma (como muchos otros lenguajes de programación). No se necesita hacer un diseño de clases para programar una aplicación de mil líneas. Entonces otro interrogante podrá ser porque no programar con otro lenguaje más simples, como puede ser Visual Basic, si no se necesita que sea OO. La respuesta a ésto es la gran ventaja de un lenguaje OO, que son las bibliotecas de clases que se pueden construir para la aplicación. Una biblioteca de clases cumple el mismo objetivo de una biblioteca de procedimientos en una lenguaje como C. Sin embargo: Una biblioteca de clases es mucho más fácil de usar que una biblioteca de procedimientos, incluso para programadores sin experiencia en orientación a objetos. Esto se debe a que las clases ofrecen mecanismos de abstracción más e caces que los procedimientos. Se puede distinguir entre varios tipos de programadores en Java: El diseñador de clases: Es el encargado de de nir qué clases ofrece una biblioteca y cuál es la funcionalidad que se espera de estas clases. Esta persona tiene que ser muy hábil y de mucha experiencia. Un diseño equivocado puede conducir a clases que son incomprensibles para los clientes de la biblioteca. El programador de clases de biblioteca: Sólo programa la clases especi cadas por el diseñador de clases. Esta persona debe entender orientación a objetos, pero no requiere mayor experiencia en diseño de clases. El cliente de bibliotecas: Es el programador de aplicaciones. Él sólo usa las clases que otros han diseñado y programado. Como en el caso anterior necesita entender orientación a objetos y conocer la biblioteca que va usar, pero no necesita mayor experiencia. Tanto programadores de clases como clientes de bibliotecas pueden llegar a convertirse en buenos diseñadores de clases en la medida que adquieran experiencia, comparando los diseños de las bibliotecas que utilicen. Por lo tanto es importante destacar que no se necesita gran experiencia en diseño orientado a objetos para poder aprovechar las ventajas de la orientación

1.1. INTRODUCCIÓN AL LENGUAJE 3 a objetos. 1.1.1 Bibliotecas de Clases Estándares de Java Toda implementación de Java debe tener las siguientes bibliotecas de clases: ² Manejo de archivos ² Comunicación de datos ² Acceso a la red internet ² Acceso a bases de datos ² Interfaces grá cas La interfaz de programación de estas clases es estándar, es decir en todas ellas las operaciones se invocan con el mismo nombre y los mismos argumentos. 1.1.2 Java es Multiplataforma Los programas en Java pueden ejecutarse en cualquiera de las siguientes plataformas, sin necesidad de hacer cambios: Windows/95 y /NT. Power/Mac. Unix (Solaris, Silicon Graphics,...). La compatibilidad es total: A nivel de fuentes: El lenguaje es exactamente el mismo en todas las plataformas. A nivel de bibliotecas: En todas las plataformas están presentes las mismas bibliotecas estándares. Aniveldelcódigo compilado: el código intermedio que genera el compilador es el mismo para todas las plataformas. Lo que cambia es el intérprete del código intermedio.

4 CAPÍTULO 1. JAVA 1.1.3 Características del Lenguaje Java ² Robustez En Java no se pueden cometer los 4 errores que se mencionarán a continuación: Java siempre chequea los índices al acceder a un arreglo. Java realiza chequeo de tipos durante la compilación (al igual que C). En una asignación entre punteros el compilador veri ca que los tipos sean compatibles. Además, Java realiza chequeo de tipos durante la ejecución (cosa que C y C++ no hacen). Cuando un programa usa un cast para acceder a un objeto como si fuese de un tipo especí co, se veri ca durante la ejecución que el objeto en cuestión sea compatible con el cast que se le aplica. Si el objeto no es compatible, entonces se levanta una excepciónque informa al programador la línea exacta en donde está la fuente del error. Java posee un recolector de basuras que administra automáticamente la memoria. Es elrecolector elque determina cuando se puede liberar el espacio ocupado por un objeto. El programador no puede liberar explícitamente el espacio ocupado por un objeto. Java no posee aritmética de punteros, porque es una propiedad que no se necesita para programar aplicaciones. En C sólo se necesita la aritmética de punteros para programa malloc/free o para programar el núcleo del sistema operativo. Por lo tanto Java no es un lenguaje para hacer sistemas operativos o administradores de memoria, pero síes unexcelente lenguaje para programar aplicaciones. ² Flexibilidad Java combina exibilidad, robustez y legibilidad gracias a una mezcla de chequeo de tipos durante la compilación y durante la ejecución. En Java se pueden tener punteros a objetos de un tipo especí co y también se pueden tener punteros a objetos de cualquier tipo. Estos punteros se pueden convertir

1.1. INTRODUCCIÓN AL LENGUAJE 5 a punteros de un tipo especí co aplicando un cast, en cuyo caso se chequea en tiempo de ejecución de que el objeto sea de un tipo compatible. El programador usa entonces punteros de tipo especí co en la mayoría de los casos con el n de ganar legibilidad y en unos pocos casos usa punteros a tipos desconocidos cuando necesita tener exibilidad. Por lo tanto Java combina la robustez de Pascal con la exibilidad de Lisp, sin que lo programas pierdan legibilidad en ningún caso. ² Administración Automática de la Memoria En Java los programadores no necesitan preocuparse de liberar un trozo de memoria cuando ya no lo necesitan. Es el recolector de basuras el que determina cuando se puede liberar la memoria ocupada por un objeto. Un recolector de basuras es un gran aporte a la productividad. Se ha estudiado en casos concretos que los programadores han dedicado un 40% del tiempo de desarrollo a determinar en qué momento se puede liberar un trozo de memoria. Además este porcentaje de tiempo aumenta a medida que aumenta la complejidad del software en desarrollo. Es relativamente sencillo liberar correctamente la memoria enun programa de 1000 líneas. Sinembargo, es difícil hacerlo en un programa de 10000 líneas. Y se puede postular que es imposible liberar correctamente la memoria en un programa de 100000 líneas. Para entender mejor esta a rmación, se podría suponer que se realizó un programa de 1000 líneas hace un par de meses y ahora se necesita hacer algunas modi caciones. Ahora, para esta altura ya se habrán olvidado gran parte de los detalles de la lógica de ese programa y no será sencillo determinar si un puntero referencia un objeto que todavía existe, o si ya fue liberado. Peor aún, supóngase que el programa fue hecho por otra persona y evalúe cuán probable es cometer errores de memoria al tratar de modi car ese programa. Volviendo al caso de un programa de 100000 líneas. Este tipo de programas los desarrolla un grupo de programadores que pueden tomar años en terminarlo. Cada programador desarrolla un módulo que eventualmente utiliza objetos de otros módulos desarrollados por otros programadores. Entonces, quién libera la memoria de estos objetos, cómo se ponen de acuerdo los programadores sobre cuándo y quién libera un objeto compartido, o cómo probar el programa completo ante las in nitas condiciones de borde que pueden existir

6 CAPÍTULO 1. JAVA en un programa de 100000 líneas. Es inevitable que la fase de prueba dejará pasar errores en el manejo de memoria que sólo serán detectados más tarde por el usuario nal. Probablemente se incorporan otros errores en la fase de mantención. Resumiendo, se puede concluir que: todo programa de 100000 líneas que libera explícitamente la memoria tiene errores latentes, sin un recolector de basuras no hay verdadera modularidad y un recolector de basuras resuelve todos los problemas de manejo de memoria en forma trivial. El interrogante sería cuál es el impacto de un recolector de basura en el desempeño de un programa. El sobrecosto de la recolección de basuras no es superior al 100%. Es decir si se tiene un programa que libera explícitamente la memoria y que toma tiempo X, el mismo programa modi cado de modo que utilice un recolector de basuras para liberar la memoria tomará un tiempo no superior a 2X. Este sobrecosto no es importante si se considera el periódico incremento en la velocidad de los procesadores. El impacto que un recolector de basura en el tiempo de desarrollo y en la con abilidad del software. 1.2 Estructura General de un Programa Java En el siguiente ejemplo se presenta la estructura habitual de un programa realizado en cualquier lenguaje orientado a objetos u OOP (Object Oriented Programming), y en particular en el lenguaje Java. import java.awt.*; import java.lang.string; import java.lang.integer; import java.awt.event.windowevent; import java.util.*; import java.awt.textfield; public class Simuextends Frame implements ActionListener,ItemListener{ MenuBar barra;

1.3. CONCEPTOS BÁSICOS 7 m1 =new Menu( Archivo ); barra.add(m1); m2 =new Menu( Ver ); barra.add(m2);... public static void main(string argv [ ]){ Simu menus = new Simu(); menus.settitle( Simulaciónde Redes Neuronales ); menus.setvisible(true); } } Aparece una clase que contiene el programa principal Simu (aquel que contiene la función main()) y algunas clases de usuario (las especí cas de la aplicación que se está desarrollando) que son utilizadas por el programa principal. La aplicación se ejecuta por medio del nombre de la lase que contiene la función main(). Las clases de Java se agrupan en packages, que son librerías de clases. Si las clases no se de nen como pertenecientes a un package, se utiliza un package por defecto (default) que es el directorio activo. 1.3 Conceptos Básicos 1.3.1 Clase Una clase es una agrupación de datos (variables o campos) y de funciones (métodos) que operan sobre esos datos. A estos datos y funciones pertenecientes a una clase se les denomina variables y métodos o funciones miembro. La programación orientada a objetos se basa enla programación de clases. Un programa se construye a partir de un conjunto de clases. Una vez de nida e implementada una clase, es posible declarar elementos de esta clase de modo similar a como se declaran las variables del lenguaje (int, double, String). Los elementos declarados de una clase se denominan objetos de la clase. De una única clase se pueden declarar o crear numerosos objetos. La clase es lo genérico: es el patrón o modelo para crear objetos. Cada objeto

8 CAPÍTULO 1. JAVA tiene sus propias copias de las variables miembro, con sus propios valores, en general distintos de los demás objetos de la clase. Las clases pueden tener variables static, que son propias de la clase y no de cada objeto. Ejemplo: public abstract class FuncionActivacion implements Cloneable,Serializable{ /*constructor sin argumentos que permite la herencia */ public FuncionActivacion () { } } 1.3.2 Herencia La herencia permite que se puedan de nir nuevas clases basadas en clases existentes, lo cual facilita reutilizar código previamente desarrollado. Si una clase deriva de otra (extends) hereda todas sus variables y métodos. La clase derivada puede añadir nuevas variables y métodos y/o rede nir las variables y métodos heredados. En Java, a diferencia de otros lenguajes orientados a objetos, una clase sólo puede derivar de una única clase, con lo cual no es posible realizar herencia múltiple en base a clases. Sin embargo es posible simular la herencia múltiple en base a las interfaces. 1.3.3 Interface Una interface es un conjunto de declaraciones de funciones. Si una clase implementa (implements) una interface, debe de nir todas las funciones especi- cadas por la interface. Una clase puede implementar más de una interface, representando una forma alternativa de la herencia múltiple. Una interface puede derivar de otra o incluso de varias interfaces, en cuyo caso incorpora todos los métodos de las interfaces de las que deriva.

1.3. CONCEPTOS BÁSICOS 9 Ejemplo: La clase TangenteHiperbolica se extiende de la clase FuncionActivacion que implementa la interface Serializable. /*función de activación tangente hiperbólica */ public class TangenteHiperbolica extends FuncionActivacionimplements Serializable{ } /*constructor sin argumentos */ public TangenteHiperbolica () { } 1.3.4 Package Un package es una agrupación de clases. Existen una serie de packages incluidos en el lenguaje. Además el programador puede crear sus propios packages. Todas las clases que formen parte de un package deben estar en el mismo directorio. Los packages se utilizan con las siguientes nalidades: 1. Para agrupar clases relacionadas. 2. Para evitar con ictos de nombres. En caso de con icto de nombres entre clases importadas, el compilador obliga a cuali car en el código los nombres de dichas clases con el nombre del package. 3. Para ayudar en el control de la accesibilidad de clases y miembros. Por las razones citadas, durante la etapa de Diseño del Software desarrollado, se ha decido crear dos paquetes, calculos e interfase, utilizando la sentencia package. package myprojects.simu; import myprojects.calculos.*; import myprojects.interfase.*;

10 CAPÍTULO 1. JAVA 1.3.5 La jerarquía de clases de Java (API) Durante la generación de código en Java, es recomendable y casi necesario tener siempre a la vista la documentación on-line del API de Java 1.1 ó Java 1.2. En dicha documentación es posible ver tanto la jerarquía de clases, es decir la relación de herencia entre clases, como la información de los distintos packages que componen las librerías base de Java. Es importante distinguir entre lo que signi ca herencia y package. Un package es una agrupación arbitraria de clases, una forma de organizar las clases. La sin embargo consiste en crear nuevas clases en base a otras ya existentes. Las clases incluidas en un package no derivan en general de la misma clase. Enla documentación on-line se presentan ambas visiones: Package Index y Class Hierarchy. La primera presenta la estructura del API de Java agrupada por packages, mientras que en la segunda aparece la jerarquía de clases. Hay que resaltar el hecho de que todas las clases en Java son derivadas de la clase java.lang.object, por lo que heredantodos los métodos y variables de ésta. Si se selecciona una clase en particular, la documentación muestra una descripción detallada de todos los métodos y variables de la clase. A su vez muestra su herencia completa (partiendo de la clase java.lang.object). 1.4 Variables dentro del Lenguaje Java Una variable en Java es un identi cador que representa una palabra de memoria que contiene información. El tipo de información almacenado en una variable sólo puede ser del tipo con que se declaró esa variable. En Java hay dos tipos principales de variables: 1. Variables de tipos primitivos. Están de nidas mediante un valor único y almacenan directamente ese valor siempre que pertenezca al rango de ese tipo. Por ejemplo una variable int almacena un valor entero como 1, 2, 0, -1, etc. Esto signi ca que al asignar una variable entera a otra variable entera, se copia el valor de la primera en el espacio que ocupa la segunda variable.

1.4. VARIABLES DENTRO DEL LENGUAJE JAVA 11 2. Variables referencia. Las variables referencia son referencias o nombres de una información más compleja: arrays u objetos de una determinada clase. Una referencia a un objeto es la dirección de un área en memoria destinada a representar ese objeto. El área de memoria se solicita con el operador new. Al asignar una variable de tipo referencia a objeto a otra variable se asigna la dirección y no el objeto referenciado por esa dirección. Esto signi ca que ambas variables quedan refenciando el mismo objeto. En Java una variable no puede almacenar directamente un objeto, como ocurre en C y C++. Por lo tanto cuando se dice en Java que una variable es un string, lo que se quiere decir en realidad es que la variable es una referencia a un string. Desde el punto de vista de su papel dentro del programa, las variables pueden ser: 1. Variables miembro de una clase: Se de nen en una clase, fuera de cualquier método; pueden ser tipos primitivos o referencias. 2. Variables locales: Se de nen dentro de un método o más en general dentro de cualquier bloque entre llaves {}. Se crean en el interior del bloque y se destruyen al nalizar dicho bloque. Puedenser tambiéntipos primitivos o referencias. En la Tabla 1.1 de la pág. 11 se muestra una declaración, el nombre de la variable introducida y el tipo de información que almacena la variable: Declaración Identi cador Tipo int i; i entero String s; s referencia a string int a []; a referencia a arreglo de enteros int[]b; b referencia a arreglo de enteros Tabla 1.1: Tipos de Variables. En la Tabla 1.2 de la pág. 12 se muestran las dos grandes categorías de tipos para las variables en Java:

12 CAPÍTULO 1. JAVA Tipos Primitivos int, short, byte, long char, boolean oat, double Referencias a Objetos Strings Arreglos otros objetos Tabla 1.2: Categorías de Variables. En la Tabla 1.3de la pág. 12 se indica para cada tipo primitivo el número de bits que se emplea en su representación y el rango de valores que se puede almacenar en las variables de estos tipos. Tipo Bits Rango Ejemplos int 32 2 31..2 31 1 0,1,5,-120,... short 16 2 15 ::2 15 1 0,1,5,-120,... byte 8 2 7 ::2 7 1 0,1,5,-120,... long 64 2 63 ::2 63 1 0,1,5,-120,... boolean 1 n/a false, true char 16 n/a a, A, 0, *,... oat 32 IEEE 1.2 double 64 IEEE 1.2 Tabla 1.3: Tipos Primitivos de Variables. Se dice que un tipo A es de mayor rango que un tipo B si A es un superconjunto de B. Esto quiere decir que las variables de tipo B siempre se pueden asignar a variables de tipo A (eventualmente con pérdida de signi cancia). Por ejemplo int es de mayor rango que short, que a su vez es de mayor rango que byte. Float y double son de mayor rango que int. Double es de mayor rango que oat. Esto se puede quedar resumido de la siguiente manera: double > oat > long > int > short > byte

1.4. VARIABLES DENTRO DEL LENGUAJE JAVA 13 1.4.1 Visibilidad y vida de las variables Se entiende por visibilidad, ámbito o scope de una variable, la parte de la aplicación donde dicha variable es accesible y por lo tanto puede ser utilizada en cualquier expresión. En Java todos las variables deben estar incluidas en una clase. En general las variables declaradas dentro de unas llaves {}, es decir dentro de un bloque, son visibles y existen dentro de estas llaves. Por ejemplo las variables declaradas al principio de una función existen mientras se ejecute la función; las variables declaradas dentro de un bloque if no serán válidas al nalizar las sentencias correspondientes a dicho if y las variables miembro de una clase (es decir declaradas entre las llaves {} de la clase pero fuera de cualquier método) son válidas mientras existe el objeto de la clase. Las variables miembro de una clase declaradas como public son accesibles a través de una referencia a un objeto de dicha clase utilizando el operador punto (.). Las variables miembro declaradas como private no son accesibles directamente desde otras clases. Las funciones miembro de una clase tienen acceso directo a todas las variables miembro de la clase sin necesidad de anteponer el nombre de un objeto de la clase. Sin embargo las funciones miembro de una clase B derivada de otra A, tienen acceso a todas las variables miembro de A declaradas como public o protected, pero no a las declaradas como private. Una clase derivada sólo puede acceder directamente a las variables y funciones miembro de su clase base declaradas como public o protected. Otra característica del lenguaje es que es posible declarar una variable dentro de un bloque con el mismo nombre que una variable miembro, pero no con el nombre de otra variable local. La variable declarada dentro del bloque oculta a la variable miembro en ese bloque. Para acceder a la variable miembro oculta será preciso utilizar el operador this. Uno de los aspectos más importantes en la programación orientada a objetos (OOP) es la forma en la cual son creados y eliminados los objetos. La forma de crear nuevos objetos es utilizar el operador new. Cuando se utiliza el operador new, la variable de tipo referencia guarda la posición de memoria donde está almacenado este nuevo objeto. Para cada objeto se lleva cuenta de por cuántas variables de tipo referencia es apuntado. La eliminación de los objetos la realiza el denominado garbage collector, quien automáticamente libera o borra la memoria ocupada por un objeto cuando no existe ninguna referencia apuntando a ese objeto. Lo anterior signi ca que aunque una variable de tipo referencia deje de existir, el objeto al cual apunta no es eliminado si hay otras referencias apuntando a ese mismo objeto.

14 CAPÍTULO 1. JAVA 1.5 Operadores en Java Java es un lenguaje rico en operadores, que son casi idénticos a los de C/C++. Estos operadores se describen brevemente a continuación. 1.5.1 Operadores aritméticos Son operadores binarios (requieren siempre dos operandos) que realizan las operaciones aritméticas habituales: suma (+), resta (-), multiplicación (*), división (/) y resto de la división (%). 1.5.2 Operadores de asignación Los operadores de asignación permiten asignar un valor a una variable. El operador de asignación por excelencia es el operador igual (=). La forma general de las sentencias de asignación con este operador es: variable = expression; Java dispone de otros operadores de asignación. Se trata de versiones abreviadas del operador (=) que realizan operaciones acumulativas sobre una variable. La siguiente Tabla 1.4 de la pág. 14, muestra estos operadores y su equivalencia con el uso del operador igual (=). Operador Utilización ExpresiónEquivalente + = op1 + = op2 op1 = op1 + op2 - = op1 - = op2 op1 = op1 - op2 = * op1 * = op2 op1 = op1 * op2 = / op1 / = op2 op1 = op1 / op2 % = op1% = op2 op1 = op1 % op2 Tabla 1.4: Operadores de asignación.

1.5. OPERADORES EN JAVA 15 1.5.3 Operadores unarios Los operadores más (+) y menos (-) unarios sirven para mantener o cambiar el signo de una variable, constante o expresión numérica. Su uso en Java es el estándar de estos operadores. 1.5.4 Operadores incrementales Java dispone del operador incremento (++) y decremento ( ). El operador (++) incrementa en una unidad la variable a la que se aplica, mientras que ( ) la reduce en una unidad. Estos operadores se pueden utilizar de dos formas: 1. Precediendo a la variable (por ejemplo: ++i). En este caso primero se incrementa la variable y luego se utiliza (ya incrementada) en la expresión en la que aparece. 2. Siguiendo a la variable (por ejemplo: i++). En este caso primero se utiliza la variable en la expresión (con el valor anterior) y luego se incrementa. En muchas ocasiones estos operadores se utilizan para incrementar una variable fuera de una expresión. En este caso ambos operadores son equivalente. Si se utilizan en una expresión más complicada, el resultado de utilizar estos operadores en una u otra de sus formas será diferente. La actualización de contadores en bucles for es una de las aplicaciones más frecuentes de estos operadores. 1.5.5 Operadores relacionales Los operadores relacionales sirven para realizar comparaciones de igualdad, desigualdad y relación de menor o mayor. El resultado de estos operadores es siempre un valor boolean (true o false) según se cumpla o no la relación considerada. La siguiente Tabla 1.5 de la pág. 16 muestra los operadores relacionales de Java.

16 CAPÍTULO 1. JAVA Operador Utilización El resultado es true > op1 > op2 si op1 es mayor que op2 > = op1 >= op2 si op1 es mayor o igual que op2 < op1 < op2 si op1 es menor que op 2 < = op1 <= op2 si op1 es menor o igual que op2 = = op1 == op2 si op1 y op2 son iguales! = op1!= op2 sio p1 y op2 son diferentes Tabla 1.5: Operadores relacionales. Estos operadores se utilizan con mucha frecuencia en las bifurcaciones y en los bucles, que se verán luego. Ejemplo de Operadores Incrementales y Operadores Relacionales en un método. public void cambiarparesentrenamiento(double[ ] paresentrenamiento){ } /* inicialización de sus valores a partir de los valores pasados como argumentos */ for(int i = 0; i< paresentrenamiento.length; i++) {for(int j = 0; j< numeroneuronasentrada; j++) } {entradaentrenamiento[i][j] = paresentrenamiento[i][j]; } for(int j = 0; j< numerosalidas; j++) {salidaentrenamiento[i][j] = paresentrenamiento[i][j+numeroneuronasentrada]; }

1.6. ESTRUCTURAS DE PROGRAMACIÓN 17 1.5.6 Operador de concatenación de cadenas de caracteres (+) El operador más (+) se utiliza también para concatenar cadenas de caracteres. Por ejemplo, para escribir una cantidad con un rótulo puede utilizarse la sentencia: editor.append( Error Obtenido: + String.valueOf(imprimoError) + nn ); editor.append( Iteraciones: + String.valueOf(imprimoIteraciones) + nn ); editor.append( Inicio: + horainicial.tostring() + nn ); editor.append( Final: + horafinal.tostring() + nn ); donde el operador de concatenación se utiliza dos veces para construir la cadena de caracteres que se desea imprimir. Las variables imprimoerrror, imprimoiteraciones, horainicial, horafinal son convertidas en cadena de caracteres para poder concatenarlas. 1.5.7 Precedencia de operadores El orden en que se realizan las operaciones es fundamental para determinar el resultado de una expresión. Por ejemplo, el resultado de x/y*z depende de qué operación (la división o el producto) se realice primero. La Tabla 1.6 de la pág. 18 muestra el orden en que se ejecutan los distintos operadores en una sentencia, de mayor a menor precedencia: En Java, todos los operadores binarios, excepto los operadores de asignación, se evalúan de izquierda a derecha. Los operadores de asignación se evalúan de derecha a izquierda, lo que signi ca que el valor de la izquierda se copia sobre la variable de la derecha. 1.6 Estructuras de Programación Las estructuras de programación o estructuras de control permiten tomar decisiones y realizar un proceso repetidas veces. Son los denominados bifurcaciones y bucles. En la mayoría de los lenguajes de programación, este tipo de

18 CAPÍTULO 1. JAVA Nombre Sintáxis Post jos [ ].(params) expr++ expr- Unarios ++expr expr +expr -expr! De creación (type) expr Multiplicativo * / % Adición + - Shift << >> >>> Relacional <> <= >= instanceof Igualdad = =! = AND & Or Excluyente ^ Or Incluyente j Logico AND && Logico OR jj Condicional?: Asignación = += -= *= /= %= &= ^= j= <<= >>= >>>= Tabla 1.6: Precedencia de Operadores. estructuras son comunes en cuanto a concepto, aunque su sintaxis varía de un lenguaje a otro. La sintaxis de Java coincide prácticamente con la utilizada en C/C++, lo que hace que para un programador de C/C++ no suponga ninguna di cultad adicional. 1.6.1 Sentencias o expresiones Una expresión es un conjunto variables unidos por operadores. Son órdenes que se le dan al computador para que realice una tarea determinada. Una sentencia es una expresión que acaba en punto y coma (;). Se permite incluir varias sentencias en una línea, aunque lo habitual es utilizar una línea para cada sentencia. A continuación se muestra un ejemplo de una línea compuesta de tres sentencias: i = 0; j = 5; x = i + j;

1.6. ESTRUCTURAS DE PROGRAMACIÓN 19 1.6.2 Comentarios Existen dos formas diferentes de introducir comentarios entre el código de Java (en realidad son tres, como pronto se verá). Son similares a la forma de realizar comentarios en el lenguaje. Los comentarios son tremendamente útiles para poder entender el código utilizado, facilitando de ese modo futuras revisiones y correcciones. Además permite que cualquier persona distinta al programador original pueda comprender el código escrito de una forma más rápida. Se recomienda acostumbrarse a comentar el código desarrollado. De esta forma se simpli ca también la tarea de estudio y revisión posteriores. Java interpreta que todo lo que aparece a la derecha de dos barras // en una línea cualquiera del código es un comentario del programador y no lo tiene en cuenta. El comentario puede empezar al comienzo de la línea o a continuación de una instrucción que debe ser ejecutada. La segunda forma de incluir comentarios consiste en escribir el texto entre los símbolos /* */. Este segundo método es válido para comentar más de una línea de código. Por ejemplo: // Esta línea es un comentario int a=1; // Comentario a la derecha de una sentencia // Esta es la forma de comentar más de una línea utilizando // las dos barras. Requiere incluir dos barras al comienzo de cada línea /* Esta segunda forma es mucho más cómoda para comentar un número elevado de líneas ya que sólo requiere modi car el comienzo y el nal. */ En Java existe además una forma especial de introducir los comentarios (utilizando /***/ más algunos caracteres especiales) que permite generar automáticamente la documentación sobre las clases y packages desarrollados por el programador. Una vez introducidos los comentarios, el programa javadoc.exe (incluido en el JDK) genera de forma automática la información de forma similar a la presentada en la propia documentación del JDK. La sintaxis de estos comentarios y la forma de utilizar el programa javadoc.exe se puede encontrar en la información que viene con el JDK.

20 CAPÍTULO 1. JAVA 1.6.3 Bifurcaciones Las bifurcaciones permiten ejecutar una de entre varias acciones en función del valor de una expresión lógica o relacional. Se tratan de estructuras muy importantes ya que son las encargadas de controlar el ujo de ejecución de un programa. Se exponen dos variantes del de tipo if. Bifurcación if Esta estructura permite ejecutar un conjunto de sentencias en función del valor que tenga la expresión de comparación. Ejemplo: se ejecuta si la expresión de comparación (error < errorminimo) tiene valor true: protected void comprobarnuevominimo() { if (error < errorminimo) {errorminimo = error; vectordisminimo = (double[ ])(vectordis.clone()); } /* n del if */ } Las llaves {} sirven para agrupar en un bloque las sentencias que se han de ejecutar, y no son necesarias si sólo hay una sentencia dentro del if. Bifurcación if else Análoga a la anterior, de la cual es una ampliación. Las sentencias incluidas en el else se ejecutan en el caso de no cumplirse la expresión de comparación (false), Ejemplo: public double decirsalidaactual(int indiceetapa) { if(pila!= null) {return pila[indiceetapa];}

1.6. ESTRUCTURAS DE PROGRAMACIÓN 21 } else {System.out.println( Fallo: Pila no creada ); return 0; } 1.6.4 Bucles Un bucle se utiliza para realizar un proceso repetidas veces. Se denomina también lazo o loop. El código incluido entre las llaves {} (opcionales si el proceso repetitivo consta de una sola línea), se ejecutará mientras se cumpla unas determinadas condiciones. Hay que prestar especial atencióna los bucles in nitos, hecho que ocurre cuando la condición de nalizar el bucle (booleanexpression) no se llega a cumplir nunca. Se trata de un fallo muy típico, habitual sobre todo entre programadores poco experimentados. Bucle while En el siguiente ejemplo se muestra que se ejecutará la sentencia n++ mientras la expresión (capas.charat( n)!=, && capas.charat( n)!=-1)sea verdadera. for (int j=0; j < numerocapas; j++) {int n = principio; try { while (capas.charat( n)!=, && capas.charat( n)!= -1) { n++; } } } Bucle for A continuación se podrá apreciar la utilización del bucle for:

22 CAPÍTULO 1. JAVA /* calcular el nuevo vector de diseño */ for (int i = 0; i < vectordis.length; i++) {vectordis[i] = vectordis[i] + learningrate * S[i]; } La sentencia int i = 0 (inicialización) se ejecuta al comienzo del for, e i++ (incremento) después de vectordis[i] = vectordis[i] + learningrate *S[i] (sentencia). La expresión booleana (vectordis.length) se evalúa al comienzo de cada iteración; el bucle termina cuando la expresión de comparación toma el valor false. Bucle do while Es similar al bucle while pero con la particularidad de que el control está al nal del bucle (lo que hace que el bucle se ejecute al menos una vez, independientemente de que la condición se cumpla o no). Una vez ejecutados las sentencias, se evalúa la condición: si resulta true se vuelven a ejecutar las sentencias incluidas en el bucle, mientras que si la condición se evalúa a false naliza el bucle. do{ /* calcular el gradiente del vector jar el vector de diseño */ problema. jovector(vectordis); /* incrementar el contador de iteraciones*/ step++; } while (error > errordeseado && step < iteracionesmaximas); /*... hasta que el error sea menor o igual que el deseado o */ /* se alcance el número de iteraciones pasado como argumento */ problema. jovector(vectordis);

1.6. ESTRUCTURAS DE PROGRAMACIÓN 23 Sentencia return Una forma de salir de un bucle es utilizar la sentencia return. Esta sentencia sale también de un método o de una función. En el caso de que la función devuelva alguna variable, este valor se deberá poner a continuación del return. public double devuelveerrorminimo() {return errorminimo; } Bloque try{...} catch{...} nally{...} Java incorpora enelpropio lenguaje la gestión de errores. El mejor momento para detectar los errores es durante la compilación. Sin embargo prácticamente sólo los errores de sintaxis son detectados en esta operación. El resto de problemas surgen durante la ejecución de los programas. En el lenguaje Java, una Exception es un cierto tipo de error o una condición anormal que se ha producido durante la ejecución de un programa. Algunas excepciones son fatales y provocan que se deba nalizar la ejecución del programa. En este caso conviene terminar ordenadamente y dar un mensaje explicando el tipo de error que se ha producido. Otras excepciones, como por ejemplo no encontrar un chero en el que hay que leer o escribir algo, pueden ser recuperables. En este caso el programa debe dar al usuario la oportunidad de corregir el error (dando por ejemplo un nuevo path del chero no encontrado). Los errores se representan mediante clases derivadas de la clase Throwable, pero los que tiene que chequear un programador derivan de Exception (java.lang.exception que a su vez deriva de Throwable). Existen algunos tipos de excepciones que Java obliga a tener en cuenta. Esto se hace mediante el uso de bloques try,catch y nally. El código dentro del bloque try está vigilado : Si se produce una situación anormal y se lanza como consecuencia una excepción, el control pasa al bloque catch que se hace cargo de la situación y decide lo que hay que hacer. Se pueden incluir tantos bloques catch como se desee, cada uno de los cuales tratará un tipo de excepción. Finalmente, si está presente, se ejecuta el bloque nally,