Informe Proyecto Final
Upcoming SlideShare
Loading in...5
×
 

Informe Proyecto Final

on

  • 3,920 views

Este informe contiene la información de teoría y aplicación de losm diferentes conceptos de java, que fueron necesarios para realizar el proyecto

Este informe contiene la información de teoría y aplicación de losm diferentes conceptos de java, que fueron necesarios para realizar el proyecto

Statistics

Views

Total Views
3,920
Views on SlideShare
3,920
Embed Views
0

Actions

Likes
0
Downloads
61
Comments
0

0 Embeds 0

No embeds

Accessibility

Categories

Upload Details

Uploaded via as Microsoft Word

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

Informe Proyecto Final Informe Proyecto Final Document Transcript

  • ESCUELA POLITÉCNICA NACIONAL INGENIERÍA EN ELECTRÓNICA Y REDES DE INFORMACIÓN TEMA DE PROYECTO MUSICA INTEGRANTES: Aguayo César Cárdenas Cristel Suasnavas Carmen PROFESOR: ING. RODRIGO CHANCUSIG
  • INDICE 1. TEMA........... ........... ........... ........... ................................................................................................................... 2 2. OBJETIVOS……………………………………………………………………………………………………...2 3.ALCANCE ……………………………………………………………………………………………………….2 4.SUSTENTACIÓN TEÓRICA……………………………………………………………………………….……3 Eclipse…………………………………………………………………………………………..…..…….3 Diagrama UML……………………………………………………………………………………….…..4 Diagrama de Clases ………………………………………………………………………..…...5 Algunos Elementos Utilizados ………………………………………………………………..…………9 Interfaces …………………………………………………………………………..…………10 Variables y Métodos estáticos …………………………………………………….…………11 Integer …………………………………………………………………………………………..………14 Excepciones ………………………………………………………………………………...…………..15 Actualización de información…………………………………………………….……………………..23 Archivos de texto…………………………………………………………………………………..……24 5.CONCLUSIONES Y RECOMENDACIONES ………………………………………………….…….…….…25 6.REFERENCIAS Y BIBLIOGRAFÍA……………………………………………………………………...….…26 ESCUELA POLITÉCNICA NACIONAL INGENIERÍA ELECTRÓNICA Y REDES DE INFORMACIÓN PROGRAMACIÓN ORIENTADA A OBJETOS. PROYECTO FINAL TEMA: MUSICA OBJETIVO.- Implementar un pequeño sistema que permita: • Ingresar información • Búsqueda de información 2
  • • Modificar información • Borrar información • Almacenar en un archivo de texto. ALCANCE: El presente trabajo cuanta con diferentes opciones para el manejo de información de Música Bailable Codigo de la cancion.- dato de tipo int, código de la canción que queremos ingresar Nombre de la canción.- dato de tipo int, nombre de la canción ingresada Autor de canción.- dato de tipo char, autor de la canción Ano de Lanzamiento- dato de tipo int, Año de lanzamiento de la canción Tipo de Canción.- dato de tipo char, Que clase de canción es Tiempo de duración de la canción.- dato de tipo char, tiempo de duración de la canción Los métodos de todas las subclases son heredadas de la súper clase Música Ingresar( ); Modificar( ); Eliminar( ); Ingresar( ); Permite ingresar nuevas canciones del tipo: Código, Nombre. Autor , Año, Tipo, Duración Eliminar( ); Permite observar y eliminar las canciones que se han creado, mediante un ID 3
  • SUSTENTACIÓN TEÓRICA. ECLIPSE Eclipse es un entorno de desarrollo integrado de código abierto multiplataforma para desarrollar lo que el proyecto llama "Aplicaciones de Cliente Enriquecido", opuesto a las aplicaciones "Cliente-liviano" basadas en navegadores. Esta plataforma, típicamente ha sido usada para desarrollar entornos de desarrollo integrados (del inglés IDE), como el IDE de Java llamado Java Development Toolkit (JDT) y el compilador (ECJ) que se entrega como parte de Eclipse (y que son usados también para desarrollar el mismo Eclipse). Sin embargo, también se puede usar para otros tipos de aplicaciones cliente, como BitTorrent Azureus. Arquitectura La base para Eclipse es la Plataforma de cliente enriquecido (del Inglés Rich Client Platform RCP). Los siguientes componentes constituyen la plataforma de cliente enriquecido: • Plataforma principal - inicio de Eclipse, ejecución de plugins • OSGi - una plataforma para bundling estándar. • El Standard Widget Toolkit (SWT) - Un widget toolkit portable. • JFace - manejo de archivos, manejo de texto, editores de texto • El Workbench de Eclipse - vistas, editores, perspectivas, asistentes Los widgets de Eclipse están implementados por un herramienta de widget para Java llamada SWT, a diferencia de la mayoría de las aplicaciones Java, que usan las opciones estándar Abstract Window Toolkit (AWT) o Swing. La interfaz de usuario de Eclipse también tiene una capa GUI intermedia llamada JFace, la cual simplifica la construcción de aplicaciones basada en SWT. En cuanto a las aplicaciones clientes, eclipse provee al programador con frameworks muy ricos para el desarrollo de aplicaciones gráficas, definición y manipulación de modelos de software, aplicaciones web, etc. Por ejemplo, GEF (Graphic Editing Framework - Framework para la edición gráfica) es un plugin de Eclipse para el desarrollo de editores visuales que pueden ir desde procesadores de texto wysiwyg hasta editores de diagramas UML, interfaces gráficas para el usuario (GUI), etc. Dado que los editores realizados con GEF "viven" dentro de Eclipse, además de poder ser usados conjuntamente con otros plugins, hacen uso de su interfaz gráfica personalizable y profesional. 4
  • Características La versión actual de Eclipse dispone de las siguientes características: • Editor de texto • Resaltado de sintaxis • Compilación en tiempo real • Pruebas unitarias con JUnit • Control de versiones con CVS • Integración con Ant • Asistentes (wizards): para creación de proyectos, clases, tests, etc. • Refactorización Asimismo, a través de "plugins" libremente disponibles es posible añadir: • Control de versiones con Subversion. • Integración con Hibernate. DIAGRAMA UML Lenguaje Unificado de Modelado (UML, por sus siglas en inglés, Unified Modeling Language) es el lenguaje de modelado de sistemas de software más conocido y utilizado en la actualidad; está respaldado por el OMG (Object Management Group). Es un lenguaje gráfico para visualizar, especificar, construir y documentar un sistema. UML ofrece un estándar para describir un "plano" del sistema (modelo), incluyendo aspectos conceptuales tales como procesos de negocio y funciones del sistema, y aspectos concretos como expresiones de lenguajes de programación, esquemas de bases de datos y componentes reutilizables. Es importante resaltar que UML es un "lenguaje" para especificar y no para describir métodos o procesos. Se utiliza para definir un sistema, para detallar los artefactos en el sistema y para documentar y construir. En otras palabras, es el lenguaje en el que está descrito el modelo. Se puede aplicar en el desarrollo de software entregando gran variedad de formas para dar soporte a una metodología de desarrollo de software (tal como el Proceso Unificado Racional o RUP), pero no especifica en sí mismo qué metodología o proceso usar. 5
  • UML no puede compararse con la programación estructurada, pues UML significa (Lengua de Modelación Unificada), no es programación, solo se diagrama la realidad de una utilización en un requerimiento. Mientras que, programación estructurada, es una forma de programar como lo es la orientación a objetos, sin embargo, la orientación a objetos viene siendo un complemento perfecto de UML, pero no por eso se toma UML sólo para lenguajes orientados a objetos UML cuenta con varios tipos de diagramas, los cuales muestran diferentes aspectos de las entidades representadas. Modelo de Clases Utilizando Estándar UML. Un diagrama de clases sirve para visualizar las relaciones entre las clases que involucran el sistema, las cuales pueden ser asociativas, de herencia, de uso y de contenido. Un diagrama de clases esta compuesto por los siguientes elementos: • Clase: atributos, métodos y visibilidad. • Relaciones: Herencia, Composición, Agregación, Asociación y Uso. ELEMENTOS. • Clase. Es la unidad básica que encapsula toda la información de un Objeto (un objeto es una instancia de una clase). A través de ella se puede modelar el entorno en estudio (una Casa, un Auto, una Cuenta Corriente, etc.). En UML, una clase es representada por un rectángulo que posee tres divisiones: En donde: o Superior: Contiene el nombre de la Clase. o Intermedio: Contiene los atributos (o variables de instancia) que caracterizan a la Clase (pueden ser private, protected o public). 6
  • o Inferior: Contiene los métodos u operaciones, los cuales son la forma como interactúa el objeto con su entorno (dependiendo de la visibilidad: private, protected o public). Ejemplo: Una Cuenta Corriente que posee como característica: o Balance Puede realizar las operaciones de: o Depositar o Girar o y Balance El diseño asociado es: ATRIBUTOS Y MÉTODOS. Atributos. Los atributos o características de una Clase pueden ser de tres tipos, los que definen el grado de comunicación y visibilidad de ellos con el entorno, estos son: • public (+, ): Indica que el atributo será visible tanto dentro como fuera de la clase, es decir, es accesible desde todos lados. • private (-, ): Indica que el atributo sólo será accesible desde dentro de la clase (sólo sus métodos lo pueden accesar). • protected (#, ): Indica que el atributo no será accesible desde fuera de la clase, pero si podrá ser accesado por métodos de la clase además de las subclases que se deriven (ver herencia). Métodos. Los métodos u operaciones de una clase son la forma en como ésta interactúa con su entorno, éstos pueden tener las características: 7
  •  public (+, ): Indica que el método será visible tanto dentro como fuera de la clase, es decir, es accesible desde todos lados.  private (-, ): Indica que el método sólo será accesible desde dentro de la clase (sólo otros métodos de la clase lo pueden accesar).  protected (#, ): Indica que el método no será accesible desde fuera de la clase, pero si podrá ser accesado por métodos de la clase además de métodos de las subclases que se deriven (ver herencia). RELACIONES ENTRE CLASES. Ya definido el concepto de Clase, es necesario entender como se pueden interrelacionar dos o más clases (cada uno con características y objetivos diferentes). Antes es necesario explicar el concepto de cardinalidad de relaciones: En UML, la cardinalidad de las relaciones indica el grado y nivel de dependencia, se anotan en cada extremo de la relación y éstas pueden ser: • uno o muchos: 1..* (1..n) • 0 o muchos: 0..* (0..n) • número fijo: m (m denota el número). Herencia (Especialización/Generalización): Indica que una subclase hereda los métodos y atributos especificados por una Super Clase, por ende la Subclase además de poseer sus propios métodos y atributos, poseerá las características y atributos visibles de la Super Clase (public y protected), ejemplo: Agregación: Para modelar objetos complejos, n bastan los tipos de datos básicos que proveen los lenguajes: enteros, reales y secuencias de caracteres. Cuando se requiere componer objetos que son instancias de clases definidas por el desarrollador de la aplicación, tenemos dos posibilidades:  Por Valor: Es un tipo de relación estática, en donde el tiempo de vida del objeto incluido esta condicionado por el tiempo de vida del que lo incluye. Este tipo de relación es comúnmente llamada Composición (el Objeto base se construye a partir del objeto incluido, es decir, es "parte/todo").  Por Referencia: Es un tipo de relación dinámica, en donde el tiempo de vida del objeto incluido es independiente del que lo incluye. Este tipo de relación es comúnmente llamada Agregación (el objeto base utiliza al incluido para su funcionamiento). Asociación: 8
  • La relación entre clases conocida como Asociación, permite asociar objetos que colaboran entre si. Cabe destacar que no es una relación fuerte, es decir, el tiempo de vida de un objeto no depende del otro. Ejemplo: Un cliente puede tener asociadas muchas Ordenes de Compra, en cambio una orden de compra solo puede tener asociado un cliente. Dependencia o Instanciación (uso): Representa un tipo de relación muy particular, en la que una clase es instanciada (su instanciación es dependiente de otro objeto/clase). Se denota por una flecha punteada. El uso más particular de este tipo de relación es para denotar la dependencia que tiene una clase de otra, como por ejemplo una aplicación grafica que instancia una ventana (la creación del Objeto Ventana esta condicionado a la instanciación proveniente desde el objeto Aplicación): Cabe destacar que el objeto creado (en este caso la Ventana gráfica) no se almacena dentro del objeto que lo crea (en este caso la Aplicación). CASOS PARTICULARES. Clase Abstracta. Una clase abstracta se denota con el nombre de la clase y de los métodos con letra "itálica". Esto indica que la clase definida no puede ser instanciada pues posee métodos abstractos (aún no han sido definidos, es decir, sin implementación). La única forma de utilizarla es definiendo subclases, que implementan los métodos abstractos definidos. 9
  • Clase parametrizada. Una clase parametrizada se denota con un sub-cuadro en el extremo superior de la clase, en donde se especifican los parámetros que deben ser pasados a la clase para que esta pueda ser instanciada. El ejemplo más típico es el caso de un Diccionario en donde una llave o palabra tiene asociado un significado, pero en este caso las llaves y elementos pueden ser genéricos. La genericidad puede venir dada de un Template (como en el caso de C++) o bien de alguna estructura predefinida (especialización a través de clases). En el ejemplo no se especificaron los atributos del Diccionario, pues ellos dependerán exclusivamente de la implementación que se le quiera dar. ALGUNOS CONCEPTOS UTILIZADOS EN EL PROGRAMA Después de haber visto los conceptos más importantes sobre la clase objeto, debemos incursionarnos en los formatos que son indispensables en la elaboración de clases y subclases para manejar los diferentes métodos aplicados en la realización de este trabajo. A continuación vamos a puntualizar los más destacados e importantes dentro del código fuente, pues las demás atributos se lo toma como aprendidos en clase y sobrentendidos en el transcurso del curso. • This y Super Al acceder a variables de instancia de una clase, la palabra clave this hace referencia a los miembros de la propia clase. Volviendo al ejemplo de MiClase, se puede añadir otro constructor de la forma siguiente: public class MiClase { int i; public MiClase() { i = 10; } // Este constructor establece el valor de i public MiClase( int valor ) { this.i = valor; // i = valor } public void Suma_a_i( int j ) { i = i + j; } } 10
  • Aquí this.i se refiere al entero i en la clase MiClase . Si se necesita llamar al método padre dentro de una clase que ha reemplazado ese método, se puede hacer referencia al método padre con la palabra clave super : import MiClase; public class MiNuevaClase extends MiClase { public void Suma_a_i( int j ) { i = i + ( j/2 ); super.Suma_a_i( j ); } } • Herencia La Herencia es el mecanismo por el que se crean nuevos objetos definidos en términos de objetos ya existentes. Por ejemplo, si se tiene la clase Ave, se puede crear la subclase Pato, que es una especialización de Ave. class Pato extends Ave { int numero_de_patas; } La palabra clave extends se usa para generar una subclase (especialización) de un objeto. Una Pato es una subclase de Ave. Cualquier cosa que contenga la definición de Ave será copiada a la clase Pato, además, en Pato se pueden definir sus propios métodos y variables de instancia. Se dice que Pato deriva o hereda de Ave. Además, se pueden sustituir los métodos proporcionados por la clase base. Utilizando nuestro anterior ejemplo de MiClase, aquí hay un ejemplo de una clase derivada sustituyendo a la función Suma_a_i() : import MiClase; public class MiNuevaClase extends MiClase { public void Suma_a_i( int j ) { i = i + ( j/2 ); } } Ahora cuando se crea una instancia de MiNuevaClase, el valor de i también se inicializa a 10, pero la llamada al método Suma_a_i() produce un resultado diferente: MiNuevaClase mnc; mnc = new MiNuevaClase(); mnc.Suma_a_i( 10 ); • Interfaces Los métodos abstractos son útiles cuando se quiere que cada implementación de la clase parezca y funcione igual, pero necesita que se cree una nueva clase para utilizar los métodos abstractos. Los interfaces proporcionan un mecanismo para abstraer los métodos a un nivel superior. 11
  • Un interface contiene una colección de métodos que se implementan en otro lugar. Los métodos de una clase son public , static y final . La principal diferencia entre interface y abstract es que un interface proporciona un mecanismo de encapsulación de los protocolos de los métodos sin forzar al usuario a utilizar la herencia. Por ejemplo: public interface VideoClip { // comienza la reproduccion del video void play(); // reproduce el clip en un bucle void bucle(); // detiene la reproduccion void stop(); } Las clases que quieran utilizar el interface VideoClip utilizarán la palabra implements y proporcionarán el código necesario para implementar los métodos que se han definido para el interface: class MiClase implements VideoClip { void play() { <código> } void bucle() { <código> } void stop() { <código> } Al utilizar implements para el interface es como si se hiciese una acción de copiar-y- pegar del código del interface, con lo cual no se hereda nada, solamente se pueden usar los métodos. • Variables y Métodos Estáticos En un momento determinado se puede querer crear una clase en la que el valor de una variable de instancia sea el mismo (y de hecho sea la misma variable) para todos los objetos instanciados a partir de esa clase. Es decir, que exista una única copia de la variable de instancia. Se usará para ello la palabra clave static . class Documento extends Pagina { static int version = 10; } El valor de la variable version será el mismo para cualquier objeto instanciado de la clase Documento . Siempre que un objeto instanciado de Documento cambie la variable version , ésta cambiará para todos los objetos. De la misma forma se puede declarar un método como estático, lo que evita que el método pueda acceder a las variables de instancia no estáticas: 12
  • class Documento extends Pagina { static int version = 10; int numero_de_capitulos; static void annade_un_capitulo() { numero_de_capitulos++; // esto no funciona } static void modifica_version( int i ) { version++; // esto si funciona } } La modificación de la variable numero_de_capitulos no funciona porque se está violando una de las reglas de acceso al intentar acceder desde un método estático a una variable no estática. Todas las clases que se derivan, cuando se declaran estáticas, comparten la misma página de variables; es decir, todos los objetos que se generen comparten la misma zona de memoria. Las funciones estáticas se usan para acceder solamente a variables estáticas. class UnaClase { int var; UnaClase() { var = 5; } UnaFuncion() { var += 5; } } En el código anterior, si se llama a la función UnaFuncion a través de un puntero a función, no se podría acceder a var , porque al utilizar un puntero a función no se pasa implícitamente el puntero al propio objeto ( this ). Sin embargo, sí se podría acceder a var si fuese estática, porque siempre estaría en la misma posición de memoria para todos los objetos que se creasen de UnaClase. • La clase StringBuffer Java posee gran capacidad para el manejo de cadenas dentro de sus clases String y StringBuffer . Un objeto String representa una cadena alfanumérica de un valor constante que no puede ser cambiada después de haber sido creada. Un objeto StringBuffer representa una cadena cuyo tamaño puede variar. La clase StringBuffer dispone de muchos métodos para modificar el contenido de los objetos StringBuffer. Si el contenido de una cadena va a ser modificado en un programa, habrá que sacrificar el uso de objetos String en beneficio de StringBuffer, que aunque consumen más recursos del sistema, permiten ese tipo de manipulaciones. Al estar la mayoría de las características de los StringBuffers basadas en su tamaño variable, se necesita un nuevo método de creación: StringBuffer(); StringBuffer( int len ); StringBuffer( String str ); 13
  • Se puede crear un StringBuffer vacío de cualquier longitud y también se puede utilizar un String como punto de partida para un StringBuffer. StringBuffer Dos = new StringBuffer( 20 ); StringBuffer Uno = new StringBuffer( "Hola Mundo" ); Cambio de Tamaño El cambio de tamaño de un StringBuffer necesita varias funciones específicas para manipular el tamaño de las cadenas: int length(); char charAt( int index ); void getChars( int srcBegin,int srcEnd,char dst[],int dstBegin ); String toString(); void setLength( int newlength ); void setCharAt( int index,char ch ); int capacity(); void ensureCapacity( int minimum ); void copyWhenShared(); Obervar que una de las funciones devuelve una cadena constante normal de tipo String. Este objeto se puede usar con cualquier función String, como por ejemplo, en las funciones de comparación. Modificación del Contenido Para cambiar el contenido de un StringBuffer, se pueden utilizar dos métodos: append() e insert() . En el ejemplo CadAppend.java , vemos el uso de estos dos métodos: class CadAppend { public static void main( String args[] ) { StringBuffer str = new StringBuffer( "Hola" ); str.append( " Mundo" ); System.out.println( str ); } } Operadores de Concatenación Hay que recordar que los operadores " + " y " += " también se pueden aplicar a cadenas. Ambos realizan una concatenación y están implementados con objetos StringBuffer. Por ejemplo, la sentencia: String s = "¿Qué" + " tal ?"; es interpretada por el compilador como: String s = new StringBuffer().append( "¿Qué" ).append( " tal ?" ).toString(); y se marcaría el StringBuffer para borrarlo ya que el contenido pasa al objeto String. 14
  • • La clase Integer Cada tipo numérico tiene su propia clase de objetos. Así el tipo int tiene el objeto Integer . De la misma forma que con la clase Character , se han codificado muchas funciones útiles dentro de los métodos de la clase Integer . Declaraciones La primera sentencia creará una variable int y la segunda un objeto Integer: Integer.MIN_VALUE; Integer.MAX_VALUE; Valores de Integer Integer.MIN_VALUE; Integer.MAX_VALUE; Métodos de Integer String Integer.toString( int i,int base ); String Integer.toString( int i ); int I.parseInt( String s,int base ); int I.parseInt( String s ); Integer Integer.valueOf( String s,int base ); Integer Integer.valueOf( String s ); int I.intValue(); long I.longValue(); float I.floatValue(); double I.doubleValue(); String I.toString(); int I.hashCode(); boolean I.equals( Object obj ); Los valores boolean también tienen su tipo asociado Boolean , aunque en este caso hay menos métodos implementados que para el resto de las clases numéricas. Declaraciones La primera sentencia creará una variable boolean y la segunda un objeto Boolean: boolean b; Boolean B; Valores de Boolean Boolean.TRUE; Boolean.FALSE; Métodos de Boolean boolean B.booleanValue(); String B.toString(); boolean B.equals( Object obj ); 15
  • • Excepciones try-catch-throw try { sentencias; } catch( Exception ) { sentencias; } Java implementa excepciones para facilitar la construcción de código robusto. Cuando ocurre un error en un programa, el código que encuentra el error lanza una excepción, que se puede capturar y recuperarse de ella. Java proporciona muchas excepciones predefinidas. El manejo y control de excepciones es tan importante en Java que debe ser tratado en un capítulo aparte, aunque sirva este punto como mención previa de su existencia. • Control General del Flujo break break [etiqueta]; La sentencia break puede utilizarse en una sentencia switch o en un bucle. Cuando se encuentra en una sentencia switch, break hace que el control del flujo del programa pase a la siguiente sentencia que se encuentre fuera del entorno del switch. Si se encuentra en un bucle, hace que el flujo de ejecución del programa deje el ámbito del bucle y pase a la siguiente sentencia que venga a continuación del bucle. Java incorpora la posibilidad de etiquetar la sentencia break, de forma que el control pasa a sentencias que no se encuentran inmediatamente después de la sentencia switch o del bucle, es decir, saltará a la sentencia en donde se encuentre situada la etiqueta. La sintaxis de una sentencia etiquetada es la siguiente: etiqueta: sentencia; continue continue [etiqueta]; La sentencia continue no se puede utilizar en una sentencia switch, sino solamente en bucles. Cuando se encuentra esta sentencia en el discurrir normal de un programa Java, la iteración en que se encuentre el bucle finaliza y se inicia la siguiente. Java permite el uso de etiquetas en la sentencia continue, de forma que el funcionamiento normal se ve alterado y el salto en la ejecución del flujo del programa se realizará a la sentencia en la que se encuentra colocada la etiqueta. Por ejemplo, al encontrarse con bucles anidados, se pueden utilizar etiquetas para poder salir de ellos: 16
  • uno: for( ) { dos: for( ) { continue; // seguiría en el bucle interno continue uno; // seguiría en el bucle principal break uno; // se saldría del bucle principal } } Hay autores que sugieren que el uso de sentencias break y continue etiquetadas proporciona una alternativa al infame goto (que C++ todavía soporta, pero Java no, aunque reserva la palabra). Quizá se así, pero el entorno de uso de las sentencias etiquetadas break y continue es mucho más restrictivo que un goto. Concretamente, parece que un break o continue con etiqueta, compila con éxito solamente si la sentencia en que se encuentra colocada la etiqueta es una sentencia a la que se pueda llegar con un break o continue normal. return return expresión; La sentencia return se utiliza para terminar un método o función y opcionalmente devolver un valor al método de llamada. En el código de una función siempre hay que ser consecuentes con la declaración que se haya hecho de ella. Por ejemplo, si se declara una función para que devuelva un entero, es imprescindible colocar un return final para salir de esa función, independientemente de que haya otros en medio del código que también provoquen la salida de la función. En caso de no hacerlo se generará un Warning, y el código Java no se puede compilar con Warnings. int func() { if( a == 0 ) return 1; return 0; // es imprescindible porque se retorna un entero } Si el valor a retornar es void, se puede omitir ese valor de retorno, con lo que la sintaxis se queda en un sencillo: return; y se usaría simplemente para finalizar el método o función en que se encuentra, y devolver el control al método o función de llamada. Esta sentencia se puede utilizar para mostrar uno de los problemas para los que Java está destinado a corregir. En C++ se permite que los valores de retorno de una función o método puedan ser por valor o por referencia. Cuando se devuelve un valor por referencia, o un puntero, en C++, hay que asegurarse de que el objeto referenciado continúe existiendo a la terminación del método. Por ejemplo, si se devuelve un puntero o una referencia a una variable local de la función, pueden presentarse problemas, porque esa variable deja de existir tan pronto como finaliza la función. 17
  • El compilador Borland C++ utilizado por el autor para realizar pruebas, no permite que se devuelva una referencia a una variable local, pero sí que permite devolver un puntero a esa variable. El siguiente programa, java409.cpp, es muy simple e ilustra esto. Crea un array en la función principal para modificar la memoria y luego utiliza el puntero devuelto para presentar el contenido de la memoria a la que apunta ese puntero. El programa presenta en pantalla porquería, porque después de que termine la función, el puntero apunta a una dirección de memoria que ya no es válida para el programa. Sin embargo, compilando la aplicación con GNU C++ y corriendo sobre Linux, el valor que se presenta sí es el correcto. #include <iostream.h> int *test() { // Declara la variable local a la función int variableLocal = 6; // Guarda su dirección en un puntero int *puntero = &variableLocal; // Devuelve el puntero a la variable local return puntero; } void main() { // Recoge el puntero devuelto por la función de test int *punteroMain = test(); // Rellena con cosas la memoria int memArray[5] = { 10,11,12,13,14 }; // Presenta en pantalla el contenido de la zona a que apunta el // puntero cout << "El contenido de la memoria es " << *punteroMain; } Aparentemente en Java, solamente se puede retornar por valor. En el caso de tipos básicos, se devuelve una copia del item retornado. Si no se quiere devolver una copia, siempre está la posibilidad de utilizar las versiones objeto de los tipos básicos. • Manejo de excepciones Vamos a mostrar como se utilizan las excepciones, reconvirtiendo nuestro applet de saludo a partir de la versión iterativa de HolaIte.java : import java.awt.*; import java.applet.Applet; public class HolaIte extends Applet { private int i = 0; private String Saludos[] = { "Hola Mundo!", "HOLA Mundo!", "HOLA MUNDO!!" }; public void paint( Graphics g ) { g.drawString( Saludos[i],25,25 ); i++; } } 18
  • Normalmente, un programa termina con un mensaje de error cuando se lanza una excepción. Sin embargo, Java tiene mecanismos para excepciones que permiten ver qué excepción se ha producido e intentar recuperarse de ella. Vamos a reescribir el método paint() de nuestra versión iterativa del saludo: La palabra clave finally define un bloque de código que se quiere que sea ejecutado siempre, de acuerdo a si se capturó la excepción o no. En el ejemplo anterior, la salida en la consola, con i=4 sería: • Capturar Excepciones Las excepciones lanzadas por un método que pueda hacerlo deben recoger en bloque try/catch o try/finally . try Es el bloque de código donde se prevé que se genere una excepción. Es como si dijésemos "intenta estas sentencias y mira a ver si se produce una excepción". El bloque try tiene que ir seguido, al menos, por una cláusula catch o una cláusula finally catch Es el código que se ejecuta cuando se produce la excepción. Es como si dijésemos "controlo cualquier excepción que coincida con mi argumento". En este bloque tendremos que asegurarnos de colocar código que no genere excepciones. Se pueden colocar sentencias catch sucesivas, cada una controlando una excepción diferente. No debería intentarse capturar todas las excepciones con una sola cláusula, como esta: catch( Excepcion e ) { ... Esto representaría un uso demasiado general, podrían llegar muchas más excepciones de las esperadas. En este caso es mejor dejar que la excepción se propague hacia arriba y dar un mensaje de error al usuario. Se pueden controlar grupos de excepciones, es decir, que se pueden controlar, a través del argumento, excepciones semejantes que aparezcan en el programa. Si hay alguno que coincida, se ejecuta el bloque. El operador instanceof se utiliza para identificar exactamente cual ha sido la identidad de la excepción. finally Es el bloque de código que se ejecuta siempre, haya o no excepción. Hay una cierta controversia entre su utilidad, pero, por ejemplo, podría servir para hacer un log o un seguimiento de lo que está pasando, porque como se ejecuta siempre puede dejarnos grabado si se producen excepciones y nos hemos recuperado de ellas o no. 19
  • • Excepciones Predefinidas Las excepciones predefinidas y su jerarquía de clases es la que se muestra en la figura: Los nombres de las excepciones indican la condición de error que representan. Las siguientes son las excepciones predefinidas más frecuentes que se pueden encontrar: ArithmeticException Las excepciones aritméticas son típicamente el resultado de una división por 0: int i = 12 / 0; NullPointerException Se produce cuando se intenta acceder a una variable o método antes de ser definido: class Hola extends Applet { Image img; paint( Graphics g ) { g.drawImage( img,25,25,this ); } } 20
  • IncompatibleClassChangeException El intento de cambiar una clase afectada por referencias en otros objetos, específicamente cuando esos objetos todavía no han sido recompilados. ClassCastException El intento de convertir un objeto a otra clase que no es válida. y = (Prueba)x; // donde x no es de tipo Prueba NegativeArraySizeException Puede ocurrir si hay un error aritmético al intentar cambiar el tamaño de un array. OutOfMemoryException ¡No debería producirse nunca! El intento de crear un objeto con el operador new ha fallado por falta de memoria. Y siempre tendría que haber memoria suficiente porque el garbage collector se encarga de proporcionarla al ir liberando objetos que no se usan y devolviendo memoria al sistema. NoClassDefFoundException Se referenció una clase que el sistema es incapaz de encontrar. ArrayIndexOutOfBoundsException Es la excepción que más frecuentemente se produce. Se genera al intentar acceder a un elemento de un array más allá de los límites definidos inicialmente para ese array. UnsatisfiedLinkException Se hizo el intento de acceder a un método nativo que no existe. Aquí no existe un método a.kk class A { native void kk(); } InternalException Este error se reserva para eventos que no deberían ocurrir. Por definición, el usuario nunca debería ver este error y esta excepción no debería lanzarse. • Ficheros Todos los lenguajes de programación tienen alguna forma de interactuar con los sistemas de ficheros locales; Java no es una excepción. 21
  • Cuando se desarrollan applets para utilizar en red, hay que tener en cuenta que la entrada/salida directa a fichero es una violación de seguridad de acceso. Muchos usuarios configurarán sus navegadores para permitir el acceso al sistema de ficheros, pero otros no. Antes de realizar acciones sobre un fichero, necesitamos un poco de información sobre ese fichero. La clase File proporciona muchas utilidades relacionadas con ficheros y con la obtención de información básica sobre esos ficheros. Creación de un objeto File Para crear un objeto File nuevo, se puede utilizar cualquiera de los tres constructores siguientes: File miFichero; miFichero = new File( "/etc/kk" ); o miFichero = new File( "/etc","kk" ); o File miDirectorio = new File( "/etc" ); miFichero = new File( miDirectorio,"kk" ); El constructor utilizado depende a menudo de otros objetos File necesarios para el acceso. Por ejemplo, si sólo se utiliza un fichero en la aplicación, el primer constructor es el mejor. Si en cambio, se utilizan muchos ficheros desde un mismo directorio, el segundo o tercer constructor serán más cómodos. Y si el directorio o el fichero es una variable, el segundo constructor será el más útil. • Ficheros de Acceso Aleatorio A menudo, no se desea leer un fichero de principio a fin; sino acceder al fichero como una base de datos, donde se salta de un registro a otro; cada uno en diferentes partes del fichero. Java proporciona una clase RandomAccessFile para este tipo de entrada/salida. Creación de un Fichero de Acceso Aleatorio Hay dos posibilidades para abrir un fichero de acceso aleatorio: Con el nombre del fichero: miRAFile = new RandomAccessFile( String nombre,String modo ); Con un objeto File: miRAFile = new RandomAccessFile( File fichero,String modo ); El argumento modo determina si se tiene acceso de sólo lectura ( r ) o de lectura/escritura ( r/w ). Por ejemplo, se puede abrir un fichero de una base de datos para actualización: RandomAccessFile miRAFile; miRAFile = new RandomAccessFile( "/tmp/kk.dbf","rw" ); 22
  • Acceso a la Información Los objetos RandomAccessFile esperan información de lectura/escritura de la misma manera que los objetos DataInput/DataOutput. Se tiene acceso a todas las operaciones read() y write() de las clases DataInputStream y DataOutputStream. También se tienen muchos métodos para moverse dentro de un fichero: long getFilePointer(); Devuelve la posición actual del puntero del fichero void seek( long pos ); Coloca el puntero del fichero en una posición determinada. La posición se da como un desplazamiento en bytes desde el comienzo del fichero. La posición 0 marca el comienzo de ese fichero. long length(); Devuelve la longitud del fichero. La posición length() marca el final de ese fichero. Actualización de Información Se pueden utilizar ficheros de acceso aleatorio para añadir información a ficheros existentes: Listas Hay varias implementaciones de List, siendo ArrayList la que debería ser la elección por defecto, en caso de no tener que utilizar las características que proporcionan las demás implementaciones. ArrayList Es una Lista volcada en un Array. Se debe utilizar en lugar de Vector como almacenamiento de objetos de propósito general. Permite un acceso aleatorio muy rápido a los elementos, pero realiza con bastante lentitud las operaciones de insertado y borrado de elementos en medio de la Lista. Se puede utilizar un ListIterator para moverse hacia atrás y hacia delante en la Lista, pero no para insertar y eliminar elementos. Sets Set tiene exactamente el mismo interfaz que Collection, y no hay ninguna funcionalidad extra, como en el caso de las Listas. Un Set es exactamente una Colección, pero tiene utilizada en un entorno determinado, que es ideal para el uso de la herencia o el polimorfismo. Un Set sólo permite que exista una instancia de cada objeto. 23
  • A continuación se muestran las diferentes implementaciones de Set, debiendo utilizarse HashSet en general, a no ser que se necesiten las características proporcionadas por alguna de las otras implementaciones. Set (interfaz) Cada elemento que se añada a un Set debe ser único, ya que el otro caso no se añadirá porque el Set no permite almacenar elementos duplicados. Los elementos incorporados al Conjunto deben tener definido el método equals(), en aras de establecer comparaciones para eliminar duplicados. Set tiene el mismo interfaz que Collection, y no garantiza el orden en que se encuentren almacenados los objetos que contenga. ARCHIVOS DE TEXTO Si se desea procesar datos de un archivo existente, se debe: 1. Abrir el archivo 2. Leer o introducir los datos en las variables, un elemento a la vez 3. Cerrar el archivo cuando se termine de trabajar con él Para transferir algunos datos de ciertas variables a un archivo, se debe: 1. Abrir el archivo 2. Extraer o escribir los elementos en la secuencia requerida 3. Cerrar el archivo cuando se termine de trabajar con él Al leer un archivo, todo lo que puede hacerse es leer el siguiente elemento. Si, por ejemplo, quisiéramos examinar el último elemento, tendríamos que codificar un ciclo para leer cada uno de los elementos en turno, hasta llegar al elemento requerido. Para muchas tareas, es conveniente visualizar un archivo como una serie de líneas de texto, cada una compuesta por un número de caracteres y que termina con el carácter de fin de línea. Un beneficio de esta forma de trabajo es la facilidad de transferir archivos entre aplicaciones. Así se podría crear un archivo ejecutando un programa en Java y después cargarlo en un procesador de palabras, editor de texto o correo electrónico. Las clases de flujo están organizadas de la siguiente forma: Reader BufferedReader InputStreamReader FileReader Writer PrintWriter FileWriter 24
  • Para procesar archivos se utilizan las clases BufferedReader y PrintWriter para leer y escribir líneas de texto, y para la entrada que no provenga de archivos (desde el teclado y páginas Web) también se utiliza InputSreamReader. Los programas que utilizan archivos deben contener la instrucción: import java.io.*; "Búfer" significa que, el software lee un gran trozo de datos del dispositivo de almacenamiento externo y lo guarda en la RAM, de tal forma que invocaciones sucesivas de los métodos que necesitan leer una pequeña cantidad de datos del dispositivo de almacenamiento de archivos puedan obtener rápidamente los datos de la RAM. Por lo tanto, un búfer actúa como un amortiguador entre el dispositivo de almacenamiento y el programa. La clase File Esta clase ofrece la capacidad de manipular archivos y directorios en general. No se utiliza para tener acceso a los datos dentro de los archivos. Se necesita utilizar la instrucción: import java.io.*; La mayoría de los sistemas operativos ofrecen una estructura jerárquica con una ruta para avanzar a través de la misma, cuya forma es: d:estructuraDeDatosJavaArchivosInventario.java Ésta es una ruta estilo Windows que utiliza '' como separador. En un sistema UNIX se utiliza como separador '/'. Si usted necesita escribir software para manipular rutas y que funcione en cualquier sistema puede averiguar cúal es el separador de archivos haciendo referencia a la constante de la cadena File.separator. La ruta mostrada anteriormente es absoluta, empieza desde la parte superior del directorio y lo lleva hasta el archivo. No obstante, a veces esto es irrelevante: sólo necesitamos tratar con rutas que sean relativas al directorio actual. Por ejemplo, si nos encontramos en el directorio Java, entonces la ruta de Inventario.java sería ArchivosInventario.java. Inicialmente debemos construir una instancia de la clase File proporcionando una cadena. Una vez creada se puede utilizar. Considere la siguiente instrucción: File archivo = new File ("c:estructuraDeDatosJavaArchivosInventario.java"); Como el caracter de escape '' es casualmente el mismo que el separador de archivos en Window, se necesita decir que es simplemente un caracter normal de la cadena en vez de tener un significado especial, por lo que hay que anteponerle un caracter de escape. Así, representa a . 25
  • FUNCIONAMIENTO DEL PROGRAMA El programa principal utiliza todas las características mencionadas en el artículo presente, por lo que el modo de funcionamiento tiene basadas las características antes mencionadas con la interfaz gráfica que permite una interacción con el usuario por medio de ventanas, las mismas que despliegan la información, solicitando al usuario las diferentes opciones que presenta, en cada cuadro de diálogo. Por ejemplo, para el menú principal se tiene: Si se escoge la primera opción, aparecerá otro menú mostrando lo siguiente: 26
  • En este existen las diferentes opciones de un menú general, por lo que si se selecciona por ejemplo la opción 2: aparecerá en orden los menús solicitando la información requerida:  código que identificará a la canción Para el código existe un parámetro que debe cumplirse, de lo contrario no se procederá continuar con el programa y con esto no se almacenará lo que se ingrese; el parámetro es de M[x][n] [n] [n] Donde: x hace referencia a la inicial del tipo de canción inicial, ejemplo: Bailable B; ClásicaC, etc., y n es un dígito entero; por lo que se necesitan 3 dígitos  el nombre de la canción 27
  •  el autor de la canción  año de la canción En este caso se debe cumplir que esté entre los años 1900 hasta el 2010.  Este cuadro es para el género más específico de la canción.  Por último está el tiempo de duración que en este caso está estimado por un valor double. Al terminar podremos escoger la opción de guardado, que es la única manera de almacenar los datos ingresados, escogiendo la opción 5: 28
  • y como demostración que se van almacenando una tras otra las canciones, se puede abrir el documento de texto que es utilizado para este propósito. Como se puede observar se encuentra almacenado al final del archivo, con lo que concluye la explicación de almacenamiento. Para búsqueda es un proceso de lectura que pide parámetros y para borrado igualmente, por lo que hay que tener atención a qué es lo que se quiere buscar o eliminar. CONCLUSIONES Y RECOMENDACIONES: • Eclipse es un entorno de desarrollo integrado de código abierto multiplataforma para desarrollar lo que el proyecto llama "Aplicaciones de Cliente Enriquecido", opuesto a las aplicaciones "Cliente-liviano" basadas en navegadores. • Al realizar este programa, encontramos que existe diferentes tipos para expresar las variables que vayamos a utilizar y a la vez debemos utilizar. • Nos pudimos dar cuenta que el resultado del proyecto debería darnos con un interfaz agradable con el usuario, para que se diferencien los objetivos señalados 29
  • • La visualización de todo el trabajo se basa específicamente en tres niveles de objetos, para poder identificar aun más los comandos utilizados para este propósito. • Algunas especificaciones varían de acuerdo a lo solicitado por el usuario, como son por ejemplo en las clases y tipos de datos a utilizarse para la implementación del mismo. • Para obtener el diagrama UML hay que tener en claro los conceptos de clases, objetos, atributos y métodos. • Hay que tener en cuenta la forma de elaborar los diagramas UML que quisiéramos utilizar. • Los diagramas que utilizamos son elaborado mediante herencias y por eso no encontramos los atributos y métodos. • En nuestro programa utilizamos el manejo de excepciones y archivos. • Una excepción es un evento que ocurre durante la ejecución de un programa y detiene el flujo normal de la secuencia de instrucciones de ese programa; en otras palabras, una excepción es una condición anormal que surge en una secuencia de código durante su ejecución. • Cuando queremos preservar la información es necesario guardarlo en un almacenamiento de tipo no volátil: este es el almacenamiento secundario • . • El SDK de Eclipse incluye las herramientas de desarrollo de Java, ofreciendo un IDE con un compilador de Java interno y un modelo completo de los archivos fuente de Java. Esto permite técnicas avanzadas de refactorización y análisis de código. BIBLIOGRAFIA: Diagrama UML • http://es.wikipedia.org/wiki/Lenguaje_Unificado_de_Modelado • http://tvdi.det.uvigo.es/~avilas/UML/node37.html Eclipse • http://es.wikipedia.org/wiki/Eclipse Herencias • http://www.webtaller.com/manual-java/herencia.php 30
  • • http://www.itapizaco.edu.mx/paginas/JavaTut/froufe/parte4/cap4-7.html#Cap 4_7_4 • http://www.webtaller.com/manual-java/this-super.php • http://www.itapizaco.edu.mx/paginas/JavaTut/froufe/parte4/cap4-7.html#Cap 4_7_4 Interfaces • http://www.webtaller.com/manual-java/this-super.php • http://www.webtaller.com/manual-java/interfaces.php • http://www.itapizaco.edu.mx/paginas/JavaTut/froufe/parte4/cap4-7.html#Cap 4_7_4 Variables y Métodos estáticos • http://es.wikipedia.org/wiki/Lenguaje_Unificado_de_Modelado • http://www.itapizaco.edu.mx/paginas/JavaTut/froufe/parte4/cap4-7.html#Cap 4_7_4 • http://www.scribd.com/doc/6724629/Clase-Archivo-Java Integer • http://www.itapizaco.edu.mx/paginas/JavaTut/froufe/parte4/cap4-7.html#Cap 4_7_4 Excepciones • http://jcca007.iespana.es/codigosjava.htm • http://es.wikipedia.org/wiki/Manejo_de_excepciones • http://www.scribd.com/doc/6724629/Clase-Archivo-Java • http://delfosis.uam.mx/~sgb/Archivos/Excepciones_y_archivos.html Actualización de información • http://www.itapizaco.edu.mx/paginas/JavaTut/froufe/parte4/cap4-7.html#Cap 4_7_4 Archivos de texto • http://www.itapizaco.edu.mx/paginas/JavaTut/froufe/parte4/cap4-7.html#Cap 4_7_4 31