Antologia de Aplicaciones en Java II Patricia Herod

Lic. Patricia Hernández Rodríguez | Docente

Licenciatura En Informática

ITSP APLICACIONES EN JAVA II

Aplicaciones en Java II----Lic. Patricia H

ernández Rodríguez----Lic. En Informática

Contenido TABLA DE IMÁGENES ................................................................................................................................. 3

OBJETIVO GENERAL DEL CURSO ................................................................................................................ 5

TEMARIO .................................................................................................................................................... 6

CRITERIOS DE EVALUACIÓN ....................................................................................................................... 7

FECHAS DE EXAMENES ............................................................................................................................... 7

UNIDAD I. INTRODUCCIÓN A LA PROGRAMACIÓN ORIENTADA A OBJETOS EN JAVA .............................. 8

1.1 Conceptos Generales de la Programación Orientada a Objetos ..................................................... 8

¿QUÉ ES LA PROGRAMACIÓN ORIENTADA A OBJETOS? ................................................................... 8

DATOS SOBRE EL LENGUAJE JAVA. .................................................................................................... 9

1.2 Clases y objetos. .......................................................................................................................... 10

1.3 Abstracción. ....................................................................................................................................... 16

1.4 Encapsulación. ................................................................................................................................... 16

1.5 Herencia. ........................................................................................................................................... 17

1.6 Polimorfismo. .................................................................................................................................... 18

1.7 Destrucción de objetos. .................................................................................................................... 18

1.8 Características de Java. ...................................................................................................................... 20

Java es Simple. ..................................................................................................................................... 20

Java es Orientado a Objetos. ............................................................................................................... 20

Java es Robusto. ................................................................................................................................... 21

Java es Multihilo (Multithreaded). ....................................................................................................... 21

Java posee Arquitectura Neutral. ........................................................................................................ 22

Java es Interpretado. ........................................................................................................................... 22

Java es Distribuido. .............................................................................................................................. 23

Java es Dinámico. ................................................................................................................................. 23

1.9 Ventajas de la POO. ........................................................................................................................... 24

Modelos ............................................................................................................................................... 24

Modularidad ........................................................................................................................................ 24

Extensibilidad ....................................................................................................................................... 24

Eliminacion de redundancia ................................................................................................................. 25

Reutilizacion ......................................................................................................................................... 25

1.10 Comparativa con otros Lenguajes de programación orientados a objetos .................................... 25



ANEXO ...................................................................................................................................................... 26

HERENCIA ............................................................................................................................................. 26

EJEMPLO 1. HUMANO--CIUDADANO ............................................................................................... 26

EJEMPLO 2. ANIMAL---AVE .............................................................................................................. 27

EJEMPLO 3.PERSONA---ALUMNO .................................................................................................... 27

SOBRECARGA ....................................................................................................................................... 27

EJEMPLO 1. FRACCION ..................................................................................................................... 27

Polimorfismo ........................................................................................................................................ 29

EXAMEN ............................................................................................................................................... 30

PRACTICAS DE LA UNIDAD 1 .................................................................................................................... 31

OBJETIVO GENERAL DEL CURSO ................................................................. ¡Error! Marcador no definido.

CRITERIOS DE EVALUACIÓN DE LA 2DA. UNIDAD ....................................... ¡Error! Marcador no definido.

2.1 INTRODUCCIÓN A LAS APPLETS. ........................................................... ¡Error! Marcador no definido.

2.2 LA CLASE APPLET. .................................................................................. ¡Error! Marcador no definido.

2.3 CONSTRUCCIÓN DE UNA APPLET. ......................................................... ¡Error! Marcador no definido.

2.4 CREACIÓN DE APPLETS AVANZADOS. ................................................... ¡Error! Marcador no definido.

2.5 CREACIÓN DE APLICACIONES CON APPLETS. ........................................ ¡Error! Marcador no definido.

PRACTICAS DE LA UNIDAD 2 ....................................................................... ¡Error! Marcador no definido.

UNIDAD III. GRÁFICOS EN JAVA .................................................................. ¡Error! Marcador no definido.

3.1 CONCEPTOS BÁSICOS DE LOS GRÁFICOS. ............................................. ¡Error! Marcador no definido.

Introducción al API 2D de Java ................................................................ ¡Error! Marcador no definido.

3.2 LIBRERÍAS DE GRÁFICOS. ....................................................................... ¡Error! Marcador no definido.

3.3 TIPOS DE GRÁFICOS. ............................................................................. ¡Error! Marcador no definido.

3.3.1 TEXTO. ............................................................................................ ¡Error! Marcador no definido.

3.3.2 IMÁGENES. ..................................................................................... ¡Error! Marcador no definido.

3.4 TRANSFORMAR FORMAS. ..................................................................... ¡Error! Marcador no definido.

3.5 COMPONER GRÁFICOS. ......................................................................... ¡Error! Marcador no definido.

TABLA DE IMÁGENES

Imagen 1. Datos de Java ............................................................................................................................ 9



Imagen 2. Representación de un objeto .................................................................................................. 10

Imagen 3. Objeto. .................................................................................................................................... 11

Imagen 4. Ejemplos de objetos ................................................................................................................ 11

Imagen 5. Clase5 ....................................................................................................................................... 12

Imagen 6. Clases y objetos ....................................................................................................................... 12

Imagen 7. Ejemplo de un objeto y sus métodos ...................................................................................... 12

Imagen 8. Propiedades de una clase. ...................................................................................................... 14

Imagen 9. Tipos de atributos. .................................................................................................................. 14

Imagen 10. Ejemplo de clase y objeto ..................................................................................................... 15

Imagen 11. Declaración de un objeto ...................................................................................................... 15

Imagen 12. Abstracción ........................................................................................................................... 16

Imagen 13. Ejemplo de herencia ............................................................................................................. 17

Imagen 14. Polimorfismo ......................................................................................................................... 18

Imagen 15. Ejemplo de navegador con java ............................................................................................ 23

Imagen 16. Descarga de módulos con java.............................................................................................. 24

UNIDAD I. INTRODUCCIÓN A LA PROGRAMACIÓN ORIENTADA A OBJETOS EN

JAVA

OBJETIVO GENERAL DEL CURSO El estudiante conocerá y aplicará las principales herramientas de desarrollo web, en el entorno de Java, para el desarrollo de sistemas.

TEMARIO

Unidad Temas Subtemas

1

2

3

4

Introducción a la POO en Java.

Applets

Gráficos en Java. Servlets

1.1 Conceptos generales de la programación orientada a objetos.

1.2 Clases y objetos. 1.2.1 Atributos.

1.2.2 Métodos. 1.2.3 Constructores. 1.3 Abstracción.

1.4 Encapsulación. 1.5 Herencia. 1.6 Polimorfismo.

1.7 Destrucción de objetos. 1.8 Características de Java. 1.9 Ventajas de la POO.

1.10 Comparativa con otros Lenguajes de programación orientados a objetos

2.1 Introducción a las applets. 2.2 La clase applet. 2.3 Construcción de una applet.

2.4 Creación de Applets avanzados. 2.5 Creación de aplicaciones con Applets. 3.1 Conceptos básicos de los gráficos.

3.2 Librerías de gráficos. 3.3 Tipos de gráficos. 3.3.1 Texto.

3.3.2 Imágenes. 3.4 Transformar formas. 3.5 Componer gráficos.

4.1 Definición de servlet. 4.2 Usos de los servlets.

4.3 Características de los servlets. 4.4 La aplicación Servletrunner. 4.4.1 Instalación.

4.4.2 Fichero de propiedades. 4.4.3 Ejecución. 4.5 Creación de servlets.

4.6 Ciclo de vida de un servlet. 4.7 Formas de ejecución de un servlet. 4.8 Introducción al acceso de base de datos

mediante servlets.

5

Aplicaciones móviles en Java.

5.1 Introducción a los dispositivos móviles y su programación.

5.2 Java 2 Micro Edition (J2ME) 5.2.1 Origen y evolución. 5.2.2 Ediciones de J2ME. 5.2.3 Arquitectura. 5.3 Tipos de dispositivos móviles. 5.4 Configuraciones. 5.5 Interfaz gráfica de usuario midlets. 5.6 Uso de la herramienta NetBeans para la

programación de dispositivos móviles. 5.7 Desarrollo de aplicaciones para dispositivos móviles.



CRITERIOS DE EVALUACIÓN

EXAMEN 30%

TAREAS 30%

PRACTICAS 30%

ASISTENCIA 5%

APUNTES 5%

100%

FECHAS DE EXAMENES

Unidad I 06/JULIO/2012

Unidad II 13/JULIO/2012

Unidad III 19/JULIO/2012

Unidad IV 25/JULIO/2012

Unidad V 03/AGOSTO/2012



UNIDAD I. INTRODUCCIÓN A LA PROGRAMACIÓN ORIENTADA A

OBJETOS EN JAVA

1.1 Conceptos Generales de la Programación Orientada a Objetos

¿QUÉ ES LA PROGRAMACIÓN ORIENTADA A OBJETOS?

Hasta el momento, las siguientes son las formas de programación utilizadas por los programadores:

La programación construyendo el programa instrucción a instrucción, utilizando las tres estructuras básicas de control (Secuencial. Condicional e Iterativa): PROGRAMACIÓN IMPERATIVA.

La programación construyendo un programa mediante un conjunto de funciones de orden superior, que se han definido previamente (Subprograma) y aplicando posteriormente la programación funcional y la recursión: PROGRAMACIÓN FUNCIONAL.

La programación construyendo un programa como un conjunto de asertos y reglas lógicas, que definen relaciones: PROGRAMACIÓN LÓGICA.

La programación que ve un programa como un conjunto de objetos que se relacionan unos a otros enviándose mensajes: PROGRAMACIÓN ORIENTADA A OBJETOS. 1

En el mundo del software, un objeto es un componente de software con estructura similar a los objetos del mundo real. Cada objeto está compuesto por un juego de datos (propiedades y/o atributos) que son las variables que describen las características esenciales del objeto, también consiste en un juego de métodos (comportamientos) que describen como el objeto se comporta.

La clase es la estructura fundamental en la programación orientada a objetos. Esta se puede tomar como una plantilla, un prototipo o un anteproyecto de los objetos. Esta consiste en dos tipos de miembros que son llamados campos (propiedades o atributos) y métodos. Los campos especifican el tipo de datos definidos por la clase, mientras que los métodos especifican las operaciones. Un objeto es una instancia de una clase.

Las clases proporcionan la propiedad de la reusabilidad, los programas de software pueden usar una clase una y otra vez para crear muchos objetos.2

1 Introducción A La Programación En Java. Fray León Osorio

2 http://aprendeenlinea.udea.edu.co/lms/moodle/file.php/561/Modulos/Modulo_11_Classes_y_objetos_en_Java.pdf

http://aprendeenlinea.udea.edu.co/lms/moodle/file.php/561/Modulos/Modulo_11_Classes_y_objetos_en_Java.pdf



DATOS SOBRE EL LENGUAJE JAVA.

Imagen 1. Datos de Java



1.2 Clases y objetos.

OBJETO:

Los objetos son la clave para entender la tecnología orientada a objetos. Si mira a su alrededor ahora mismo se encontrará con muchos ejemplos de objetos del mundo real: su perro, su escritorio, su televisor, su bicicleta.

Imagen 2. Representación de un objeto

Los objetos del mundo real comparten dos características: Todos tienen estado y comportamiento. Los perros tienen estado (nombre, color, raza, hambriento) y comportamiento (ladrando, buscando, meneando la cola). Las bicicletas también tienen un estado (marcha actual, cadencia de pedaleo actual, velocidad actual) y comportamiento (cambio de marcha, cambio de cadencia de pedaleo, frenar). Identificar el estado y el comportamiento de los objetos del mundo real es una gran ayuda para empezar a pensar en términos de programación orientada a objetos.

Tómese un momento ahora mismo para observar los objetos del mundo real que hay a su alrededor. Para cada uno de los objetos que ve, hágase dos preguntas: «¿En qué posibles estados puede estar este objeto?» y «¿Qué posibles comportamientos puede realizar?»". Asegúrese de escribir sus observaciones. Mientras lo haga, verá que los objetos del mundo real varían en complejidad, su lámpara de escritorio puede tener solo dos estados (encendido y apagado) y dos posibles comportamientos (encender y apagar), pero su radio tendrá más estados (encendido, apagado, volumen actual, emisora actual) y comportamientos (encender, apagar, subir volumen, bajar volumen, buscar y sintonizar). También observará que algunos objetos, a su vez, también contendrán otros objetos. Todas estas observaciones del mundo real son reproducibles en el mundo de la programación orientada a objetos.3

3 http://www.codexion.com/tutorialesjava/java/concepts/object.html

http://www.codexion.com/tutorialesjava/java/concepts/object.html



Imagen 3. Objeto.4

Imagen 4. Ejemplos de objetos

5

CLASE:

Las clases son abstracciones que representan a un conjunto de objetos con un comportamiento e interfaz común.

Podemos definir una clase como "un conjunto de cosas (físicas o abstractas) que tienen el mismo comportamiento y características... Es la implementación de un tipo de objeto (considerando los objetos como instancias de las clases)". [Piattini et al., 1996].

Una clase no es más que una plantilla para la creación de objetos. Cuando se crea un objeto (instanciación) se ha de especificar de qué clase es el objeto instanciado, para que el compilador comprenda las características del objeto.

4 http://www.slideshare.net/techmi/curso-java-inicial-4-poo-en-java

5 http://www.slideshare.net/nano_trujillo/programacin-orientada-a-objetos-2827362

http://www.slideshare.net/techmi/curso-java-inicial-4-poo-en-java

http://www.slideshare.net/nano_trujillo/programacin-orientada-a-objetos-2827362



Las clases presentan el estado de los objetos a los que representan mediante variables denominadas atributos. Cuando se instancia un objeto el compilador crea en la memoria dinámica un espacio para tantas variables como atributos tenga la clase a la que pertenece el objeto.6

Imagen 5. Clase5

Imagen 6. Clases y objetos7

Imagen 7. Ejemplo de un objeto y sus métodos

6 http://zarza.usal.es/~fgarcia/doc/tuto2/I_1.htm

7 http://www.slideshare.net/nano_trujillo/programacin-orientada-a-objetos-2827362

http://zarza.usal.es/~fgarcia/doc/tuto2/I_1.htm

http://www.slideshare.net/nano_trujillo/programacin-orientada-a-objetos-2827362



1.2.1 Atributos.

Características o propiedades que tiene un objeto y el conjunto de atributos define al objeto como uno más de su clase, todo atributo es un dato que pertenece al objeto y es representado en el diseño como una variable.

Las propiedades son como las “variables” en programación estructurada, que pueden

tomar un único valor o varios y pueden ser de un tipo o de distintos. 8

Son datos específicos de una clase:

Definidos por un nombre (sustantivos) y con los atributos (propiedades) que van a poseer (sustantivos o adjetivos).

Deben ser únicos aunque el mismo nombre de un atributo puede estar en distintas clases.

Definen la estructura de una clase y la de sus objetos.

La declaración como públicas significa que podrá utilizarse en cualquier parte del programa.

Para acceder a un atributo hay que indicarle el nombre del objeto al que pertenece.

Tenemos 2 tipos de propiedades:

Propias: dentro del propio objeto.

8 http://www.slideshare.net/da4equipo3/propiedades-de-la-poo

Tarea 1: Investigar los

pilares de la POO

Tarea 2: Diseñar en

UML 3 clases.

http://www.slideshare.net/da4equipo3/propiedades-de-la-poo



Heredadas: definidas en otro objeto (antepasado), se las llama propiedades miembro; el objeto las posee por el simple hecho de ser miembro de una clase.

Imagen 8. Propiedades de una clase.

Imagen 9. Tipos de atributos.

1.2.2 Métodos.

Procesos que los objetos de su tipo pueden realizar o pueden aplicarse sobre ellos.

Sus elementos son los argumentos y su tipo de retorno. Los argumentos son los datos

necesarios para que el método pueda realizar su tarea. De éstos debe indicarse su

respectivo tipo. Si el método posee retorno, éste se refiere al tipo de dato de la

respuesta o resultado del método.

Algoritmo asociado a un objeto (o a una clase de objetos), cuya ejecución se

desencadena tras la recepción de un "mensaje".

Desde el punto de vista del comportamiento, es lo que el objeto puede hacer.

Un método puede producir un cambio en las propiedades del objeto, o la

generación de un "evento" con un nuevo mensaje para otro objeto del sistema.



Las categorías de los métodos son:

Inicializadores

Getters

Setters

Visualizadores

Operadores

Constructores

Destructores

Otros

1.2.3 Constructores.

Métodos especiales que se ejecutan cuando se crea un objeto.

Inicializan a los atributos.

Pueden existir varios constructores (sobrecarga).

Tienen el mismo nombre de la clase, son públicos y no tienen tipo de dato de

retorno.

El constructor es necesario, para que solo en la clase se inicialicen los valores de las

variables privadas, es decir, son procedimientos que se ejecutan en el momento de la

instanciación del objeto (tienen el mismo nombre de la clase).

Imagen 10. Ejemplo de clase y objeto

Imagen 11. Declaración de un objeto



1.3 Abstracción. La abstracción es un método por el cual obtenemos una determinada entidad de la

realidad sus características y funciones que desempeñan, estos son representados en

clases por medio de atributos y métodos de dicha clase. Ejemplo:

Un ejemplo sencillo para comprender este concepto seria la abstracción de un

Automóvil.

Determinamos de la entidad sus características por ejemplo: color, año de fabricación,

modelo, etc. Y también sus métodos o funciones típicas de esta entidad como por

ejemplo: frenar, encender, etc.

Imagen 12. Abstracción

1.4 Encapsulación.

Es el empaquetamiento de las variables de un objeto con la protección de sus métodos.

Es usado para esconder detalles de la puesta en práctica no importantes de otros objetos, entonces los métodos dentro de sus instrucciones pueden cambiar en cualquier tiempo sin afectar otras partes del programa.

Ventajas:

Modularidad: se realiza en partes o modelos y darle mantenimiento al código.

Ocultamiento de información: la interfaz puede ser privada y nadie tiene acceso a el.

Las clases proveen el beneficio de la reutilización.

Este concepto se basa en que por ejemplo a un conductor no necesita saber cómo

están compuestas las partes internas del motor, sino la funcionalidad que tiene, a este

ocultamiento se le denomina encapsulamiento. Es el ocultamiento de información que

no es necesario saber un determinado usuario.



1.5 Herencia. Es una característica fundamental de la POO ya que es la que permite un gran

aumento en la reutilización de código. La posibilidad de crear nuevas clases basadas

en otras preexistentes permite crear bibliotecas genéricas, a las cuales les podemos

hacer algunos ajustes.

Para crear una clase basada en una preexistente se utiliza la siguiente sintaxis:

clase subclase extends superclase

{ }

Persona

Estudiante Empleado

Medio superior Superior

Regular

es

Irregular Regular

es

Irregular

es

Obrero Gerente

Turno

M V

Imagen 13. Ejemplo de herencia



1.6 Polimorfismo.

Llamar a un método igual que otros pero con diferentes parámetros. Este concepto se base en que podemos utilizar varios metodos con el mismo nombre y con diferente funcionalidad. Por ejemplo de mi clase Vehiculos tenemos el metodo frenar, y tenemos sus sub clases Automovil y Motocicleta, ambos tienen el metodo frenar pero cada uno tiene una definicion diferente para cada clase. A esto se le denomina polimorfismo, mas adelante lo vamos a ver en las sobrecargas de funciones y redefiniciones de metodos en la herencia.

Imagen 14. Polimorfismo

1.7 Destrucción de objetos.

a.) La destrucción de los objetos

Cuando un objeto no va a ser utilizado, el espacio de memoria de dinámica que utiliza ha de ser liberado, así como los recursos que poseía, permitiendo al programa disponer de todos los recursos posibles. A esta acción se la da el nombre de destrucción del objeto.

En Java la destrucción se puede realizar de forma automática o de forma personalizada, en función de las características del objeto.

b.) La destrucción por defecto: Recogida de basura

El intérprete de Java posee un sistema de recogida de basura, que por lo general permite que no nos preocupemos de liberar la memoria asignada explícitamente.

El recolector de basura será el encargado de liberar una zona de memoria dinámica que había sido reservada mediante el operador new, cuando el objeto ya no va a ser



utilizado más durante el programa (por ejemplo, sale del ámbito de utilización, o no es referenciado nuevamente).

El sistema de recogida de basura se ejecuta periódicamente, buscando objetos que ya no estén referenciados.

c.) La destrucción personalizada: finalize

A veces una clase mantiene un recurso que no es de Java como un descriptor de archivo o un tipo de letra del sistema de ventanas. En este caso sería acertado el utilizar la finalización explícita, para asegurar que dicho recurso se libera. Esto se hace mediante la destrucción personalizada, un sistema similar a los destructores de C++.

Para especificar una destrucción personalizada se añade un método a la clase con el nombre finalize:

class ClaseFinalizada{

ClaseFinalizada() { // Constructor

// Reserva del recurso no Java o recurso compartido

}

protected void finalize() {

// Liberación del recurso no Java o recurso compartido

}

}

En Java, el programador no tiene que preocuparse por la gestión de la memoria. Los objetos se destruyen solos, mediante el recolector de memoria, sin que el programador tenga que pedirlo.

En otros lenguajes, como el Pascal o el C, en los que la memoria se utiliza dinámicamente para varios propósitos, si que debe liberarse explícitamente.

El recolector de memoria consume recursos de la máquina pero, merece la pena. Estamos seguros de que la memoria no se deteriora por defectos en la programación.



1.8 Características de Java.

Java es Simple.

Java ofrece toda la funcionalidad de un lenguaje potente, pero sin las características menos usadas y más confusas de éstos. C++ es un lenguaje que adolece de falta de seguridad, pero C y C++ son lenguajes más difundidos, por ello Java se diseñó para ser parecido a C++ y así facilitar un rápido y fácil aprendizaje.

Java elimina muchas de las características de otros lenguajes como C++, para mantener reducidas las especificaciones del lenguaje y añadir características muy útiles como el garbage collector (reciclador de memoria dinámica). No es necesario preocuparse de liberar memoria, el reciclador se encarga de ello y como es un thread de baja prioridad, cuando entra en acción, permite liberar bloques de memoria muy grandes, lo que reduce la fragmentación de la memoria.

Java reduce en un 50% los errores más comunes de programación con lenguajes como C y C++ al eliminar muchas de las características de éstos, entre las que destacan:

• Aritmética De Punteros. • No Existen Referencias. • Registros (Struct). • Definición De Tipos (Typedef). • Macros (#Define). • Necesidad De Liberar Memoria (Free).

Aunque, en realidad, lo que hace es eliminar las palabras reservadas (struct, typedef), ya que las clases son algo parecido.

Además, el intérprete completo de Java que hay en este momento es muy pequeño, ocupa muy poca RAM.

Java es Orientado a Objetos.

Java implementa la tecnología básica de C++ con algunas mejoras y elimina algunos aspectos para mantener el objetivo de la simplicidad del lenguaje. Java trabaja con sus datos como objetos y con interfaces a esos objetos. Soporta las tres características propias del paradigma de la orientación a objetos: encapsulación, herencia y polimorfismo. Las plantillas de objetos son llamadas, como en C++, clases y sus copias, instancias. Estas instancias, como en C++, necesitan ser construidas y destruidas en espacios de memoria.

Java incorpora funcionalidades inexistentes en C++ como por ejemplo, la resolución dinámica de métodos. Esta característica deriva del lenguaje Objective C, propietario del sistema operativo Next. En C++ se suele trabajar con librerías dinámicas (DLLs) que obligan a recompilar la aplicación cuando se retocan las funciones que se encuentran



en su interior. Este inconveniente es resuelto por Java mediante una interfaz específica llamada RTTI (RunTime Type Identification) que define la interacción entre objetos excluyendo variables de instancias o implementación de métodos. Las clases en Java tienen una representación en el runtime que permite a los programadores interrogar por el tipo de clase y enlazar dinámicamente la clase con el resultado de la búsqueda.

Java es Robusto.

Java realiza verificaciones en busca de problemas tanto en tiempo de compilación como en tiempo de ejecución. La comprobación de tipos en Java ayuda a detectar errores lo antes posible en el ciclo de desarrollo. Java obliga a la declaración explícita de métodos y tipos de variables (Java es fuertemente tipado), reduciendo así las posibilidades de error. Maneja la memoria para eliminar las preocupaciones por parte del programador de la liberación o corrupción de memoria. También implementa los arrays auténticos, en vez de listas enlazadas de punteros, con comprobación de límites, para evitar la posibilidad de sobreescribir o corromper memoria resultado de punteros que señalan a zonas equivocadas. Estas características reducen drásticamente el tiempo de desarrollo de aplicaciones en Java.

Además, para asegurar el funcionamiento de la aplicación, realiza una verificación de los byte-codes, que son el resultado de la compilación de un programa Java. Es un código de máquina virtual que es interpretado por el intérprete Java. No es el código máquina directamente entendible por el hardware, pero ya ha pasado todas las fases del compilador: análisis de instrucciones, orden de operadores, etc., y ya tiene generada la pila de ejecución de órdenes.

Java proporciona, por tanto:

• Comprobación de punteros. • Comprobación de límites de arrays. • Excepciones. • Verificación de byte-codes.

Java es Multihilo (Multithreaded).

Java al ser multithreaded, permite muchas actividades simultáneas en un programa. Los threads (a veces llamados, procesos ligeros), son básicamente pequeños procesos o piezas independientes de un gran proceso. Al estar los threads construidos en el lenguaje, son más fáciles de usar y más robustos que sus homólogos en C o C++.

El beneficio de ser multithreaded consiste en un mejor rendimiento interactivo y mejor comportamiento en tiempo real. Aunque el comportamiento en tiempo real está limitado a las capacidades del sistema operativo subyacente (Unix, Windows, etc.), aún supera a los entornos de flujo único de programa (single-threaded), tanto en facilidad de desarrollo, como en rendimiento.



Como ejemplo de todo esto, supongamos la visualización de una imagen desde Internet. Con Java, esta imagen se pueden ir trayendo en un thread independiente, permitiendo que el usuario pueda acceder a la información en la página sin tener que esperar por el navegador.

Java posee Arquitectura Neutral.

Uno de los principales problemas con el que se enfrentan los programadores es que no hay garantías de que un programa que escriben hoy se ejecute mañana, e incluso en la misma máquina. Las actualizaciones del sistema operativo, de los procesadores y los cambios en los recursos básicos del sistema pueden provocar que un programa deje de funcionar correctamente. Java ha sido diseñado para "escribir una vez, ejecutar en cualquier sitio, en cualquier momento y para siempre". En gran parte, ese objetivo se ha logrado.

Java es Interpretado.

El intérprete Java (sistema run-time) puede ejecutar directamente el código objeto. Enlazar (linkar) un programa, normalmente, consume menos recursos que compilarlo, por lo que los desarrolladores con Java pasarán más tiempo desarrollando y menos esperando por el ordenador. No obstante, el compilador actual del JDK es bastante lento. Por ahora, que todavía no hay compiladores específicos de Java para las diversas plataformas, Java es más lento que otros lenguajes de programación, como C++, ya que debe ser interpretado y no ejecutado como sucede en cualquier programa tradicional.

Se dice que Java es de 10 a 30 veces más lento que C, y que tampoco existen en Java proyectos de gran envergadura como en otros lenguajes. La verdad es que ya hay comparaciones ventajosas entre Java y el resto de los lenguajes de programación, y una gran cantidad de folletos electrónicos a favor y en contra de los distintos lenguajes contendientes con Java. Lo que se suele dejar de lado en todo esto, es que primero habría que decidir hasta que punto Java, un lenguaje en pleno desarrollo y todavía sin definición definitiva, está maduro como lenguaje de programación para ser comparado con otros; como por ejemplo con Smalltalk, que lleva más de 20 años en uso.

La verdad es que Java para conseguir ser un lenguaje independiente del sistema operativo y del procesador que incorpore la máquina utilizada, es tanto interpretado como compilado. Y esto no es ningún contrasentido, el código fuente escrito con cualquier editor se compila generando el byte-code. Este código intermedio es de muy bajo nivel, pero sin alcanzar las instrucciones máquina propias de cada plataforma y no tiene nada que ver con el p-code de Visual Basic. El byte-code corresponde al 80% de las instrucciones de la aplicación. Ese mismo código es el que se puede ejecutar sobre cualquier plataforma. Para ello hace falta el run-time, que sí es completamente dependiente de la máquina y del sistema operativo, que interpreta dinámicamente el byte-code y añade el 20% de instrucciones que faltaban para su ejecución. Con este



sistema es fácil crear aplicaciones multiplataforma, pero para ejecutarlas es necesario que exista el run-time correspondiente al sistema operativo utilizado.

Java es Distribuido.

Java se ha construido con extensas capacidades de interconexión TCP/IP. Existen librerías de rutinas para acceder e interactuar con protocolos como http y ftp. Esto permite a los programadores acceder a la información a través de la red con tanta facilidad como a los ficheros locales.

Java en sí no es distribuido, sino que proporciona las librerías y herramientas para que los programas puedan ser distribuidos, es decir, que se ejecuten en varias máquinas, interactuando.

Como ejemplo, Java también tiene la posibilidad de que los objetos puedan ejecutar procedimientos remotos; esta facilidad se llama RMI (Remote Method Invocation). Esto le aporta más características del modelo cliente/servidor.

Java es Dinámico.

Java se beneficia todo lo posible de la tecnología orientada a objetos. Java no intenta conectar todos los módulos que comprenden una aplicación hasta el tiempo de ejecución. Las librería nuevas o actualizadas no paralizarán las aplicaciones actuales (siempre que mantengan el API anterior).

La siguiente figura muestra las diferencias entre un navegador convencional y un con Java:

Imagen 15. Ejemplo de navegador con java

Java también simplifica el uso de protocolos nuevos o actualizados. Si su sistema

ejecuta una aplicación Java sobre la red y encuentra una pieza de la aplicación que no



sabe manejar es capaz de traer automáticamente cualquiera de esas piezas que el

sistema necesita para funcionar desde el servidor remoto.

Imagen 16. Descarga de módulos con java.

Java, para evitar tener que ir descargando módulos de byte-codes, objetos o nuevas

clases, implementa las opciones de persistencia, para que no se eliminen cuando de

limpie la caché de la máquina.9

1.9 Ventajas de la POO.

Modelos La poo permite realizar un modelo de sistema casi independientemente de los requisitos del Proyecto. La razon es que en la poo la jerarquia la establecen los datos, en cambio en la Programacion estructurada la jerarquia viene definida por los programas. Este cambio hace que los modelos se establezcan de forma similar al razonamiento humano y, por lo tanto, resulte mas natural.

Modularidad Un programa es modular si se compone de modulos independientes y robustos. Esto permite la Reutilizacion y facilita la verificacion y depuracion de los mismos. En poo, los modulos estan Directamente relacionados con los objetos. Los objetos son modulos naturales ya que corresponden A una imagen logica de la realidad.

Extensibilidad Durante el desarrollo de sistemas, ocurre la aparicion de nuevos requisitos, por eso es deseable Que las herramientas de desarrollo permitan anadirlos sin modificar la

9 http://www.dma.fi.upm.es/mabellanas/voronoi/java/java.htm#2.2

http://www.dma.fi.upm.es/mabellanas/voronoi/java/java.htm#2.2



estructura basica del Diseno. En poo es posible lograr esto siempre y cuando se hayan definido de forma adecuada la Jerarquia de clases, los atributos y metodos.

Eliminacion de redundancia

En el desarrollo de sistemas se desea evitar la definicion multiple de datos y funciones comunes. En poo esto se logra mediante la herencia (evita la definicion multiple de propiedades comunes a Muchos objetos) y el polimorfismo (permite la modificación de metodos heredados). Solo hay que Definir los atributos y los metodos en el antepasado mas lejano que los comparte.

Reutilizacion La poo proporciona un marco perfecto para la reutilización de las clases. El encapsulamiento y la Modularidad nos permiten utilizar una y otra vez las mismas clases en aplicaciones distintas. En efecto, el aislamiento entre distintas clases significa que es posible añadir una nueva clase o Un modulo nuevo (extensibilidad) sin afectar al resto de la aplicación.

Los beneficios de la programación orientada a objetos son más que los que pueden

verse a simple vista. El énfasis en las propiedades esenciales de un objeto, fuerza al

desarrollador a pensar cuidadosamente que es un objeto y que es lo que hace con el

resultado de que el sistema es normalmente más preciso, general y robusto que si

pusiéramos el énfasis en los procedimientos y los datos por separado

1.10 Comparativa con otros Lenguajes de programación orientados a

objetos



ANEXO

HERENCIA

EJEMPLO 1. HUMANO--CIUDADANO

HUMANO.JAVA

class Humano {

protected String nombre;

protected String apellido;

public Humano(String nombre,String apellido) {

this.nombre = nombre;

this.apellido = apellido;

}

public String nombreCompleto()

{

return this.apellido + ", " + this.nombre;

}

public String identificacion() {

return this.nombreCompleto();

}

}



class Ciudadano extends Humano {

protected String documento;

public Ciudadano(String nombre,String apellido, String documento) {

super(nombre,apellido);

this.documento = documento;

}

public String identificacion() {

return super.identificacion() + ", documento: " + this.documento;

}

}

public class herencia1 {

public static void main(String[] args) {

// TODO Auto-generated method stub

Humano a = new Humano("Emilio","Rosso");

Ciudadano b = new Ciudadano("Emilio","Rosso","3052454545");

System.out.println("Humano:"+a.nombreCompleto()+a.identificacion());

System.out.println("Ciudadano:"+b.identificacion());

}

}

EJEMPLO 2. ANIMAL---AVE

EJEMPLO 3.PERSONA---ALUMNO

SOBRECARGA

EJEMPLO 1. FRACCION

public class sobrecargas{

private double suma;

public sobrecargas()

{

suma=0;

}

public sobrecargas(double a,double b)

{

suma=0;

}



public int sumar(int n1,int n2)

{

int total;

total=n1+n2;

suma=total;

return total;

}

public void sumar(double n1,double n2)

{

double total;

total=n1+n2;

suma=total;

System.out.println("El total de la suma es: "+ total);

}

}

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStreamReader;

public class sobrecarga1 {

/**

* @param args

*/

public static void main(String argum[]) throws IOException {

BufferedReader op = new BufferedReader(new InputStreamReader(System.in));

String opc; int a,b;

double a1,b1;

//declara el objeto cuenta de tipo banco

sobrecargas cuenta = new sobrecargas();

System.out.println("Ingrese Valor fraccionario de A");

a1=Double.parseDouble( op.readLine() );

System.out.println("Ingrese Valor fraccionario de B");

b1= Double.parseDouble( op.readLine() );

cuenta.sumar(a1, b1);

System.out.println("Ingrese Valor de A");

a=Integer.parseInt( op.readLine() );

System.out.println("Ingrese Valor de B");

b= Integer.parseInt( op.readLine() );

System.out.println("El total es: "+ cuenta.sumar(a, b));



}

} // fin clase

Polimorfismo

El Polimorfismo es la respuesta distinta frente a una llamada a un método dependiendo de la naturaleza del objeto. Consiste en definir métodos distintos, que comparten el mismo nombre, pero que se aplican a clases diferentes. Por ejemplo, un método llamado breathe puede responder de manera distinta dependiendo de quien lo invoque:

Código class animal

{

public void breathe()

{

System.out.println("Respirar...");

}

}

class pez extends animal

{

public void breathe()

{

System.out.println("Burbujear...");

}

}

Si se invoca el método breathe desde un objeto-perro, imprimirá en pantalla "Respirar...", pero si es invocado desde un objeto-trucha, imprimirá en pantalla "Burbujear...". Otra forma de utilizar polimorfismo es mediante la sobrecarga de funciones:

Código: char convertir_numero_cadena(int valor, char cadena, int

base)

char convertir_numero_cadena(long valor, char cadena, int

base)

En este caso, cuando se invoca la función, el compilador debe

analizar los argumentos de la llamada y, en función de su tipo,

http://www.google.com/search?hl=en&q=allinurl%3Asystem+java.sun.com&btnI=I%27m%20Feeling%20Lucky

http://www.google.com/search?hl=en&q=allinurl%3Asystem+java.sun.com&btnI=I%27m%20Feeling%20Lucky



deducir cual de las distintas versiones del método con ese nombre

debe recibir el control.

EXAMEN

public class tabla {

private int num;

//constructor que inicializa la variable privada

tabla()

{

num=0;

}

void asignar(int num)

{

this.num=num;

}

//la funcion para imprimir la tabla

void calcular_tabla ()

{

int i=1,res=0;

while(i<=10)

{

res=num*i;

System.out.println(num+" X "+i+" = "+res);

i++;

}

}

}

import java.io.*;

public class principal {

public static void main(String[] args) throws IOException{

int numero;

BufferedReader l;

InputStreamReader e;



e= new InputStreamReader(System.in);

l= new BufferedReader(e);

tabla miobjeto= new tabla();

System.out.println("EScriba un numero: ");

numero= Integer.parseInt(l.readLine());

miobjeto.asignar(numero);

miobjeto.calcular_tabla();

}

}

APLICACIONES EN JAVA II

PRACTICAS DE LA UNIDAD 1

CURSO DE VERANO 2012

DOCENTE: LIC. PATRICIA HERNÁNDEZ RODRÍGUEZ

Realizar y entregar el día del examen.

Todas las prácticas deben de estar con comentarios, sobre la función que realizan.

Cada programa debe de llevar, la siguiente presentación (Ejemplo):

Número de Practica: 5 (consecutivo a las prácticas que realicemos)

Nombre: Cuadrado de un número

Fecha: 31/01/2012

Desarrollo: Mostrar el código (la última línea que debe de mostrar el programa es tu

nombre) y la pantalla de resultado.

Realizado por: <<Tu nombre>>



1. Programa que lee el nombre y el número y calcula el cuadrado de este.

2. Programa que intercambia el valor de 2 variables.

3. Programa que convierte de grados celsius a Fahrenheit, la formula es f=(9/5)*c+32

4. Escribir un programa en Java que sume, reste, multiplique y divida dos números:

5. Programa que despliegue un menú y solicite al usuario a que figura desea calcular el área.

a) Cuadrado. b) Rectángulo. c) Triángulo. d) Salir.

6. Escribir un programa en Pascal que evalúe la siguiente expresión: (-b + √(b2-4*a*c)/(2*a)

(es la solución positiva de una ecuación de 2” grado)

7. Realizar la clase automóvil con las siguientes características: 1) marca, 2) modelo, 3)

cantidad_gas. Con los métodos 1) encendido, 2) cargar gasolina.

8. Hacer una clase “figura”, con los datos de tipo_figura, ancho, alto, area, perímetro, los métodos: calcular_perimetro, calcular_area.

9. Hacer una clase “materia”, con los datos nombre, maestro, promedio, y los métodos mostrar y leer.

Antologia de Aplicaciones en Java II Patricia Herod

Documents

Transcript of Antologia de Aplicaciones en Java II Patricia Herod