|
 |
 |
|
|
 |
Publicaciones de Estudiantes
Francisco Javier Pabón Molina
Titulo: Principios de Programación II
Area: Information Systems
Pais:
Perfil:
Programa:
Available for Download:
Yes
Diseminar información, ideas innovadoras y
conocimientos académicos es una función
importante para Atlantic Internacional
University. Publicaremos noticias, artículos,
comentarios y otras publicaciones de
nuestros estudiantes y otros colaboradores.
Si desea contactar al autor por motivos
profesionales favor enviar su petición por
este medio.
|
|
| |
|
|
| |
1.
Introducción
En este ensayo titulado “Principles
of programming: Object Oriented
Programming”
pretendo dar un recorrido a este
paradigma de programación actual que
es
utilizado por miles de programadores
a nivel mundial, y que se ha
convertido en un
estándar en el desarrollo de
aplicaciones tanto de escritorio,
Web e Internet y
dispositivos móviles.
A lo largo del presente texto se ira
describiendo el origen, evolución,
tendencias
actuales y ciertos patrones de
diseño, así como una vista aunque no
muy profunda
si lo mas fiel posible a un lenguaje
de programación que ha revolucionado
el
presente y porque no decirlo también,
el futuro de la programación actual,
el
lenguaje Java.
¿Por qué Java?, en lo que va de mi
corta pero interesante carrera
profesional en
tecnologías de información he tenido
contacto con un pequeño numero de
lenguajes, desde Pascal (del cual
desarrollé el ensayo de Principles
of
programming I), donde se trató la
programación estructurada, dando una
minúscula exploración a Delphi,
lenguaje C y haciendo uso de
herramientas
propietarias en las cuales he tenido
mas experiencia y profundización
como ser la
suite Microsoft Visual Studio 6.0 en
el que comencé a dar mis primeros
pasos con
este estilo de programación de
objetos y el cual en la actualidad
sigo utilizando,
haciendo un cambio a la plataforma
.Net y lo que se ha aplica
actualmente el
concepto de framework1 de desarrollo,
existiendo varias tendencias o
estilos;
aunque las herramientas antes
mencionadas proveen de cierta
facilidad y
productividad al programador y
desarrollador de aplicaciones,
tienen la limitación
de la plataforma y ser propietarias2
y no en muchas universidades se
encuentran
disponible para la enseñanza, es
aquí donde entra Java.
Como se ira viendo, Java tiene la
ventaja de ser multiplataforma y
detallaré más a
fondo estas características en los
siguientes apartados, y si uno como
profesional
aplica para obtener un trabajo en el
área de la programación, es casi una
obligación desde un punto de vista
personal conocer y desempeñarse en
ambas
plataformas y certificarse3, para
ofrecer y brindarle mayores
soluciones a la
empresa, organización o individuo
que requiera de sus servicios.
También se pretende dar una pequeña
crítica a este estilo de
programación,
porque aunque todo tiene sus
ventajas y desventajas, y como dije
al principio, la
comunidad de desarrolladores es muy
amplia, hay muchos de los cuales aun
no
están del todo conformes y prefieren
todavía otros estilos y metodologías.
1 En desarrollo de software, un
framework es definido como una
estructura de apoyo en la cual otro
proyecto de software
puede ser organizado y desarrollado.
2 El uso de herramientas
propietarias, generalmente ligadas a
tecnologías específicas bajo el
control de determinadas
empresas, contribuye a lograr una
fuerte dependencia del futuro
profesional en las mismas.
3 Actualmente, certificarse es un
requisito en el mercado tecnológico.
La competencia es cada vez mayor y
debes estar
preparado para los cambios del
mercado.
Las prácticas y desarrollos se harán
con el JRE 5.0 Update 6 y como IDE
me he
decidido por Eclipse Project del
cual también detallaré mas adelante.
Agradecer a Atlantic International
University por brindarme la
oportunidad de poder
mostrar mis conocimientos y adquirir
y profundizar los nuevos que he
elegido en
vista a un mejor crecimiento
profesional.
2. Paradigma de la Programación
Un paradigma es una forma de
representar y manipular el
conocimiento.
Representa un enfoque particular o
filosofía para la construcción o
ingeniería de
software. No es mejor uno que otro
sino que cada uno tiene sus ventajas
y
desventajas. También hay situaciones
donde un paradigma es mejor que otro.
Un paradigma provee (y determina) la
vista que el programador tiene de la
ejecución del programa. Por ejemplo,
en un programa orientado a objetos,
los
programadores pueden pensar en un
programa como una colección de
interacción
de objetos, mientras en un programa
funcional un programa puede ser
pensado
como una secuencia de evaluaciones
de función sin estado.
Tal como diferentes grupos en
ingeniería de software abogan por
las diferentes
metodologías, los distintos
lenguajes de programación abogan por
los diferentes
paradigmas de programación. Algunos
lenguajes son diseñados para apoyar
un
paradigma particular (Smalltalk4 y
Java apoyan la programación
orientada a
objetos mientras Haskell5 y Scheme6
apoyan el paradigma de programación
funcional), otros lenguajes de
programación apoyan múltiples
paradigmas.
Algunos ejemplos de paradigmas de
programación:
El paradigma imperativo es
considerado el más común y está
representado, por
ejemplo, por el C7 o por BASIC8.
• El paradigma funcional está
representado por la familia de
lenguajes LISP9,
en particular Scheme.
• El paradigma lógico, un ejemplo es
PROLOG10.
Si bien puede seleccionarse la forma
pura de estos paradigmas al momento
de
programar, en la práctica es
habitual que se mezclen. Tal es el
caso de lenguajes
como C++, Delphi o Visual Basic, los
cuales combinan el paradigma
imperativo
con el orientado a objetos.
Por ejemplo, C++ es diseñado para
apoyar los elementos de programación
procedural, programación basada a
objetos, programación orientada a
objetos, y
programación genérica.
4-10 Lenguajes de programación
pertenecientes a distintos
paradigmas.
Uno puede escribir un programa
puramente procedural en C ++, puede
escribir un
Sin embargo, los diseñadores y
programadores deciden como construir
un
programa que usa aquellos elementos
de un paradigma. programa puramente
orientado a objetos en C ++, o puede
escribir un programa que contiene
los
elementos de ambos paradigmas.
En estos estilos es donde entra la
controversia por parte de muchos
programadores en cuanto a cual es
mejor o cumple sus necesidades, y
con la
evolución de los lenguajes, van
aplicándose nuevos paradigmas, por
ejemplo el de
programación orientada a aspectos,
el cual es reciente y su intención
es permitir
una adecuada modularización y
posibilitar una mejor separación de
conceptos.
Varias tecnologías con nombres
diferentes se encaminan a la
consecución de los
mismos objetivos y así, el término
POA (Programación Orientada a
Aspectos) es
usado para referirse a varias
tecnologías relacionadas.
Muchas veces nos encontramos, a la
hora de programar, con problemas que
no
podemos resolver de una manera
adecuada con las técnicas habituales
usadas en
la programación procedural o en la
programación orientada a objetos. O
que en
otro lenguaje se resuelven de forma
más sencilla y tratamos de evitar en
la
mayoría de las veces varias líneas
de código. Con éstas, nos vemos
forzados a
tomar decisiones de diseño que
repercuten de manera importante en
el desarrollo
de la aplicación y que nos alejan
con frecuencia de otras
posibilidades. Pero,
como se repite en este apartado,
todo tiene sus ventajas y se hará un
énfasis a la
programación orientada a objetos y
sus fortalezas.
Algunos diseñadores de lenguajes han
dado por sentado que la programación
orientada a objetos, de por sí, no
es adecuada para resolver de manera
sencilla
todos los problemas de programación,
y hacen referencia al uso de
lenguajes de
programación multiparadigma.
La descripción de los otros
paradigmas se dejara para un futuro
apartado.
3. Programación orientada a objetos
Aunque existen distintas
terminologías para nombrar los
mismos conceptos y
características importantes de la
programación orientada a objetos,
abreviada
POO, es importante entender la
mayoría de ellos tanto por quien la
desconoce
como por aquel que la conoce.
Las computadoras, más que máquinas,
pueden considerarse como
herramientas
que permiten ampliar la mente ("bicicletas
para la mente", como se enorgullece
de
decir Steve Jobs), además de un
medio de expresión inherentemente
diferente.
Como resultado, las herramientas
empiezan a parecerse menos a
máquinas y
más a partes de nuestra mente, al
igual que ocurre con otros medios de
expresión
como la escritura, la pintura, la
escultura, la animación o la
filmación de películas.
La programación orientada a objetos
(POO) es una parte de este
movimiento
dirigido a utilizar las computadoras
como si de un medio de expresión se
tratara.
La programación orientada a objetos
asevera dar mayor flexibilidad,
facilitando los
cambios a los programas y es
ampliamente popular en la gran
escala de
ingeniería de software. Además, los
que proponen la POO argumentan que
es
mas fácil de aprender para quienes
son nuevos en la programación de
computadoras y que su abordaje a
menudo es más fácil de desarrollar y
mantener
prestándose así mismo más análisis
directo, codificación y
entendimiento de
situaciones complejas y
procedimientos comparado a otros
métodos de
programación.
4. ¿Qué es la POO?
La programación orientada a objetos
es una evolución lógica de la
programación
estructurada, en la que el concepto
de variables locales a un
procedimiento o
función, que no son accesibles a
otros procedimientos y funciones, se
hace
extensible a los propios
subprogramas que acceden a estas
variables. Pero la
programación orientada a objetos va
mucho más allá. En realidad, cambia
la
concepción de la metodología de
diseño de los programas.
En la programación orientada a
objetos, se definen objetos que
conforman una
aplicación. Estos objetos están
formados por una serie de
características y
operaciones que se pueden realizar
sobre los mismos. Estos objetos no
están
aislados en la aplicación, sino que
se comunican entre ellos.
Los programadores que emplean
lenguajes procedurales, escriben
funciones y
después les pasan datos. Los
programadores que emplean lenguajes
orientados a
objetos definen objetos con datos y
métodos y después envían mensajes a
los
objetos diciendo que realicen esos
métodos en sí mismos.
4.1 Conceptos fundamentales
La programación orientada a objetos
hace énfasis en los siguientes
conceptos:
• Abstracción: Cada objeto en el
sistema sirve como modelo de un
"agente"
abstracto que puede realizar
trabajo, informar y cambiar su
estado, y
"comunicarse" con otros objetos en
el sistema sin revelar cómo se
implementan estas características.
Los procesos, las funciones o los
métodos pueden también ser
abstraídos y cuando los están, una
variedad
de técnicas son requeridas para
ampliar una abstracción. Es la
habilidad de
un programa de ignorar los detalles
de un objeto. Por ejemplo “Rin Tin
Tin”
el perro puede ser tratado como
perro la mayoría de las veces, menos
cuando es abstraído apropiadamente
al nivel de canido (superclase de
perro) o carnívoro (superclase de
canido) y así sucesivamente.
• Encapsulamiento: También llamada
"ocultación de la información", esto
asegura que los objetos no pueden
cambiar el estado interno de otros
objetos de maneras inesperadas;
solamente los propios métodos
internos
del objeto pueden acceder a su
estado. Cada tipo de objeto expone
una
interfaz a otros objetos que
especifica cómo otros objetos pueden
interactuar con él. Algunos
lenguajes relajan esto, permitiendo
un acceso
directo a los datos internos del
objeto de una manera controlada y
limitando
el grado de abstracción.
• Polimorfismo: Las referencias y
las colecciones de objetos pueden
contener objetos de diferentes
tipos, y la invocación de un
comportamiento
en una referencia producirá el
comportamiento correcto para el tipo
real del
objeto referenciado. Cuando esto
ocurre en "tiempo de ejecución",
esta
última característica se llama
asignación tardía o asignación
dinámica.
Algunos lenguajes proporcionan
medios más estáticos (en "tiempo de
compilación") de polimorfismo, tales
como las plantillas y la sobrecarga
de
operadores de C++.
• Herencia: Organiza y facilita el
polimorfismo y la encapsulación
permitiendo
a los objetos ser definidos y
creados como tipos especializados de
objetos
preexistentes. Estos pueden
compartir (y extender) su
comportamiento sin
tener que reimplementar su
comportamiento. Esto suele hacerse
habitualmente agrupando los objetos
en clases o Class y las clases en
árboles o enrejados que reflejan un
comportamiento común.
Cada uno de estos conceptos se irá
detallando más a fondo en los
siguientes
apartados.
4.2 ¿Qué es un Objeto?
La respuesta a esta pregunta en
términos ajenos a la programación
parece simple.
Un objeto es una persona, animal o
cosa. Se distingue de otros objetos
por tener
unas determinadas características y
“sirve” para algo, o dicho de otra
forma, se
pueden realizar distintas
operaciones con/sobre ese objeto.
Por ejemplo: Una casa es un objeto.
CARACTERÍSTICAS: Número de pisos,
altura total en metros, color de la
fachada, número de ventanas, número
de puertas, ciudad, calle y número
donde
está ubicada, etc.
OPERACIONES: Construir, destruir,
pintar fachada, modificar alguna de
las
características, como por ejemplo,
abrir una nueva ventana, etc.
Evidentemente, cada objeto puede
definirse en función de multitud de
características y se pueden realizar
innumerables operaciones sobre él.
Ya en
términos de programación, será
misión del programador determinar
qué
características y que operaciones
interesa mantener sobre un objeto.
Por ejemplo,
sobre el objeto casa puede no ser
necesario conocer su ubicación y por
lo tanto,
dichas características no formarán
parte del objeto definido por el
programador. Lo
mismo podría decirse sobre las
operaciones.
Pensar en términos de objetos es muy
parecido a cómo lo haríamos en la
vida
real. Por ejemplo vamos a pensar en
un coche para tratar de modelizarlo
en un
esquema de POO. Diríamos que el
coche es el elemento principal que
tiene una
serie de características, como
podrían ser el color, el modelo o la
marca. Además
tiene una serie de funcionalidades
asociadas, como pueden ser ponerse
en
marcha, parar o aparcar.
En terminología de programación
orientada a objetos, a las
características del
objeto se les denomina ATRIBUTOS y a
las operaciones MÉTODOS. Cada uno de
estos métodos es un procedimiento o
una función perteneciente a un
objeto.
Un objeto está formado por una serie
de características o datos
(atributos) y una
serie de operaciones (métodos). No
puede concebirse únicamente en
función de
los datos o de las operaciones sino
en su conjunto.
4.3 Abstracción
Todos los lenguajes de programación
proporcionan abstracciones. Puede
incluso
afirmarse que la complejidad de los
problemas a resolver es directamente
proporcional a la clase (tipo) y
calidad de las abstracciones a
utilizar, entendiendo
por tipo "clase", aquello que se
desea abstraer. El lenguaje
ensamblador es una
pequeña abstracción de la máquina
subyacente. Muchos de los lenguajes
denominados "imperativos"
desarrollados a continuación del
antes mencionado
ensamblador (como Fortran, BASIC y
C) eran abstracciones a su vez del
lenguaje
citado. Estos lenguajes supusieron
una gran mejora sobre el lenguaje
ensamblador, pero su abstracción
principal aún exigía pensar en
términos de la
estructura del computador más que en
la del problema en sí a resolver. El
programador que haga uso de estos
lenguajes debe establecer una
asociación
entre el modelo de la máquina
(dentro del "espacio de la
solución", que es donde
se modela el problema, por ejemplo,
un computador) y el modelo del
problema
que de hecho trata de resolver (en
el "espacio del problema", que es
donde de
hecho el problema existe).
La abstracción consiste en aislar un
elemento de su contexto o del resto
de los
elementos que lo acompañan. El
término se refiere al énfasis en el
"¿qué hace?"
más que en el "¿cómo lo hace?". El
común denominador en la evolución de
los
lenguajes de programación, desde los
clásicos o imperativos hasta los
orientados
a objetos, ha sido el nivel de
abstracción del que cada uno de
ellos hace uso.
Se sabe que los lenguajes de
programación son las herramientas
mediante las
cuales los diseñadores de lenguajes
pueden implementar los modelos
abstractos.
La abstracción ofrecida por los
lenguajes de programación se puede
dividir en dos
categorías: abstracción de datos
(pertenecientes a los datos) y
abstracción de
control (perteneciente a las
estructuras de control).
La abstracción encarada desde el
punto de vista de la programación
orientada a
objetos expresa las características
esenciales de un objeto, las mismas
distinguen
al objeto de los demás. Además de
distinguir entre los objetos provee
límites
conceptuales. Entonces se puede
decir que la encapsulación separa
las
características esenciales de las no
dentro de un objeto. Si un objeto
tiene mas
características de las necesarias
los mismos resultarán difíciles de
usar, modificar,
construir y comprender.
La misma genera una ilusión de
simplicidad dado a que minimiza la
cantidad de
características que definen a un
objeto.
Y todo es un objeto. Hay que pensar
en cualquier objeto como una
variable:
almacena datos, permite que se le
"hagan peticiones", pidiéndole que
desempeñe
por sí mismo determinadas
operaciones, etc. En teoría, puede
acogerse cualquier
componente conceptual del problema a
resolver (bien sean perros,
edificios,
servicios, etc.) y representarlos
como objetos dentro de un programa.
4.4 Métodos y mensajes
Un término que se utiliza más
frecuentemente en Java y POO es
método, al ser
"una manera de hacer algo". Si se
desea, es posible seguir pensando en
funciones. Verdaderamente sólo hay
una diferencia sintáctica, pero de
ahora en
adelante se usará el término
"método" en lugar del término
"función".
Los métodos son las operaciones que
pueden realizarse sobre el objeto,
que
normalmente estarán incorporados en
forma de programas (código) que el
objeto
es capaz de ejecutar y que también
pone a disposición de sus
descendientes a
través de la herencia.
Las partes fundamentales de un
método son su nombre, sus
parámetros, el tipo
de retorno y el cuerpo.
He aquí su forma básica:
tipoRetorno nombreMetodo ( /* lista
de parámetros */ ) {
/ * Cuerpo del método */
}
El tipo de retorno es el tipo del
valor que surge del método tras ser
invocado. La
lista de parámetros indica los tipos
y nombres de las informaciones que
es
necesario pasar a ese método. Cada
método se identifica unívocamente
mediante
el nombre del método y la lista de
parámetros.
En Java los métodos pueden crearse
como parte de una clase. Es posible
que un
método pueda ser invocado sólo por
un objeto2, y ese objeto debe ser
capaz de
llevar a cabo esa llamada al método.
Si se invoca erróneamente a un
método de
un objeto, se generará un error en
tiempo de compilación. Se invoca a
un método
de un objeto escribiendo el nombre
del objeto seguido de un punto y el
nombre del
método con su lista de argumentos,
como: nombreObjeto.nombreMetodo
(arg1,
arg2, arg3). Por ejemplo, si se
tiene un método f ( ) que no recibe
ningún
parámetro y devuelve un dato de tipo
int, y si se tiene un objeto a para
el que
puede invocarse a f ( ), es posible
escribir:
int x = a.f ();
El tipo del valor de retorno debe
ser compatible con el tipo de x.
Este acto de invocar a un método
suele denominarse envío de un
mensaje a un
objeto. En el ejemplo de arriba, el
mensaje es f ( ) y el objeto es a.
La
programación orientada a objetos
suele resumirse como un simple
"envío de
mensajes a objetos".
Un ejemplo claro sería el siguiente:
. Ejemplo de Clase Mamífero:
Datos Métodos
Color Desplazarse
Tamaño Masticar
Peso Digerir
Cantidad de dientes Respirar
Cuadrúpedo/bípedo Parpadear
Edad Dormir
Ahora veamos un ejemplo más cercano
a la informática: Una ventana. Clase
Ventana:
Datos Métodos
Etiqueta de encabezado
Cerrarse
Abrirse
Tipo de letra encabezado Minimizarse
Maximizarse
Color de Fondo
Color de letra encabezado
Como puede verse, en esencia la POO
lo que nos permite es ampliar el
tipo de
datos con los que se puede trabajar.
Todos los hombres comparten las
características de la clase hombre.
Sin
embargo todos los hombres son
distintos entre sí, en estatura,
pigmentación, etc.
A cada uno de los hombres
particulares se le llama “objetos de
la clase
hombre”. Cada niño que nace es una
instanciación de la clase hombre.
Entonces, los métodos los podemos
considerar sinónimos de
comportamientos,
operaciones, procedimientos.
La aplicación de los métodos dará
distintos resultados dependiendo de
los
valores con los que trabaje.
Para poder mandar mensajes a los
objetos, necesitamos un operador, a
este le
llamamos el operador de envío. Cada
lenguaje puede tener el suyo, pero
es
frecuente que se utilicen los dos
puntos (‘:’) o el punto (‘.’) (En
C++ es el punto
simple, igual que para referirnos a
los elementos de los struct’s).
Así, si queremos enviarle el mensaje
Caminar al objeto Juan de la clase
hombre,
escribiríamos lo siguiente:
El operador de envío hace que se
ejecute la porción del código
agrupada bajo el
nombre del método, y el método
trabajara con los datos propios de
la instancia de
la clase a la que se refiera.
Referencias a sí mismo
Un caso especial ocurre cuando
estamos codificando un método de una
clase y
tenemos que referirnos a un dato o
un método del propio objeto; estamos
creando
la clase, o por así decirlo, dentro
del objeto mismo.
Entonces, para referirse al propio
objeto, en OOP se hace uso de el
mismo, si
mismo, self (en ingles). Self
(algunos lenguajes utilizan “self”,
pero lo mas común
es que utilicen “this”11: así lo
hacen C++ y Java, por ejemplo.) en
OOP se refiere al
propio objeto con el que se esta
trabajando. Por lo tanto, si estamos
escribiendo
un método de una clase y queremos
enviar un mensaje al propio objeto,
escribiríamos:
This.Ocultar ( );
En este punto, puede parecer que un
programa no es más que un montón de
objetos con métodos que toman otros
objetos como parámetros y envían
mensajes a esos otros objetos. Esto
es, sin duda, mucho de lo que está
curriendo,
pero en otros apartados se verá cómo
hacer el trabajo de bajo nivel
detallado,
tomando decisiones dentro de un
método.
4.5 Encapsulado y ocultación de la
información: Clases
El concepto de clase, es simplemente
una abstracción que hacemos de
nuestra
experiencia sensible. El ser humano
tiende a agrupar seres o cosas
–objetos- con
características similares en grupos
–clases-. Así, aun cuando existen
por ejemplo
multitud de vasos diferentes,
podemos reconocer un vaso en cuanto
lo vemos,
incluso aun cuando ese modelo
concreto de vaso no lo hayamos visto
nunca. El
concepto vaso es una abstracción de
nuestra experiencia sensible. Al
igual que
ciertos ejemplos que pusimos en el
apartado anterior.
Quizás el ejemplo mas claro para
exponer esto lo tengamos en las
taxonomías;
los biólogos han dividido a todo ser
(vivo o inerte) sobre la tierra en
clases.
11 ver el apartado 12.5
Ellos, llaman a cada una de estas
parcelas reino, tipo, clase,
especie, orden,
familia, género, etc.; sin embargo,
nosotros a todas las llamaremos del
mismo
modo: clase. Así, hablaremos de la
clase animal, clase vegetal y clase
mineral, o
de la clase félidos y de las clases
leo (león) y tigres (tigre).
Cada clase posee unas cualidades que
la diferencian de las otras. Así,
por
ejemplo, los vegetales se
diferencian de los minerales –entre
otras muchas cosas-
en que los primeros son seres vivos
y los minerales no. De los animales
se
diferencian en que las plantas son
capaces de sintetizar clorofila a
partir de la luz
solar y los animales no.
Como vemos, el ser humano tiende, de
un modo natural a clasificar los
objetos del
mundo que le rodean en clases; son
definiciones estructuralistas de la
naturaleza
al estilo de la escuela francesa de
Saussure12.
Encapsulación
Un método de una clase puede llamar
a otros métodos de su misma clase y
pude
cambiar los valores de los datos de
su misma clase. Es esta la forma
correcta de
hacerse: los datos de una clase solo
deben ser alterados por los métodos
de su
clase; y no de forma directa (que es
como cambiamos los valores de las
variables
en un programa). Esta es una regla
de oro que no debe de olvidarse:
todos los
datos de una clase son privados y se
accede a ellos mediante métodos
públicos.
12 Ferdinand de Saussure. Lingüista
suizo, considerado el fundador de la
lingüística moderna.
Según los dos modos comentados,
tomemos como ejemplo un objeto
perteneciente a la clase marco,
modificaremos su dato nY1
(coordenada superior
izquierda) de dos modos distintos:
directamente y mediante el método
PonerY1 ( ).
Cambio directo: oCajaGeneral.nY1 =
12;
Cambio mediante invocación de
método: oCajaGeneral.PonerY1 (12);
Es más cómodo el primer método, ya
que hay que escribir menos para
cambiar el
valor del dato y además, a la hora
de construir la clase, no es
necesario crear un
método para cambiar cada uno de los
datos del objeto. Sin embargo, y
como se
ha ido comentando, la OOP recomienda
efusivamente que se utilice el
segundo
procedimiento. La razón es bien
simple: una clase debe ser una
estructura
cerrada, no se debe poder acceder a
ella si no es a través de los
métodos
definidos para ella. Si hacemos nY1
público (para que pueda ser accedido
directamente), estamos violando el
principio de encapsulación.
Encapsulación es la característica
de la POO que hace que un objeto sea
una
caja negra. Se le envía un mensaje
al objeto y este responde ejecutando
el
método apropiado.
Un método de una clase puede llamar
a métodos de la misma clase.
Gracias a la encapsulación una clase
que ha sido programada y probada
puede
usarse sin temor a que la
programación de otros objetos
basados en dichas clases
tengan errores.
En lugar de considerar el programa
como una enorme entidad, la
encapsulación
permite dividir un programa en
componentes más pequeños e
independientes.
Cada componente es autónomo y
realiza su labor independientemente
de los
demás componentes.
La encapsulación mantiene esa
independencia ocultando los detalles
internos de
cada componente, mediante una
interfaz externa.
Una interfaz lista los servicios
proporcionados por un componente. La
interfaz
actúa como un contrato con el mundo
exterior que define exactamente lo
que una
entidad externa puede hacer con el
objeto.
Una interfaz es un panel de control
para el objeto. Al definir una
interfaz puede
especificarse cuales métodos serán
definidos como públicos, privados y
protegidos.
Los métodos públicos son aquellos
que están disponibles para todo
aquel que
cree objetos basados en la clase.
Los métodos privados son aquellos
que solo son invocados por otros
métodos de
la clase.
Cuando un comportamiento se desee
poner a disposición del mundo
exterior,
debe tener acceso público. Lo que se
desee ocultar debe tener acceso
protegido o privado.
¿Porqué utilizar encapsulación?
. Independencia: Se puede reutilizar
el objeto en cualquier parte. Cuando
se
encapsulan de forma apropiada los
objetos, estos no están limitados a
un
programa en particular. Para
utilizarlo solo hay que poner en
acción su
interfaz.
. Transparencia: La encapsulación le
permite hacer cambios transparentes
al objeto, en tanto no se altere la
interfaz.
. Autonomía: El uso de un objeto
encapsulado no causará efectos
secundarios inesperados entre el
objeto y el resto del programa.
Puesto
que el objeto es autónomo, no tendrá
ninguna interacción con el programa
más allá de lo establecido por la
interfaz.
Gracias a la encapsulación, una
clase, cuando ha sido programada y
probada
hasta comprobar que no tiene fallos,
podemos usarla sin miedo a que al
programar otros objetos estos puedan
interferir con los primeros
produciendo
efectos colaterales indeseables que
arruinen nuestro trabajo; esto
también permite
depurar (eliminar errores de
programación) con suma facilidad, ya
que si un objeto
falla, el error solo puede estar en
esa clase y no en ninguna otra.
4.6 Modularidad
Un modulo puede definirse
diversamente, pero generalmente debe
ser un
componente de un sistema mas grande,
y opera independientemente dentro de
las funciones de ese sistema con los
otros componentes.
La modularidad es la propiedad que
mide hasta que punto han estado
compuestos de partes separadas
llamadas módulos. Los programas
tienen
muchas relaciones mutuas directas
entre cualquiera de dos partes
aleatorias del
código del programa.
4.7 Polimorfismo
Se denomina polimorfismo a la
capacidad del código de un programa
para ser
utilizado con diferentes tipos de
datos u objetos. También se puede
aplicar a la
propiedad que poseen algunas
operaciones de tener un
comportamiento diferente
dependiendo del objeto (o tipo de
dato) sobre el que se aplican.
El concepto de polimorfismo se puede
aplicar tanto a funciones como a
tipos de
datos. Así nacen los conceptos de
funciones polimórficas y tipos
polimórficos. Las
primeras son aquellas funciones que
pueden evaluarse y/o ser aplicadas a
diferentes tipos de datos de forma
indistinta; los tipos polimórficos,
por su parte,
son aquellos tipos de datos que
contienen al menos un elemento cuyo
tipo no está
especificado.
Se puede clasificar el polimorfismo
en dos grandes clases:
• Polimorfismo dinámico (o
polimorfismo ad hoc) es aquél en el
que el
código no incluye ningún tipo de
especificación sobre el tipo de
datos sobre
el que se trabaja. Así, puede ser
utilizado a todo tipo de datos
compatible.
• Polimorfismo estático (o
polimorfismo paramétrico) es aquél
en el que
los tipos a los que se aplica el
polimorfismo deben ser explicitados
y
declarados uno por uno antes de
poder ser utilizados.
El polimorfismo dinámico unido a la
herencia es lo que en ocasiones se
conoce
como programación genérica.
Pongamos por ejemplo las clase
hombre, vaca y perro, si todos les
damos la
orden –enviamos el mensaje-Come,
cada uno de ellos sabe como hacerlo
y
realizara este comportamiento a su
modo.
Veamos otro ejemplo algo más
ilustrativo. Tomemos las clases
barco, avión y
coche, todas ellas derivadas de la
clase padre vehículo; si les
enviamos el
mensaje Desplázate, cada una de
ellas sabe como hacerlo.
Realmente, y para ser exactos, los
mensajes no se envían a las clases,
sino a
todos o algunos de los objetos
instaciados de las clases. Así, por
ejemplo,
podemos decirle a los objetos Juan
Sebastián el Cano y Kontiqui, de la
clase
barco que se desplacen, con los que
el resto de los objetos de esa clase
permanecerán inmóviles.
Del mismo modo, si tenemos en
pantalla cinco recuadros (marcos) y
tres textos,
podemos decirle a tres de los
recuadros y a dos de los textos que
cambien de
color y no decírselo a los demás
objetos. Todos estos sabrán como
hacerlo
porque hemos redefinido para cada
uno de ellos su método Pintarse que
bien
podría estar en la clase padre
Visual (conjunto de objetos que
pueden visualizarse
en pantalla).
En programación tradicional, debemos
crear un nombre distinto para la
acción de
pintarse, si se trata de un texto o
de un marco; en POO el mismo nombre
nos sirve
para todas las clases creadas si así
lo queremos, lo que suele ser
habitual. El
mismo nombre suele usarse para
realizar acciones similares en
clases diferentes.
Si enviamos el mensaje Imprímete a
objetos de distintas clases, cada
uno se
imprimirá como le corresponda, ya
que todos saben como hacerlo.
El polimorfismo facilita el trabajo,
ya que gracias a él, el número de
nombre de
métodos que tenemos que recordar
disminuye ostensiblemente.
La mayor ventaja la obtendremos en
métodos con igual nombre aplicados a
las
clases que se encuentran próximas a
la raíz del árbol de clases, ya que
estos
métodos afectaran a todas las clases
que de ellas se deriven.
4.8 Jerarquización: Herencia y
Objetos compuestos
Herencia
Esta es la cualidad más importante
de un sistema POO, la que nos dará
mayor
potencia y productividad,
permitiéndonos ahorrar horas y horas
de codificación y
de depuración de errores.
Sería mejor si pudiéramos hacer uso
de una clase ya existente, clonarla,
y
después hacer al "clon" las
adiciones y modificaciones que sean
necesarias.
Efectivamente, esto se logra
mediante la herencia, con la
excepción de que si se
cambia la clase original (denominada
la clase base, clase súper o clase
padre), el
"clon" modificado (denominado clase
derivada, clase heredada, subclase o
clase
hijo) también reflejaría esos
cambios.
Puede haber más de una clase
derivada. Un tipo hace más que
definir los límites
de un conjunto de objetos; también
tiene relaciones con otros tipos.
Dos tipos
pueden tener características y
comportamientos en común, pero un
tipo puede
contener más características que
otro y también puede manipular más
mensajes
(o gestionarlos de manera distinta).
La herencia expresa esta semejanza
entre
tipos haciendo uso del concepto de
tipos base y tipos derivados. Un
tipo base
contiene todas las características y
comportamientos que comparten los
tipos que
de él se derivan. A partir del tipo
base, es posible derivar otros tipos
para expresar
las distintas maneras de llevar a
cabo esta idea.
Por ejemplo, una máquina de
reciclaje de basura clasifica los
desperdicios. El tipo
base es "basura", y cada desperdicio
tiene su propio peso, valor, etc. y
puede ser
fragmentado, derretido o
descompuesto.
Así, se derivan tipos de basura más
específicos que pueden tener
características
adicionales (una botella tiene un
color), o comportamientos (el
aluminio se puede
modelar, una lata de acero tiene
capacidades magnéticas). Además,
algunos
comportamientos pueden ser distintos
(el valor del papel depende de su
tipo y
condición). El uso de la herencia
permite construir una jerarquía de
tipos que
expresa el problema que se trata de
resolver en términos de los propios
tipos.
Un segundo ejemplo es el clásico de
la "figura geométrica" utilizada
generalmente
en sistemas de diseño por computador
o en simulaciones de juegos. El tipo
base
es "figura" y cada una de ellas
tiene un tamaño, color, posición,
etc. Cada figura
puede dibujarse, borrarse, moverse,
colorearse, etc.
A partir de ésta, se pueden derivar
(heredar) figuras específicas:
círculos,
cuadrados, triángulos, etc.,
pudiendo tener cada uno de los
cuales características
y comportamientos adicionales.
Algunos comportamientos pueden ser
distintos,
como pudiera ser el cálculo del área
de los distintos tipos de figuras.
La jerarquía
de tipos engloba tanto las
similitudes como las diferencias
entre las figuras.
Otro ejemplo, la clase león que se
comenta en la figura de la
clasificación
taxonómica en el apartado 4.5,
hereda cualidades –métodos- de todas
las clases
predecesoras –padres- y posee
métodos propios, diferentes a los
del resto de las
clases. Es decir, las clases van
especializándose según se avanza en
el árbol
taxonómico. Cada vez que creamos una
clase heredada de otra (la padre)
añadimos métodos a la clase padre o
modificamos alguno de los métodos de
la
clase padre.
Veamos que hereda la clase león de
sus clases padre:
Clase Que hereda
Vertebrados Espina dorsal
Mamíferos Se alimenta con leche
materna
Carnívoros Al ser adultos se
alimentan de carne
La clase león hereda todos los
métodos de las clases padre y añade
métodos
nuevos que forman su clase
distinguiéndola del resto de las
clases: por ejemplo el
color de su piel.
Pongamos ahora un ejemplo algo más
informático: supongamos que usted ha
construido una clase que le permite
leer números enteros desde teclado
con un
formato determinado, calcular su IVA
y almacenarlos en un archivo. Si
desea
poder hacer lo mismo con números
reales (para que admitan decimales),
solo
deberá crear una nueva subclase para
que herede de la clase padre todos
sus
métodos y redefinirá solo el método
de lectura de teclado. Esta nueva
clase sabe
almacenar y mostrar los números con
formato porque lo sabe su clase
padre.
Las cualidades comunes que comparten
distintas clases, pueden y deben
agruparse para formar una clase
padre. Por ejemplo, usted podría
derivar las
clases presupuesto y factura de la
superclase pedidos, ya que estas
clases
comparten características comunes.
De este modo, la clase padre
poseería los
métodos comunes a todas ellas y solo
tendríamos que añadir aquellos
métodos
propios de cada una de las
subclases, pudiendo reutilizar el
código escrito en la
superclase desde cada una de las
clases derivadas. Así, si enseñamos
a la clase
padre a imprimirse, cada uno de los
objetos de las clases inferiores
sabrán
automáticamente y sin escribir ni
una sola línea más de código
imprimirse.
Es así, que la herencia es la
cualidad mas importante de la POO ya
que le permite
reutilizar todo el código escrito
para las superclases re-escribiendo
solo aquellas
diferencias que existan entre estas
y las subclases.
Muchas veces las clases
–especialmente aquellas que se
encuentran próximas a
la raíz en el árbol de la jerarquía
de clases- son abstractas. Es decir,
solo existen
para proporcionar una base para la
creación de clases mas especificas,
y por lo
tanto no puede instanciarse de
ellas; son las clases virtuales.
Una subclase hereda de su superclase
solo aquellos miembros visibles
desde la
clase hija y por lo tanto solo puede
redefinir estos.
Una subclase tiene forzosamente que
redefinir aquellos métodos que han
sido
definidos como abstractos en la
clase padre o padres.
Es habitual que la herencia suscite
un pequeño debate: ¿debería la
herencia
superponer sólo las funciones de la
clase base (sin añadir nuevas
funciones
miembro que no se encuentren en
ésta)?. Esto significaría que el
tipo derivado sea
exactamente el mismo tipo que el de
la clase base, puesto que tendría
exactamente la misma interfaz.
Consecuentemente, es posible
sustituir un objeto
de la clase derivada por otro de la
clase base. A esto se le puede
considerar
sustitución pura, y a menudo se le
llama el principio de sustitución.
De cierta
forma, ésta es la manera ideal de
tratar la herencia. Habitualmente, a
la relación
entre la clase base y sus derivadas
que sigue esta filosofía se le
denomina
relación es-un, pues es posible
decir que "un círculo es un
polígono". Una manera
de probar la herencia es determinar
si es posible aplicar la relación
es-un a las
clases en liza, y tiene sentido.
Hay veces en las que es necesario
añadir nuevos elementos a la
interfaz del tipo
derivado, extendiendo así la
interfaz y creando un nuevo tipo.
Éste puede ser
también sustituido por el tipo base,
pero la sustitución no es perfecta
pues las
nuevas funciones no serían
accesibles desde el tipo base. Esta
relación puede
describirse como la relación
es-como-un" el nuevo tipo tiene la
interfaz del viejo
pero además contiene otras
funciones, así que no se puede decir
que sean
exactamente iguales. Considérese por
ejemplo un acondicionador de aire.
Supongamos que una casa está
cableada y tiene las botoneras para
refrescarla,
es decir, tiene una interfaz que
permite controlar la temperatura.
Imagínese que se
estropea el acondicionador de aire y
se reemplaza por una bomba de calor
que
puede tanto enfriar como calentar.
La bomba de calor es-como-un
acondicionador
de aire, pero puede hacer más
funciones. Dado que el sistema de
control de la
casa está diseñado exclusivamente
para controlar el enfriado, se
encuentra
restringido a la comunicación con la
parte "enfriadora" del nuevo objeto.
Es
necesario extender la interfaz del
nuevo objeto, y el sistema existente
únicamente
conoce la interfaz original.
Por supuesto, una vez que uno ve
este diseño, está claro que la clase
base
"sistema de enfriado" no es lo
suficientemente general, y debería
renombrarse a
"sistema de control de temperatura"
de manera que también pueda incluir
calentamiento -punto en el que el
principio de sustitución funcionará.
Sin embargo,
este diagrama es un ejemplo de lo
que puede ocurrir en el diseño y en
el mundo
real.
Cuando se ve el principio de
sustitución es fácil sentir que este
principio (la
sustitución pura) es la única manera
de hacer las cosas, y de hecho, es
bueno
para los diseños que funcionen así.
Pero hay veces que está claro que
hay que
añadir nuevas funciones a la
interfaz de la clase derivada.
4.9 Ligadura Dinámica
La ligadura en las llamadas a
métodos
La conexión de una llamada a un
método se denomina ligadura. Cuando
se lleva a
cabo la ligadura antes de ejecutar
el programa (por parte del
compilador y el
montador, cuando lo hay) se denomina
ligadura temprana. Puede que este
término parezca extraño pues nunca
ha sido una opción con los lenguajes
procedurales. Los compiladores de C
tienen un único modo de invocar a un
método utilizando la ligadura
temprana.
La solución es la ligadura tardía,
que implica que la correspondencia
se da en
tiempo de ejecución, basándose en el
tipo de objeto. La ligadura tardía
se
denomina también dinámica o en
tiempo de ejecución.
Cuando un lenguaje implementa la
ligadura tardía, debe haber algún
mecanismo
para determinar el tipo de objeto en
tiempo de ejecución e invocar al
método
adecuado. Es decir, el compilador
sigue sin saber el tipo de objeto,
pero el
mecanismo de llamada a métodos
averigua e invoca al cuerpo de
método
correcto. El mecanismo de la
ligadura tardía varía de un lenguaje
a otro, pero se
puede imaginar que es necesario
instalar algún tipo de información
en los objetos.
Toda ligadura de métodos en Java se
basa en la ligadura tardía a menos
que se
haya declarado un método como
constante. Esto significa que
ordinariamente no
es necesario tomar decisiones sobre
si se dará la ligadura tardía, sino
que esta
decisión se tomará automáticamente.
5. Diseño tradicional vrs. Diseño OO
Como hemos visto hasta ahora, el
Diseño Orientado a Objetos ofrece
muchas
alternativas para la resolución de
problemas al programador, y hemos
mencionado
también los distintos paradigmas de
programación.
Ahora, repasemos puntos clave del
diseño OO:
• El diseño OO se enfoca sobre
objetos y clases basados en el mundo
real.
• Hace un énfasis en el estado,
comportamientos e interacciones de
objetos
• Provee las siguientes ventajas:
o Desarrollo rápido de aplicaciones
(RAD)
o Aumenta la calidad
o Provee un fácil mantenimiento
o Mejora la modificación
o Incrementa el reutilizamiento de
software
Pero como todo en este mundo,
también tiene sus limitaciones e
inconvenientes.
De las primeras no cabe ni hablar,
porque aun cuando sea el sistema mas
apropiado del que se dispone para
programar, todavía se enfrenta con
ciertos
problemas de diseño.
El mayor inconveniente real proviene
de un “error” de planteamiento; y
como casi
siempre, estos son de mucha mayor
dificultad a la hora de
solucionarlos. El
problema, según comenta uno de los
mejores analistas de hoy en día,
Jeff
Duntemann15, en un articulo de la
revista Dr. Dobbs16, es que “la
encapsulación y
la herencia se hallan en esquinas
opuestas de la casa”.
15 Escritor, Editor, Tecnólogo. Más
en www.duntemann.com
16 Dr. Dobbs Journal, más en
www.ddj.com
Es decir, la encapsulación choca
frontalmente con la herencia, y sin
embargo, son
dos piedras angulares de la POO.
Por un lado decimos que los objetos
deben ser totalmente independientes
y
autónomos, y por otro, al heredar
unas clases de otras, estamos
dejando fuera de
un objeto perteneciente a una clase
hija gran parte de la información
que esta
necesita para poder comportarse.
Otro inconveniente que se puede
observar es el que estriba en la
imposibilidad de
utilización conjunta de objetos de
distintos programadores.
Un ejemplo simple, supongamos que se
monta un coche en un garaje, puede
comprar un carburador de cualquier
marca y montarlo en un coche de otra
marca,
unos asientos de uno y montarlos en
la carrocería de otro; esto mismo
puede
hacerse en POO.
Si Microsoft fabrica la clase Menú,
que deriva de la clase Visual y
Borland fabrica
la clase Ventana aunque también
derive de la clase Visual, no puede
conseguir
coger el menú de una y la ventana de
la otra, a menos que todas las
clases
superiores (en este caso solo una)
sean exactamente iguales: tengan el
mismo
nombre, contengan los mismos datos y
los mismos métodos y en estos, todos
los
parámetros deben coincidir en orden
y en tipo.
Este problema por ahora no tiene
solución, y lo peor es que no se
vislumbra que la
tenga en un futuro próximo, ya que
para ello seria necesario normalizar
las clases
(al menos las mas habituales), pero
si no nos ponemos de acuerdo para
utilizar un
mismo HTML ¿Cómo nos vamos a poner
de acuerdo para esto?
Critica
Los taxonomías jerárquicas no
coinciden a menudo con el mundo real
y los
cambios del mundo real según algunos
críticos, y debe evitarse. Sin
embargo,
muchos defensores de POO también
hacen pensar en evitar las
jerarquías y usar
las técnicas de POO en cambio como
la composición.
También, muchos sienten que POO
corre lo opuesto a la filosofía de
planeación
correlativa y base de datos
relacionales, mientras se vuelve a
los arreglos de la
base de datos de navegación de los
años sesenta. No está claro que ésta
es la
falta de POO, desde que la
planeación de bases de datos es
fundamentalmente
basada en las diferentes premisas
que la planeación basada en objetos.
En
cualquier caso, las bases de datos
relacionales trazan a las
asociaciones en los
modelos basados en objetos, y las
diferencias parecen ser
completamente
debidas a las diferencias en el
enfoque.
Hay una historia de
desinterpretación de la relación
entre planear basado en
objetos y en la correlación a lo que
puede enturbiar este problema. Hay
también,
variaciones en las opiniones sobre
los papeles y definiciones de cada
uno.
La desigualdad de impedancia entre
las bases de datos y POO se causa
por la
diferencia de balanza entre
funcionamientos realizados por los
objetos y bases de
datos; las transacciones de la base
de datos, la unidad más pequeña de
trabajo
realizada por las bases de datos,
son mucho más grandes que cualquier
funcionamiento proporcionado por los
objetos de POO.
Mientras se exige que POO es buena
para "aplicaciones grandes”, otros
sienten
que deben reducirse las aplicaciones
grandes en cambio a muchas
aplicaciones
pequeñas, como procedimientos
manejados a eventos que " se
alimentan" fuera
de una base de datos y armazones de
interfaz de usuario basadas en
declaratorias de programación.
Está reconocido que POO
necesariamente no quiere decir falta
de complejidad.
6. Evolución de los Lenguajes
Orientados a Objetos
Los conceptos de la programación
orientada a objetos tienen origen en
Simula 67,
un lenguaje diseñado para hacer
simulaciones, creado por Ole-Johan
Dahl y
Kristen Nygaard del Centro de
Cómputo Noruego en Oslo. Según se
informa, la
historia es que trabajaban en
simulaciones de naves, y fueron
confundidos por la
explosión combinatoria de cómo las
diversas cualidades de diversas
naves podían
afectar unas a las otras. La idea
ocurrió para agrupar los diversos
tipos de naves
en diversas clases de objetos,
siendo responsable cada clase de
objetos de definir
sus propios datos y comportamientos.
Fueron refinados más tarde en
Smalltalk,
que fue desarrollado en Simula en
Xerox PARC(Palo Alto Research
Center) pero
diseñado para ser un sistema
completamente dinámico en el cual
los objetos se
podrían crear y modificar "en
marcha" en lugar de tener un sistema
basado en
programas estáticos.
La programación orientada a objetos
tomó posición como la metodología de
programación dominante a mediados de
los años ochenta, en gran parte
debido a
la influencia de C++, una extensión
del lenguaje de programación C. Su
dominación fue consolidada gracias
al auge de las Interfaces gráficas
de usuario
(GUI por sus siglas en ingles), para
los cuales la programación orientada
a objetos
está particularmente bien adaptada.
En el ETH de Zürich, Niklaus Wirth y
sus colegas tuvieron también
investigaciones
como tópicos de abstracción de datos
y programación modular. El lenguaje
Modula-2 incluye ambos, y su diseño
sucesor, Oberon incluye una
aproximación
distintiva a orientación a objetos,
clases y semejantes. El acercamiento
es
diferente a Smalltalk, y muy
diferente a C++.
Las características de Orientación a
Objetos han sido añadidas a muchos
lenguajes existentes durante el
tiempo, incluyendo Ada, BASIC, Lisp,
Fortran,
Pascal, y otros. Agregando esos
aspectos a lenguajes que no fueron
inicialmente
diseñados para ello condujo a
problemas con la compatibilidad y
mantenimiento
de código. Los lenguajes Orientados
a Objetos “Puros”, por otra parte,
carecían de
aspectos que muchos programadores
han venido dependiendo. Para cruzar
esta
brecha, muchos intentos han sido
hechos para crear nuevos lenguajes
basados en
métodos Orientados a Objetos pero
permitiendo algunos aspectos
procedurales
en formas “seguras”.
El lenguaje Eiffel de Bertrand
Meyer’s17 fue un temprano y
moderadamente exitoso
lenguaje con esos objetivos.
En la década pasada Java ha emergido
ampliamente en uso parcialmente por
su
similitud a C y C++, pero quizás lo
más importante de su implementación
es el uso
de una maquina virtual que es
proyectada a correr código
inalterado sobre muchas
plataformas distintas. Esta ultima
característica lo ha hecho muy
atractivo en
amplias tiendas de desarrollo y
ambientes heterogéneos.
La iniciativa de la plataforma .NET
de Microsoft ha tenido un objetivo
similar e
incluye/soporta varios nuevos
lenguajes, o variantes de algunos
viejos.
Más recientemente, un número de
lenguajes ha surgido para ser
primariamente
orientados a objetos aun compatibles
con la metodología procedural, tales
como
Python y Ruby. Al lado de Java,
probablemente el mas comercial
lenguaje
orientado a objetos reciente es
Visual Basic .NET y C# diseñados
para la
plataforma .NET de Microsoft.
Tal como la programación procedural
lleva a refinamientos de técnicas
como la
programación estructurada, el
software orientado a objetos moderno
diseña
métodos que incluye refinamiento
como el uso de diseño de patrones,
diseño por
convenios, y lenguajes de modelado
(tal es UML, usado en ingeniería de
software).
17 Bertrand Meyer, (nacido en
Francia en 1950). Es uno de los
primeros y vocales más proponentes
de la POO. Sus libros
sobre “Construcción de Software” son
considerados los mejores trabajos
presentes para la presentación de
POO.
Para el aprendizaje
En el pasado, han existido muchas
disputas como cual es el mejor
lenguaje para
comenzar con la programación
orientada a objetos. Hay dos
diferentes enfoques a
tomar cuando se comienza con este
estilo de programación. El primero
es la idea
que lo mejor es empezar con un
lenguaje simple como Java, donde el
aprendizaje
se enfoca sobre la orientación a
objetos y no es perturbado por
semánticas
complejas del lenguaje. Aun así,
otra razón es que lo mejor es
empezar con un
lenguaje más complicado como C++, el
cual soporta con más precisión todas
las
estructuras y capacidades prescritas
por el lenguaje de modelado
unificado (UML),
aunque no hay un lenguaje conocido
el cual esencialmente soporte
totalmente las
capacidades de UML. En la versión
utilizada para el entorno de
desarrollo Eclipse
para este ensayo esta instalado la
versión Eclipse UML 3.10 Free
Edition de
Omondo.
7. Lenguajes orientados a objetos
Entre los lenguajes orientados a
objetos destacan los siguientes:
• Smalltalk
• Objective-C
• C++
• Ada 95
• Java
• Ocaml
• Python
• Delphi
• Lexico (en castellano)
• C#
• Eiffel
• Ruby
• ActionScript
• Visual Basic
• PHP
• PowerBuilder
• Clarion
Estos lenguajes de programación son
muy avanzados en orientación a
objetos.
Al igual que C++ otros lenguajes,
como OOCOBOL, OOLISP, OOPROLOG y
Object REXX, han sido creados
añadiendo extensiones orientadas a
objetos a un
lenguaje de programación clásico.
Un nuevo paso en la abstracción de
paradigmas de programación es la
Programación Orientada a Aspectos
(POA). Aunque es todavía una
metodología
en estado de maduración, cada vez
atrae a más investigadores e incluso
proyectos comerciales en todo el
mundo.
8. Java
8.1 ¿Qué es Java?
Java es un lenguaje de desarrollo de
propósito general, y como tal es
válido para
realizar todo tipo de aplicaciones
profesionales.
Entonces, ¿es simplemente otro
lenguaje más? Definitivamente no.
Incluye una
combinación de características que
lo hacen único y está siendo
adoptado por
multitud de fabricantes como
herramienta básica para el
desarrollo de aplicaciones
comerciales de gran repercusión.
¿Qué lo hace distinto de los demás
lenguajes?
Una de las características más
importantes es que los programas
“ejecutables”,
creados por el compilador de Java,
son independientes de la
arquitectura. Se
ejecutan indistintamente en una gran
variedad de equipos con diferentes
microprocesadores y sistemas
operativos.
• De momento, es público. Puede
conseguirse un JDK (Java Developer's
Kit) o
Kit de desarrollo de aplicaciones
Java gratis. No se sabe si en un
futuro seguirá
siéndolo.
• Permite escribir Applets (pequeños
programas que se insertan en una
página
HTML) y se ejecutan en el ordenador
local.
• Se pueden escribir aplicaciones
para intrarredes, aplicaciones
cliente/servidor,
aplicaciones distribuidas en redes
locales y en Internet.
• Es fácil de aprender y está bien
estructurado.
• Las aplicaciones son fiables.
Puede controlarse su seguridad
frente al acceso a
recursos del sistema y es capaz de
gestionar permisos y criptografía.
También,
según Sun, la seguridad frente a
virus a través de redes locales e
Internet está
garantizada. Aunque al igual que ha
ocurrido con otras tecnologías y
aplicaciones, se han descubierto, y
posteriormente subsanado, “agujeros”
en la
seguridad de Java.
¿Qué se puede programar con Java?
Si tenía preconcebida la idea de que
con Java sólo se programan applets
para
páginas Web, está completamente
equivocado. Ya que Java es un
lenguaje de
propósito general, puede programarse
en él cualquier cosa:
• Aplicaciones independientes. Como
con cualquier otro lenguaje de
propósito
general.
• Applets. Pequeñas aplicaciones que
se ejecutan en un documento HTML,
siempre y cuando el navegador
soporte Java, como ocurre con los
navegadores HotJava y las últimas
versiones de Netscape y el
explorador de
Internet de Microsoft.
Para todo aquel que no conozca la
programación orientada a objetos,
este
lenguaje es ideal para aprender
todos sus conceptos, ya que en cada
paso de su
aprendizaje se va comprobando que
las cosas se hacen en la forma
natural de
hacerlas, sin sorpresas ni
comportamientos extraños de los
programas. A medida
que se va aprendiendo, se va
fomentando en el programador, y sin
esfuerzo, un
buen estilo de programación
orientada a objetos. En realidad, no
puede ser de otra
forma, ya que Java impide “hacer
cosas extrañas” y, además, no
permite
“abandonar” la programación
orientada a objetos, como ocurre con
otros lenguajes
de programación. Esto es bastante
conveniente, de lo contrario, un
programador
que está aprendiendo puede sentir la
tentación de “volver” a lo que
conoce (la
programación tradicional).
8.2 Breve Historia de Java
El lenguaje Java™ fue creado por Sun
Microsystems Inc. en un proceso por
etapas que arranca en 1990, año en
el que Sun creó un grupo de trabajo,
liderado
por James Gosling, para desarrollar
un sistema para controlar
electrodomésticos e
incluso PDAs o Asistentes Personales
(pequeños ordenadores) que, además,
permitiera la conexión a redes de
ordenadores. Se pretendía crear un
hardware
polivalente, con un Sistema
Operativo eficiente (SunOS) y un
lenguaje de
desarrollo denominado Oak (roble),
el precursor de Java. El proyecto
finalizó en
1992 y resultó un completo fracaso
debido al excesivo coste del
producto, con
relación a alternativas similares,
tras lo cual el grupo se disolvió.
Por entonces aparece Mosaic y la
World Wide Web. Después de la
disolución del
grupo de trabajo, únicamente quedaba
del proyecto el lenguaje Oak.
Gracias a
una acertada decisión de distribuir
libremente el lenguaje por la Red de
Redes y al
auge y la facilidad de acceso a
Internet, propiciado por la WWW, el
lenguaje se
popularizó y se consiguió que una
gran cantidad de programadores lo
depurasen y
terminasen de perfilar la forma y
usos del mismo. A partir de este
momento, el
lenguaje se difunde a una velocidad
vertiginosa, añadiéndosele numerosas
clases
y funcionalidad para TCP/IP. El
nombre del lenguaje tuvo que ser
cambiado ya
que existía otro llamado Oak. El
nombre “Java” surgió en una de las
sesiones de
“brainstorming” celebradas por el
equipo de desarrollo del lenguaje.
Buscaban un
nombre que evocara la esencia de la
tecnología (viveza, animación,
rapidez,
interactividad…). Java fue elegido
de entre muchísimas propuestas. No
es un
acrónimo, sino únicamente algo
humeante, caliente y que a muchos
programadores les gusta beber en
grandes cantidades: una taza de café
(Java en
argot Inglés americano). De esta
forma, Sun lanzó las primeras
versiones de Java
a principios de 1995.
Desde entonces, Sun ha sabido
manejar inteligentemente el éxito
obtenido por su
lenguaje, concediéndose licencias a
cualquiera sin ningún problema,
fomentando
su uso entre la comunidad
informática y extendiendo las
especificaciones y
funcionalidad del lenguaje.
8.3 Características de Java
• Es intrínsecamente orientado a
objetos.
• Funciona perfectamente en red.
• Aprovecha características de la
mayoría de los lenguajes modernos
evitando
sus inconvenientes. En particular
los del C++.
• Tiene una gran funcionalidad
gracias a sus librerías (clases).
• NO tiene punteros manejables por
el programador, aunque los maneja
interna
y transparentemente.
• El manejo de la memoria no es un
problema, la gestiona el propio
lenguaje y
no el programador.
• Genera aplicaciones con pocos
errores posibles.
• Incorpora Multi-Threading (para
permitir la ejecución de tareas
concurrentes
dentro de un mismo programa).
El lenguaje Java puede considerarse
como una evolución del C++. La
sintaxis es
parecida a la de este lenguaje, por
lo que se hace referencia a dicho
lenguaje. A
pesar de que puede considerarse como
una evolución del C++ no acarrea los
inconvenientes del mismo, ya que
Java fue diseñado “partiendo de
cero”, es decir,
un lenguaje “puro” y no necesitaba
ser compatible con versiones
anteriores de
ningún lenguaje como ocurre con C++
y C.
Gracias a que fue diseñado
“partiendo de cero” ha conseguido
convertirse en un
lenguaje orientado a objetos puro,
limpio y práctico. No permite
programar
mediante otra técnica que no sea la
programación orientada a objetos y,
una vez
superado el aprendizaje de la
programación orientada a objetos, es
realmente
sencillo aprender Java.
¿El lenguaje es Compilado o
Interpretado? Ni una cosa ni la
otra. Aunque
estrictamente hablando es
interpretado, necesita de un proceso
previo de
compilación. Una vez “compilado” el
programa, se crea un archivo que
almacena
lo que se denomina bytecodes o
j_code (seudo código prácticamente
al nivel de
código máquina). Para ejecutarlo, es
necesario un “intérprete”, la JVM
(Java
Virtual Machine) máquina virtual
Java. De esta forma, es posible
compilar el
programa en una estación UNIX y
ejecutarlo en otra con Windows
utilizando la
máquina virtual Java para Windows.
Esta JVM se encarga de leer los
bytecodes y
traducirlos a instrucciones
ejecutables directamente en un
determinado
microprocesador, de una forma
bastante eficiente.
Que el programa deba ser
“interpretado” no hace que sea poco
eficiente en cuanto
a velocidad, ya que la
interpretación se hace prácticamente
al nivel de código
máquina. Por ejemplo, es mucho más
rápido que cualquier otro programa
interpretado como por ejemplo Visual
Basic, aunque es más lento que el
mismo
programa escrito en C++. Esta
deficiencia en cuanto a la
velocidad, puede ser
aminorada por los compiladores
Just-In-Time (JIT). Un compilador
JIT transforma
los bytecodes de un programa o un
applet en código nativo de la
plataforma donde
se ejecuta, por lo que es más
rápido. Suelen ser incorporados por
los
navegadores, como Netscape o
Internet Explorer.
El lenguaje Java es robusto. Las
aplicaciones creadas en este
lenguaje son
susceptibles de contener pocos
errores, principalmente porque la
gestión de
memoria y punteros es realizada por
el propio lenguaje y no por el
programador.
Bien es sabido que la mayoría de los
errores en las aplicaciones vienen
producidos por fallos en la gestión
de punteros o la asignación y
liberación de
memoria. Además, el lenguaje
contiene estructuras para la
detección de
excepciones (errores de ejecución
previstos) y permite obligar al
programador a
escribir código fiable mediante la
declaración de excepciones posibles
para una
determinada clase reutilizable.
La Máquina Virtual Java (JVM)
La máquina virtual Java es la idea
revolucionaria18 del lenguaje. Es la
entidad que
proporciona la independencia de
plataforma para los programas Java
“compilados”
en byte-code.
18 Otros sistemas en el pasado, como
por ejemplo el Pascal UCSD
compilaban a un código intermedio
(p-code) que luego
era interpretado al ejecutar el
programa.
Un mismo programa fuente compilado
en distintas plataformas o sistemas
operativos, genera el mismo archivo
en byte-code. Esto es lógico, ya que
se
supone que el compilador de Java
traduce el archivo fuente a código
ejecutable
por una máquina que únicamente
existe en forma virtual (aunque se
trabaja en la
construcción de microprocesadores
que ejecuten directamente el
byte-code).
Evidentemente, si un mismo programa
en byte-code puede ser ejecutado en
distintas plataformas es porque
existe un traductor de ese byte-code
a código
nativo de la máquina sobre la que se
ejecuta. Esta tarea es realizada por
la JVM.
Existe una versión distinta de esta
JVM para cada plataforma. Esta JVM
se carga
en memoria y va traduciendo “al
vuelo”, los byte-codes a código
máquina. La JVM
no ocupa mucho espacio en memoria,
piénsese que fue diseñada para poder
ejecutarse sobre pequeños
electrodomésticos como teléfonos,
televisores, etc.
8.4 Novedades en la versión 1.5
1. Introducción
En este documento se resumen las
principales novedades que ofrece la
versión
1.5 de Java, separándolas en
diferentes áreas. Para una
explicación más
detallada, consultar la página de
Sun:
https://java.sun.com/j2se/1.5.0/docs/relnotes/features.html
2. Novedades en la máquina virtual
Autoajuste de memoria mejorado
La capacidad de autoajustar la
cantidad de memoria necesaria (pila,
recolector de
basura, etc.) se ve mejorada en esta
versión.
Compartir clases
Al instalar la máquina virtual, se
cargan en memoria un conjunto de
clases del
sistema, en forma de representación
interna, de forma que las siguientes
llamadas
a la máquina virtual ya encuentren
estas clases mapeadas en memoria, y
se
permita que los datos de estas
clases se compartan entre múltiples
procesos
dentro de la JVM.
Ajuste del recolector de basura
Relacionado con el autoajuste de
memoria, el recolector de basura
también se
autoadapta a las necesidades de
memoria de la aplicación, para
evitar que el
usuario tenga que ajustar su tamaño
y características desde línea de
comandos.
Tratamiento de errores fatales
El mecanismo de listado de errores
fatales se ha mejorado de forma que
se
obtengan mejores diagnósticos a
partir de las salidas generadas por
dichos
errores.
3. Novedades en el lenguaje
Tipos de datos parametrizados
(generics)
Esta mejora permite tener
colecciones de tipos concretos de
datos, lo que permite
asegurar que los datos que se van a
almacenar van a ser compatibles con
un
determinado tipo o tipos. Por
ejemplo, podemos crear un Vector que
sólo
almacene Strings, o una HashMap que
tome como claves Integers y como
valores
Vectors. Además, con esto nos
ahorramos las conversiones cast al
tipo que
deseemos, puesto que la colección ya
se asume que será de dicho tipo.
Ejemplo
// Vector de cadenas
Vector<String> v = new
Vector<String>();
v.addElement("Hola");
String s = v.getElementAt(0);
v.addElement(new Integer(20)); //
Daría error!!
// HashMap con claves enteras y
valores de vectores
HashMap<Integer, Vector> hm = new
HashMap<Integer, Vector>();
hm.put(1, v);
Vector v2 = hm.get(1);
Autoboxing
Esta nueva característica evita al
programador tener que establecer
correspondencias manuales entre los
tipos simples (int, double, etc.) y
sus
correspondientes wrappers o tipos
complejos (Integer, Double, etc.).
Podremos
utilizar un int donde se espere un
objeto complejo (Integer), y
viceversa.
Ejemplo
Vector<Integer> v = new
Vector<Integer>();
v.addElement(30);
Integer n = v.getElementAt(0);
n = n+1;
Mejoras en Ciclos
Se mejoran las posibilidades de
recorrer colecciones y arrays,
previniendo índices
fuera de rango, y pudiendo recorrer
colecciones sin necesidad de acceder
a sus
iteradores (Iterator).
Ejemplo
// Recorre e imprime todos los
elementos de un array
int[] arrayInt = {1, 20, 30, 2, 3,
5};
for(int elemento: arrayInt)
System.out.println (elemento);
// Recorre e imprime todos los
elementos de un Vector
Vector<String> v = new
Vector<String>();
for(String cadena: v)
System.out.println (cadena);
Tipo enum
El tipo enum que se introduce
permite definir un conjunto de
posibles valores o
estados, que luego podremos utilizar
donde queramos:
Ejemplo
// Define una lista de 3 valores y
luego comprueba en un switch// cuál
es el valor que tiene un objeto de
ese tipo
enum EstadoCivil {soltero, casado,
divorciado};
EstadoCivil ec = EstadoCivil.casado;
ec = EstadoCivil.soltero;
switch(ec)
{
case soltero: System.out.println("Es
soltero");
break;
case casado: System.out.println("Es
casado");
break;
case
divorciado:System.out.println("Es
divorciado");
break;
}
Imports estáticos
Los imports estáticos permiten
importar los elementos estáticos de
una clase, de
forma que para referenciarlos no
tengamos que poner siempre como
prefijo el
nombre de la clase. Por ejemplo,
podemos utilizar las constantes de
color de la
clase java.awt.Color, o bien los
métodos matemáticos de la case Math.
Ejemplo
import static java.awt.Color;
import static java.lang.Math;
public class...
{
...
JLabel lbl = new JLabel();
lbl.setBackground(white); // Antes
sería
Color.white
...
double raiz = sqrt(1252.2); // Antes
sería
Math.sqrt(...)
}
Argumentos variables
Ahora Java permite pasar un número
variable de argumentos a una función
(como
sucede con funciones como printf en
C). Esto se consigue mediante la
expresión
"..." a partir del momento en que
queramos tener un número variable de
argumentos.
Ejemplo
// Funcion que tiene un parámetro
String obligatorio
// y n parámetros int opcionales
public void miFunc(String param,
int... args)
{
...
// Una forma de procesar n
parametros variables
for (int argumento: args)
{
...
}
...
}
...
miFunc("Hola", 1, 20, 30, 2);
miFunc("Adios");
Metainformación
Se tiene la posibilidad de añadir
ciertas anotaciones en campos,
métodos, clases y
otros elementos, que permitan a las
herramientas de desarrollo o de
despliegue
leerlas y realizar ciertas tareas.
Por ejemplo, generar archivos
fuentes, archivos
XML, o un Stub de métodos para
utilizar remotamente con RMI.
Un ejemplo más claro lo tenemos en
las anotaciones que ya se utilizan
para la
herramienta Javadoc. Las marcas
@deprecated no afectan al
comportamiento de
los métodos que las llevan, pero
previenen al compilador para que
muestre una
advertencia indicando que el método
que se utiliza está desaconsejado.
También
se tienen otras marcas @param,
@return, @see, etc., que utiliza
Javadoc para
generar las páginas de documentación
y las relaciones entre ellas.
Ejemplo
// Definición de una interfaz
mediante metainformacion
public @interface MiInterfaz
{
int metodo1();
String metodo2();
}
4. Novedades en librerías
principales
Red
Se han añadido cambios y mejoras
para el trabajo en red, como:
• Soporte para IPv6 en Windows XP y
2003
• Establecimiento de timeouts para
conectar y leer
• API para lanzar aplicaciones RMI a
través de inetd
• La clase InetAddress permite
testear si una URL es alcanzable
(utilidad
ping)
• Otras mejoras en el tratamiento de
cookies, servidores proxy,
tratamiento
de URLs, etc.
Seguridad
Hay bastantes mejoras en seguridad.
Se da soporte a más estándares de
seguridad (SASL, OCSP, TSP, etc.),
hay mejoras en la escalabilidad a
través de
SSLEngine, en criptografía, etc.
Internacionalización
Mediante la internacionalización
podemos construir una aplicación que
se adapte
a varios idiomas, formatos
monetarios, de fecha, etc., sin
tener que reprogramarla.
En este aspecto, se añaden mejoras
en la versión 1.5, relacionadas con:
• La gestión de juegos de caracteres
se basa en el formato Unicode 4.0,
lo
que afecta a las clases Character y
String, entre otras.
• La clase DecimalFormat se ha
modificado para poder procesar
elementos
de tipo BigDecimal o BigInteger sin
perder precisión
• Se han añadido nuevos Locales
soportados, como el vietnamita.
Formateador
La clase Formatter permite dar
formato (justificación y
alineamiento, formatos
numéricos, de fecha, etc.) a las
cadenas y otros tipos de datos,
siguiendo un estilo
parecido al printf de C. También se
permite mediante la interfaz
Formattable dar
formatos (limitados) a tipos creados
por el usuario.
Ejemplo
// Uso de formatter para construir
cadenas formateadas
StringBuilder sb = new
StringBuilder();
Formatter f = new Formatter(sb,
Locale.US);
f.format("Hola, %1$2s, esta es tu
visita numero %2$d", "Pepe",
20);
// Resultaría: "Hola, Pepe, esta es
tu visita numero 20"
// También se tienen unos métodos
predefinidos en ciertas clases
System.out.format("Hola, %1$2s, esta
es tu visita numero %2$d",
"Pepe", 20);
System.err.printf("Hola, %1$2s, esta
es tu visita numero %2$d",
"Pepe", 20);
String s = String.format("Hola,
%1$2s", "Pepe");
Escaneador
La clase Scanner permite parsear un
flujo de entrada (archivo, cadena de
texto,
stream de datos, etc.), y extraer
tokens siguiendo un determinado
patrón o tipo de
datos. También se permite trabajar
con expresiones regulares para
indicar qué
patrones se deben buscar.
Ejemplo
// Lectura de enteros de la entrada
estándar
Scanner sc =
Scanner.create(System.in);
int n = sc.nextInt();
// Lectura de todos los doubles de
un archivo
Scanner sc = Scanner.create(new
File("miFich.txt"));
while (sc.hasNextDouble())
double d = sc.nextDouble();
// Uso de otros delimitadores
String s = "Esto hola es hola 1 hola
ejemplo";
Scanner sc =
Scanner.create(s).useDelimiter("\\s*hola\\s*");
System.out.println(sc.next());
System.out.println(sc.next());
System.out.println(sc.next());
// Sacaría Esto \n es \n 1
Arquitectura de JavaBeans
La arquitectura de JavaBeans se
encuentra dentro del paquete
java.beans. Se ha
añadido una nueva clase,
IndexedPropertyChangeEvent, subclase
de
PropertyChangeEvent, para dar
soporte a eventos que respondan a
cambios en
propiedades indexadas (propiedades
que utilicen un índice para
identificar la parte
del bean que haya cambiado). También
se han añadido mejoras a la hora de
crear
editores de propiedades de beans
(PropertyEditor), como el método
createPropertyEditor(...), y
constructores públicos para la clase
PropertyEditorSupport.
Arquitectura de colecciones
Como se ha comentado antes, las
colecciones (estructura que contiene
clases e
interfaces como Collection, Vector,
ArrayList, etc.) dan soporte a
nuevas
características del lenguaje, como
el autoboxing, mejoras en los Ciclos
(for) , y el
uso de generics. Además, se han
añadido interfaces nuevos, como
Queue,
BlockingQueue y ConcurrentMap, con
algunas implementaciones concretas
de
dichas interfaces. Además, se tienen
nuevas implementaciones de List, Set
y Map.
Manipulación de bits
Los wrappers de tipos simples (es
decir, clases como Integer, Long,
Double, Char)
soportan operaciones de bits, como
highestOneBit, lowestOneBit,
rotateLeft,
rotateRight, reverse, etc.
Elementos matemáticos
El paquete java.math también ha
sufrido modificaciones, como la
adición en la
clase BigDecimal de soporte para
cálculo en coma flotante de
precisión fija.
Clases como Math o StrictMath además
incluyen soporte para senos y
cosenos
hiperbólicos, raíces cúbicas o
logaritmos en base 10. Por último,
también se da
soporte al uso de números
hexadecimales con coma flotante.
Serialización
Además de corregir errores previos
en la serialización, se da soporte
para
serializar el nuevo tipo enum,
aunque la forma de serializarlo
difiere ligeramente
de los tipos tradicionales.
Hilos
Se han añadido los paquetes
java.util.concurrent,
java.util.concurrent.atomic y
java.util.concurrent.locks, que
permiten crear diversas
infraestructuras de hilos,
como pooling de hilos o colas de
bloqueos, liberando al programador
de tener que
controlar todas estas estructuras "a
mano". En definitiva, se da soporte
para
automatizar la programación
concurrente.
Además, a la clase Thread se le han
añadido los métodos getStackTrace y
getAllStackTraces para obtener la
traza de los hilos en un momento
dado.
Monitorización y gestión
Se tienen mejoras en el control o la
monitorización tanto de las
aplicaciones Java
como de la máquina virtual (JVM), a
través de la API de JMX.
5. Novedades en librerías
adicionales
RMI
Se tienen dos mejoras fundamentales
en RMI:
• Generación dinámica de Stubs: se
generan en tiempo de ejecución, sin
necesidad de utilizar rmic
previamente. Sólo tendremos que
utilizarlo para
generar Stubs para clientes que
funcionen con versiones anteriores
de
Java.
• Lanzamiento de rmid o un servidor
RMI Java desde inetd/xinetd.
JDBC
En Java 1.4 se introdujo la interfaz
RowSet, que permitía pasar datos
entre
componentes. En Java 1.5 se han
desarrollado 5 implementaciones de
dicha
interfaz, para cubrir 5 posibles
casos de uso:
• JdbcRowSet: para encapsular un
ResultSet o un driver que utilice
tecnología JDBC
• CachedRowSet: desconecta de la
fuente de datos y trabaja
independientemente, salvo cuando
esté obteniendo datos de dicha
fuente o
volcando datos en ella.
• FilteredRowSet: hereda de la
anterior, y se utiliza para obtener
un
subconjunto de datos
• JoinRowSet: hereda de CachedRowSet
y se emplea para unir múltiples
objetos RowSet.
• WebRowSet: hereda de CachedRowSet
para procesar datos XML.
JNDI
• Mejoras en la clase
javax.naming.NameClassPair para
poder acceder al
nombre completo del servicio de
directorio.
• Soporte para controles estándar de
LDAP
• Soporte para manipular nombres de
LDAP
6. Novedades en la interfaz de
usuario
Internacionalización
Para permitir renderizar texto
multilingüe utilizando fuentes
lógicas, se tienen en
cuenta tanto las fuentes del cliente
como las del locale que tengamos
instalado.
Además, AWT utiliza APIs Unicode en
Windows 2000 y XP, con lo que se
puede
manejar texto sin estar limitado a
la configuración de locale de
Windows.
Java Sound
Para el tratamiento del sonido desde
Java, se tienen también los
siguientes
cambios, principalmente:
• Se permite el acceso a puertos en
todas las plataformas
• También está disponible la
entrada/salida MIDI
Java 2D
• Se cachean en memoria todas las
imágenes construidas a partir de
BufferedImage
• Métodos para controlar la
aceleración hardware en imágenes
• Añadido soporte para aceleración
hardware con OpenGL en Solaris y
Linux.
• Creación de fuentes a partir de
archivos y flujos de entrada
• Se ha mejorado la renderización de
texto.
Flujos de imágenes
Se permite, además de los formatos
de imágenes ya soportados (PNG, JPG,
etc.),
leer y escribir imágenes BMP y WBMP.
AWT
Las novedades más significativas
son:
• La clase MouseInfo almacena
información sobre la posición del
ratón en el
escritorio
• Se tienen nuevos métodos en la
clase Window para especificar la
posición
para las nuevas ventanas que se
creen. También se tienen métodos
para
asegurar que una ventana permanezca
siempre en primer lugar (aunque
esta característica no funciona bien
en algunas versiones de Solaris o
Linux)
• Nuevos métodos para acceder y
notificar sobre el contenido del
portapapeles.
• Se han corregido errores
existentes en los layout managers:
GridBagLayout
y FlowLayout.
• Cambios y correcciones en eventos
de teclado (nuevos mapeos de teclas,
redefinición de métodos, etc.), y de
acción (correcciones en cuanto al
uso
de Enter como evento de acción).
Swing
Entre otras, se tienen las
novedades:
• Se proporcionan nuevos look &
feels (uno de ellos, Synth, es
skinnable, es
decir, se puede personalizar el skin
que muestra)
• Se añade soporte para imprimir
JTables.
• Se permite definir menús
contextuales (popup menus) en
componentes,
para que muestren las opciones que
queramos. Para ello se tiene la
clase
JPopupMenu.
• Se han añadido mejoras en
JTextArea para facilitar el scroll
por su
contenido, y la actualización cuando
se modifique su texto.
• Podremos utilizar el método
JFrame.add(...), en lugar de
JFrame.getContentPane().add(...)
// Antes
JFrame f = new JFrame();
f.getContentPane().add(new
JButton("Hola"));
// Ahora
JFrame f = new JFrame();
f.add(new JButton("Hola"));
7. Novedades en despliegue de
aplicaciones
Despliegue general
Se tienen, entre otras, las
siguientes novedades en cuanto a
despliegue de
aplicaciones:
• Se ha unido gran parte de la
funcionalidad entre el Java Plug-in
y Java Web
Start, de modo que ahora tienen un
Java Control Panel común para ambos
• Las aplicaciones desplegadas se
pueden configurar mediante un
archivo de
configuración, que puede ser
accedido a través de una URL, y
establecer
ciertos parámetros de la aplicación.
• El formato de compresión Pack200
permite tener archivos JAR
ultracomprimidos
(hasta 1/8 de su tamaño original),
reduciendo los tiempos de
descarga, o de despliegue mediante
Java Web Start.
• Inclusión de marcas de tiempo
(timestamps) en los archivos JAR
firmados,
de forma que se sabe cuándo se
concedió el certificado para el
archivo, y
se previene así el uso de JARs cuyo
permiso ya caducó.
Java Web Start
Hay también cambios específicos de
Java Web Start, como son:
• Supresión del Application Manager,
cuya mayor funcionalidad se ha
encapsulado dentro del nuevo Java
Control Panel, y el JNLP Cache
Viewer,
una nueva herramienta que permite
gestionar las aplicaciones
descargadas.
• Supersión del Developer Bundle, ya
que Java Web Start está
completamente integrado con JRE y
SDK, y los elementos que contenía
dicho bundle ahora están integrados
en Java.
• Se tiene una caché de sistema, de
forma que el administrador del
sistema
puede cargar al inicio programas en
la caché de sistema, de forma que
sean compartidas y accesibles por
múltiples usuarios.
• Hay también una facilidad de
importación, de forma que se
facilita la
instalación desde CDs, donde el
código se carga primero desde un
lugar y
luego se actualiza desde otro.
También permite preinstalar
aplicaciones y
librerías en caché, sin ejecutarlas.
8. Novedades en herramientas
JPDA
JPDA es un conjunto de interfaces
utilizadas para depurar en entornos
y sistemas
de desarrollo. En la versión 1.5 se
tienen nuevas mejoras y
funcionalidades de
esta herramienta. Muchas de estas
nuevas funcionalidades se han
añadido para
adaptar las nuevas características
de la versión 1.5 de Java, como los
argumentos
variables, imports estáticos, etc.
JVMTI
JVMTI (Java Virtual Machine Tool
Interface) es una nueva interfaz de
programación nativa para utilizar en
herramientas de desarrollo y
monitorización.
Forma parte de las interfaces
contenidas en JPDA para depuración.
Permite
chequear el estado y controlar la
ejecución de una aplicación.
Compilador (javac)
Se han añadido algunas
características a la hora de
utilizar el compilador, como
son los parámetros:
• - source 1.5: habilita las nuevas
características de la versión 1.5 de
Java,
para ser tenidas en cuenta por el
compilador. Lleva implícito también
un
parámetro -target 1.5
• -target 1.5: permite al compilador
utilizar características específicas
de Java
1.5 en las librerías y la máquina
virtual.
• -Xlint: permite producir warnings
sobre código que, aunque es
correcto,
puede ser problemático debido a su
construcción.
Herramienta javadoc
Se tienen nuevas funcionalidades en
la herramienta javadoc. Como en
otros
elementos, muchos de los cambios dan
soporte a características nuevas de
Java
1.5 (generics, tipo enum, etc.). Se
tienen también marcas nuevas, como
regression para indicar
funcionalidades que se
desaconsejaron en versiones
anteriores, pero que han sido
corregidas en la nueva. También se
da soporte a
anotaciones para generar
metainformación que utilizar en
otros programas.
8.5 El Entorno de Desarrollo de Java
La herramienta básica para empezar a
desarrollar aplicaciones o applets
en Java
es el JDK (Java Developer’s Kit) o
Kit de Desarrollo Java, que
consiste,
básicamente, en un compilador y un
intérprete (JVM) para la línea de
comandos.
No dispone de un entorno de
desarrollo integrado (IDE), pero
este puede ser
descargado de varias fuentes en
Internet (Netbeans, Eclipse en mi
caso, etc.)
suficiente para aprender el lenguaje
y desarrollar pequeñas aplicaciones.
¿Dónde conseguirlo?
El Kit de desarrollo puede obtenerse
en las direcciones siguientes:
· https://www.sun.com
· https://www.javasoft.com
El entorno para Windows9x/NT está
formado por un archivo ejecutable
que realiza
la instalación, creando toda la
estructura de directorios. El kit
contiene
básicamente:
· El compilador: javac.exe
· El depurador: jdb.exe
· El intérprete: java.exe y
javaw.exe
· El visualizador de applets:
appletviewer.exe
· El generador de documentación:
javadoc.exe
· Un desensamblador de clases:
javap.exe
· El generador de archivos fuentes y
de cabecera (.c y .h) para clases
nativas en C: javah.exe
8.6 Herramientas para trabajar en
Java
Existen distintas “ediciones” de
Java para el desarrollo de
aplicaciones en distintos
ámbitos:
• Aplicaciones de propósito general
(J2SE)
• Aplicaciones de gestión en
entornos empresariales (J2EE)
• Aplicaciones para teléfonos
móviles, PDAs y otros dispositivos
electrónicos que
permitan aplicaciones empotradas
(J2ME)
La más utilizada es sin duda la
edición estándar (J2SE).
J2SE incluye bibliotecas muy
extensas y completas, que permiten
la
implementación de casi cualquier
tipo de aplicación:
• Seguridad
• EEDDs
• Componentes (JavaBeans)
• Internacionalización
• E/S
• XML
• Redes y acceso a Internet
• Programación distribuida (RMI,
CORBA)
• Matemática de precisión arbitraria
• Sonido
• Interfaz de usuario (AWT, SWING)
• Gráficos 2D
• Manipulación, carga y descarga de
imágenes
• Impresión
• Acceso a bases de datos (JDBC)
• Gestión de preferencias y
configuraciones
Varias de estas características se
verifican en la sección de
novedades, apartado
8.4.
Entonces, en los entornos de
desarrollo podemos encontrar:
NetBeans. Entorno integrado de
desarrollo Java de Sun, realizado
íntegramente
en Java (y por tanto
multiplataforma). Consume bastantes
recursos. Permite
diseñar ventanas, escribir código,
compilar, ejecutar etc. Requiere un
JDK
instalado. Puede obtenerse
gratuitamente de www.netbeans.org
Borland JBuilder. Excelente entorno
integrado de desarrollo Java de
Borland. Al
igual que Netbeans, también está
realizado íntegramente en Java.
Existen
versiones limitadas que pueden
bajarse de www.borland.com.
Microsoft Visual J++. Uno de los más
populares, aunque las aplicaciones
obtenidas pueden presentar problemas
de compatibilidad con el SDK oficial
de
Java, por el uso de librerías
especificas de Microsoft. Permite
construir
aplicaciones Java dentro de la
plataforma .NET.
Otros IDE son Eclipse, el cual se
detallará en el apartado 15, IBM
WebSphere,
Oracle JDeveloper, etc.
Java vrs otros lenguajes OO
9. Tipos de datos, variables y
matrices
9.1 Tipos de datos
En Java existen dos tipos
principales de datos:
1) Tipos de datos simples.
2) Referencias a objetos.
Los tipos de datos simples son
aquellos que pueden utilizarse
directamente en un
programa, sin necesidad del uso de
clases (POO). Estos tipos son:
El segundo tipo está formado por
todos los demás. Se les llama
referencias
porque en realidad lo que se
almacena en los mismos son punteros
a zonas de
memoria donde se encuentran
almacenadas las estructuras de datos
que los
soportan. Dentro de este grupo se
encuentran las clases (objetos) y
también se
incluyen las interfaces, los
vectores y los Strings.
Pueden realizarse conversiones entre
los distintos tipos de datos
(incluso entre
simples y referenciales), bien de
forma implícita o de forma
explícita.
9.2 Tipos de datos simples
Los tipos de datos simples
soportados por Java son los
siguientes:
No existen más datos simples en
Java. Incluso éstos que se enumeran
son
envueltos por clases equivalentes
(java.lang.Integer,
java.lang.Double,
java.lang.Byte, etc.), que pueden
tratarlos como si fueran objetos en
lugar de
datos simples.
A diferencia de otros lenguajes de
programación como el C, en Java los
tipos de
datos simples no dependen de la
plataforma ni del sistema operativo.
Un entero de
tipo int siempre tendrá 4 bytes, por
lo que no tendremos sorpresas al
migrar un
programa de un sistema operativo a
otro. Es más, ni siquiera hay que
volverlo a
compilar.
Eso sí, Java no realiza una
comprobación de los rangos. Por
ejemplo: si a una
variable de tipo short con el valor
32.767 se le suma 1, el resultado
será
-32.768 y no se producirá ningún
error de ejecución.
Nota: A diferencia de otros
lenguajes de programación, los
Strings en Java no son
un tipo simple de datos sino un
objeto. Los valores de tipo String
van entre
comillas dobles (“Hola”), mientras
que los de tipo char van entre
comillas simples
(‘K’).
Los valores que pueden asignarse a
variables y que pueden ser
utilizados en
expresiones directamente reciben el
nombre de literales.
9.3 Tipos de datos referenciales
El resto de tipos de datos que no
son simples, son considerados
referenciales.
Estos tipos son básicamente las
clases, en las que se basa la
programación
orientada a objetos.
Al declarar un objeto perteneciente
a una determinada clase, se está
reservando
una zona de memoria19 donde se
almacenarán los atributos y otros
datos
pertenecientes a dicho objeto. Lo
que se almacena en el objeto en sí,
es un
puntero (referencia) a dicha zona de
memoria.
Dentro de estos tipos pueden
considerarse las interfaces, los
Strings y los
vectores, que son unas clases un
tanto especiales, y que se verán en
detalle
posteriormente.
Existe un tipo referencial especial
nominado por la palabra reservada
null que
puede ser asignado a cualquier
variable de cualquier clase y que
indica que el
puntero no tiene referencia a
ninguna zona de memoria (el objeto
no está
inicializado).
Además, todos los tipos de datos
simples vistos en el punto anterior
pueden ser
declarados como referenciales
(objetos), ya que existen clases que
los engloban.
Estas clases son:
19 En realidad, el momento en el que
se realiza la reserva física del
espacio de memoria es cuando se
instancia el objeto
realizando la llamada a su
constructor, y no en el momento de
la declaración.
Clases que Engloban datos simples
9.4 Identificadores y variables
Los identificadores son los nombres
que se les da a las variables,
clases,
interfaces, atributos y métodos de
un programa.
Reglas para la creación de
identificadores:
1. Java hace distinción entre
mayúsculas y minúsculas, por lo
tanto, nombres o
identificadores como var1, Var1 y
VAR1 son distintos.
2. Pueden estar formados por
cualquiera de los caracteres del
código Unicode, por
lo tanto, se pueden declarar
variables con el nombre:
añoDeCreación, raïm, etc.
(se acabó la época de los nombres de
variable como ano_de_creacion),
aunque
eso sí, el primer carácter no puede
ser un dígito numérico y no pueden
utilizarse
espacios en blanco ni símbolos
coincidentes con operadores.
3. La longitud máxima de los
identificadores es prácticamente
ilimitada.
4. No puede ser una palabra
reservada del lenguaje ni los
valores lógicos true o
false.
5. No pueden ser iguales a otro
identificador declarado en el mismo
ámbito.
6. Por convenio, los nombres de las
variables y los métodos deberían
empezar por
una letra minúscula y los de las
clases por mayúscula.
Además, si el identificador está
formado por varias palabras la
primera se escribe
en minúsculas (excepto para las
clases) y el resto de palabras se
hace empezar
por mayúscula (por ejemplo:
añoDeCreación). Estas reglas no son
obligatorias,
pero son convenientes ya que ayudan
al proceso de codificación de un
programa,
así como a su legibilidad. Es más
sencillo distinguir entre clases y
métodos o
variables.
Ya que el lenguaje permite
identificadores todo lo largos que
se desee, es
aconsejable crearlos de forma que
tengan sentido y faciliten su
interpretación. El
nombre ideal para un identificador
es aquel que no se excede en
longitud (lo más
corto posible) siempre que califique
claramente el concepto que intenta
representar. Siempre dentro de unos
límites; por ejemplo, no sería muy
adecuado
utilizar un identificador de un
índice de un Ciclo como
indiceDeTalCiclo en lugar
de simplemente i.
Hay que evitar identificadores como
a1, a2, a3, a4, va1, xc32, xc21,
xsda, … y en
general todos aquellos
identificadores que no “signifiquen”
nada.
Declaración de variables
La declaración de una variable se
realiza de la misma forma que en C.
Siempre
contiene el nombre (identificador de
la variable) y el tipo de dato al
que pertenece.
El ámbito de la variable depende de
la localización en el programa donde
es
declarada.
Ejemplo:
int x;
Las variables pueden ser
inicializadas en el momento de su
declaración, siempre
que el valor que se les asigne
coincida con el tipo de dato de la
variable.
Ejemplo:
int x = 0;
Ámbito de una variable
El ámbito de una variable es la
porción de programa donde dicha
variable es
visible para el código del programa
y, por tanto, referenciable.
El ámbito de una variable depende
del lugar del programa donde es
declarada,
pudiendo pertenecer a cuatro
categorías distintas.
· Variable local.
· Atributo.
· Parámetro de un método.
· Parámetro de un tratador de
excepciones.
Como puede observarse, NO existen
las variables globales. Esto no es
un
“defecto” del lenguaje sino todo lo
contrario. La utilización de
variables globales
resulta peligrosa, ya que puede ser
modificada en cualquier parte del
programa y
por cualquier procedimiento.
Además, a la hora de utilizarlas hay
que buscar dónde están declaradas
para
conocerlas y dónde son modificadas
para evitar sorpresas en los valores
que
pueden contener.
Los ámbitos de las variables u
objetos en Java siguen los criterios
“clásicos”, al
igual que en la mayoría de los
lenguajes de programación como
Pascal, C++, etc.
No existen sorpresas.
Si una variable no ha sido
inicializada, tiene un valor
asignado por defecto. Este
valor es, para las variables de tipo
referencial (objetos), el valor
null. Para las
variables de tipo numérico, el valor
por defecto es cero (0), las
variables de tipo
char, el valor ‘\u0000’ y las
variables de tipo boolean, el valor
false.
Variables locales
Una variable local se declara dentro
del cuerpo de un método de una clase
y es
visible únicamente dentro de dicho
método.
Se puede declarar en cualquier lugar
del cuerpo, incluso después de
instrucciones
ejecutables, aunque es una buena
costumbre declararlas justo al
principio.
También pueden declararse variables
dentro de un bloque patentizado por
llaves
{…}. En ese caso, sólo serán
“visibles” dentro de dicho bloque.
class Caracter {
char ch;
public Caracter(char c) {
ch=c;
}
public void repetir(int num) {
int i;
for (i=0;i<num;i++)
System.out.println(ch);
}
}
class Ej1 {
public static void main(String
argumentos[]) {
Caracter caracter;
caracter = new Caracter('H');
caracter.repetir(20);
}
}
En este ejemplo existe una variable
local: int i; definida en el método
repetirde la clase Caracter, por lo
tanto, únicamente es visible dentro
del método
repetir.
También existe una variable local en
el método main. En este caso, la
variable local
es un objeto:
Caracter caracter; .. que sólo será
visible dentro del método en el que
está
declarada (main).
Es importante hacer notar que una
declaración como la anterior le
indica al
compilador el tipo de la variable
caracter pero no crea un objeto. El
operador que
crea el objeto es new, que necesita
como único parámetro el nombre del
constructor (que será el
procedimiento que asigna valor a ese
objeto recién
instanciado).
Cuando se pretende declarar
múltiples variables del mismo tipo
pueden
declararse, en forma de lista,
separadas por comas:
Ejemplo:
int x,y,z;
· Declara tres variables x, y, z de
tipo entero.
· Podrían haberse inicializado en su
declaración de la forma:
int x=0,y=0,z=3;
No es necesario que se declaren al
principio del método. Puede hacerse
en
cualquier lugar del mismo, incluso
de la siguiente forma:
public void repetir(int num) {
for (int i=0;i<num;i++)
System.out.println(ch);
}
En el caso de las variables locales,
éstas no se inicializan con un valor
por
defecto, como se ha comentado en el
punto anterior, sino que es
necesario
asignarles algún valor antes de
poder utilizarlas en cualquier
instrucción, de lo
contrario el compilador genera un
error, de tal forma que es imposible
hacer uso
de una variable local no
inicializada sin que se percate de
ello el compilador.
Las variables locales pueden ser
antecedidas por la palabra reservada
final. En
ese caso, sólo permiten que se les
asigne un valor una única vez.
Ejemplo:
final int x=0;
No permitirá que a x se le asigne
ningún otro valor. Siempre contendrá
0.
No es necesario que el valor se le
asigne en el momento de la
declaración, podría
haberse inicializado en cualquier
otro lugar, pero una sola vez:
Ejemplo:
final int x;
…
x=y+2;
Después de la asignación x=y+2, no
se permitirá asignar ningún otro
valor a x.
Atributos
Los atributos de una clase son las
características que se van a tener
en cuenta
sobre un objeto y por lo tanto su
ámbito está circunscrito, en
principio, dentro de la
clase a la cual caracterizan. Se
declaran de la misma forma que las
variables
locales pero, además, pueden tener
algunos modificadores que afectan al
ámbito
de los mismos.
En el ejemplo anterior, ch es un
atributo de la clase Caracter y por
lo tanto es
“manipulable” en cualquier método de
dicha clase, como de hecho ocurre en
los
método repetir () y Carácter ().
Para acceder a un atributo de un
objeto desde algún método
perteneciente a otra
clase u objeto se antepone el nombre
del objeto y un punto al nombre de
dicho
atributo. Por ejemplo:
caracter.ch
Con los nombres de los métodos se
hace lo mismo.
Ejemplo:
caracter.repetir(20);
Parámetros de un método
Los parámetros se declaran en la
cabecera del método de la siguiente
forma:
[Modificadores_de_método]
Tipo_devuelto Nombre_de_método
(lista_de_parámetros)
{
…
}
La lista_de_parámetros consiste en
una serie de variables, separadas
por comas y
declarando el tipo al que
pertenecen.
Ejemplo:
public static void miMétodo(int v1,
int v2, float v3, Stringv4,
ClaseObjeto v5);
Nótese que aunque existan varios
parámetros pertenecientes al mismo
tipo o
clase, no pueden declararse
abreviadamente, como ocurre con las
variables
locales y los atributos, indicando
el tipo y a continuación la lista de
parámetros
separados por comas. Así, es ilegal
la siguiente declaración del método
anterior:
public static void miMétodo(int v1,
v2, float v3, String v4,
ClaseObjeto v5); .. (ILEGAL)
La declaración de un parámetro puede
ir antecedida, como ocurre con las
variables locales, por la palabra
reservada final. En ese caso, el
valor de dicho
parámetro no podrá ser modificado en
el cuerpo del método.
Los parámetros de un método pueden
ser de dos tipos:
• Variables de tipo simple de datos:
En este caso, el paso de parámetros
se
realiza siempre por valor. Es decir,
el valor del parámetro de llamada no
puede
ser modificado en el cuerpo del
método (El método trabaja con una
copia del
valor utilizado en la llamada).
• Variables de tipo objeto
(referencias): En este caso, lo que
realmente se
pasa al método es un puntero al
objeto y, por lo tanto, el valor del
parámetro de
llamada sí que puede ser modificado
dentro del método (El método trabaja
directamente con el valor utilizado
en la llamada), a no ser que se
anteponga la
palabra reservada final.
La salida del programa sería la
siguiente:
Valor del objeto = 1
Valor de la variable = 2
-Después de llamar a modifica ( )-
Valor del objeto = 2
Valor de la variable = 2
Como puede verse, después de la
llamada, el valor del objeto obj sí
ha sido
modificado (se ha realizado un pase
de parámetro por referencia),
mientras que el
valor de la variable var1 no ha sido
modificado (se ha realizado un paso
de
parámetro por valor).
9.5 Conversión de Tipos
La palabra conversión se utiliza con
el sentido de "convertir a un
molde". Java
convertirá automáticamente un tipo
de datos en otro cuando sea
adecuado. Por
ejemplo, si se asigna un valor
entero a una variable de coma
flotante, el
compilador convertirá
automáticamente el int en float. La
conversión permite llevar
a cabo estas conversiones de tipos
de forma explícita, o forzarlas
cuando no se
diesen por defecto.
Para llevar a cabo una conversión,
se pone el tipo de datos deseado
(incluidos
todos los modificadores) entre
paréntesis a la izquierda de
cualquier valor. He aquí
un ejemplo:
void conversiones ( ) {
int i = 200;
long 1 = (long) i;
long 12 = (lon9)2OO;
}
Como puede verse, es posible llevar
a cabo una conversión, tanto con un
valor
numérico, como con una variable. En
las dos conversiones mostradas, la
conversión es innecesaria, dado que
el compilador convertirá un valor
int en long
cuando sea necesario. No obstante,
se permite usar conversiones
innecesarias
para hacer el código más limpio. En
otras situaciones, puede ser
esencial una
conversión para lograr que el código
compile.
En C y C++, las conversiones pueden
conllevar quebraderos de cabeza. En
Java,
la conversión de tipos es segura,
con la excepción de que al llevar a
cabo una de
las denominadas conversiones
reductoras(es decir, cuando se va de
un tipo de
datos que puede mantener más
información a otro que no puede
contener tanta)
se corre el riesgo de perder
información. En estos casos, el
compilador fuerza a
hacer una conversión explícita,
diciendo, de hecho, "esto puede ser
algo peligroso
de hacer -si se quiere que lo haga
de todas formas, tiene que hacer la
conversión
de forma explícita". Con una
conversión extensora no es necesaria
una
conversión explícita porque el nuevo
tipo es capaz de albergar la
información del
viejo tipo sin que se pierda nunca
ningún bit.
Java permite convertir cualquier
tipo primitivo en cualquier otro
tipo, excepto
boolean, que no permite ninguna
conversión. Los tipos clase no
permiten ninguna
conversión. Para convertir una a
otra debe utilizar métodos
especiales (String es
un caso especial y se verá más
adelante en este libro que los
objetos pueden
convertirse en una familia de tipos;
un Roble puede convertirse en Árbol
y
viceversa, pero esto no puede
hacerse con un tipo foráneo como
Roca.)
Toda expresión en Java tiene un tipo
de dato asociado, ya sea simple o
referencial, y puede ser deducido de
la estructura de la expresión y los
literales
que pudiera contener.
Las conversiones de tipos pueden ser
apropiadas para cambiar el tipo de
una
determinada expresión que no se
corresponda con el tipo necesario.
Tipos de conversiones de tipos:
Conversión por ampliación: Consiste
en cambiar el tipo de dato por otro
cuyo rango es mayor y por lo tanto,
contiene al primero. En este tipo de
conversión no se pierde información
(aunque puede perderse precisión en
la conversión de datos enteros a
reales).
Conversión por reducción: En este
tipo de conversión sí que puede
perderse información debido a que se
pretende almacenar más información
de la que “cabe” en el tipo de
destino. Al ser una conversión
“semidestructiva”, es necesario
indicar que se pretende realizar la
misma
explícitamente para evitar pérdidas
de información por conversiones por
reducción inadvertidas.
Conversión por ampliación de tipos
de datos simples
En estos casos no se pierde
información sobre la magnitud de los
valores
numéricos.
Tipo a Tipo resultante
convertir
byte short
int
long
float
double
short int
long
float
double
char int
long
float
double
int long
float
double
long float
double
float double
Para los casos de asignación no es
necesario realizar ninguna
conversión explícita
de tipos. Por ejemplo, se puede
asignar un valor de tipo byte a una
variable de tipo
short, int, long, float o double.
También se puede asignar un carácter
(char) a una variable de tipo int,
long, float
o double.
int i = ’A’;
Los únicos casos en los que no se
preserva necesariamente la exactitud
entre los
valores del tipo a convertir y el
tipo resultante, ya que puede
perderse precisión
son:
Tipo a Tipo resultante
convertir
int float
long float
double
En estos casos de pérdida de
precisión, se redondea al valor más
cercano.
Ejemplo de pérdida de precisión:
Produce la siguiente salida:
f=1.23456794E9
-46
Esto es debido a que el tipo float
sólo es preciso hasta 8 dígitos
significativos.
Conversión por reducción de tipos de
datos simples
En estos casos puede perderse
información ya que los rangos de
representación
son distintos, no estando el del
tipo de dato a convertir incluido en
el rango del tipo
de destino.
La forma de convertir de un tipo a
otro es trasladando los n bits menos
significativos a la zona de memoria
de destino con capacidad para esos n
bits. De
esta forma puede perderse incluso el
signo de valores numéricos
(representados
en complemento a dos).
Tipo a
convertir
Tipo
resultante
Tipo a
convertir
Tipo
resultante
byte char
short byte
char
char byte
short
int byte
short
char
long byte
short
char
int
float byte
short
char
int
long
double byte
short
char
Int
Long
float
Reducción de datos simples
En estos casos, en que puede
perderse información en el proceso
de conversión
de tipos, es necesario indicarlo
explícitamente para evitar que esta
pérdida se
produzca de forma accidental, o por
lo menos de forma inadvertida por el
programador.
La forma de realizar la conversión
de tipo por reducción es mediante la
anteposición a la expresión a
convertir, el tipo de destino
encerrado entre
paréntesis.
Salida por pantalla:
f1=1.234567 i1=1
f2=7.654321 i2=7
i=1234567 s=-10617
Conversión por ampliación de tipos
de datos referenciales
Al igual que ocurre con los tipos de
datos simples, también para los
objetos
pueden realizarse conversiones tanto
por ampliación como por reducción.
Las conversiones por ampliación
permitidas son:
Tipo a convertir Tipo resultante
La clase null - Cualquier clase,
interfase o vector
Cualquier clase C - Cualquier clase
R siempre que C sea
subclase de R
- Cualquier interfase I si C
implementa I
- La clase Object
Cualquier interfase I - Cualquier
interfase K siempre que I sea
subinterfaz de K
- La clase Object
Cualquier vector A - La clase Object
- La clase Cloneable
- Cualquier vector R siempre que el
tipo de los
elementos de A y R sean datos
referenciales y
exista una conversión por ampliación
entre ellos.
En estos casos no es necesaria
ninguna conversión explícita.
Produce la siguiente salda por
pantalla:
Clase c2
En el ejemplo, se ha declarado un
objeto c1 de la clase C1, que es
subclase de
C2. A c1 se le asigna un objeto de
la clase C2 (al realizar la llamada
al constructor
de C2). Esto puede hacerse sin
ninguna conversión explícita ya que
C2 es
subclase de C1. Casi gráficamente
puede entenderse mediante un ejemplo
de la
siguiente forma: imaginemos una
clase Ave y una subclase Pato; si se
dispone de
una variable de la clase Ave, a
dicha variable se le puede asignar
un “Pato”, ya
que un pato es, efectivamente, un
ave. Por lo tanto, a una variable de
la clase Ave,
se le puede asignar un objeto “Pato”
sin ninguna conversión explícita ya
que es un
proceso “natural”. El caso contrario
no siempre es cierto. Si se dispone
de una
variable de la clase Pato, no se le
puede asignar un objeto de la clase
“Ave”, ya
que cualquier ave no es un pato.
Si se dispone de una variable de la
clase Pato y se le desea asignar un
objeto de
la clase Ave, habrá que realizar una
conversión explícita (ver punto
siguiente) para
“asegurar” que el ave que asignamos
es “realmente” un pato.
Conversión por reducción de tipos de
datos referenciales
Las conversiones por reducción
permitidas son:
Tipo a convertir Tipo resultante
La clase Object - Cualquier vector
- Cualquier interfase
- Cualquier clase
Cualquier clase C - Cualquier clase
R siempre que C sea
superclase de R
- Cualquier interfase I si C no es
final y
no implementa I
Cualquier interfase I - Cualquier
clase C que no sea final
- Cualquier clase C que sea final
siempre que C implemente I
- Cualquier interfase K siempre que
I no
sea subinterface de K y no tengan
métodos con el mismo nombre pero
distinto tipo de dato de retorno.
Cualquier vector A - Cualquier
vector R siempre que el tipo
de los elementos de A y R sean datos
referenciales y exista una
conversión
por reducción entre ellos.
En estos casos es necesario
indicarlo explícitamente.
La forma de realizar la conversión
de tipo por reducción es mediante la
anteposición a la expresión a
convertir, el tipo de destino
encerrado entre
paréntesis.
El siguiente ejemplo muestra una
conversión no permitida y genera un
mensaje de
error por el compilador:
class C1 {
public String clase;
public C1() {
clase = "clase c1";
}
}
class C2 extends C1{
public C2() {
clase = "clase c2";
}
}
class Conversion4 {
public static void main(String
arg[]) {
C1 c1 = new C1();
C2 c2 = c1;
System.out.println(c2.clase);
}
}
Conversion4.java:16: Incompatible
type for declaration. Explicit
cast needed to convert C1 to C2.
C2 c2 = c1;
^
1 error
La conversión de un objeto de la
clase C1 a la clase C2 necesita del
programador
la indicación de que se sabe que se
está asignando un valor de la clase
C1 a una
variable de la clase C2, pero que en
realidad c1 no contiene un objeto de
la clase
C1 sino un objeto de la clase C2.
Para realizar la conversión en el
ejemplo anterior se antepone la
clase a convertir
encerrada entre paréntesis de la
siguiente manera:
class Conversion4 {
public static void main(String
arg[]) {
C1 c1 = new C1();
// Conversión por reducción de tipo
de
// dato referencial
C2 c2 = (C2) c1;
System.out.println(c2.clase);
}
}
Con esta conversión explícita se
indica que el objeto almacenado en
c1 es, en
realidad, de la clase C2 (lo cuál no
es cierto). Ahora el compilador no
genera
ningún error, pero al ejecutar el
programa se genera una excepción:
java.lang.ClassCastException:
at
Conversion5.main(Conversion5.java:17)
No se habría generado ninguna
excepción si en c1 hubiera un objeto
de la clase
C2 de la siguiente forma:
class Conversion4 {
public static void main(String
arg[]) {
C1 c1 = new C2(); // Conversión por
ampliación
// Conversión por reducción de tipo
de dato
// referencial
C2 c2 = (C2) c1;
System.out.println(c2.clase);
}
}
La salida por pantalla sería:
Clase c2
Conversiones de tipos no permitidas
Tipo a convertir Tipo resultante
Tipo referencial Tipo simple
Tipo simple Tipo referencial
(Excepto al tipo String)
Null Tipo simple
Cualquier tipo Tipo boolean
Tipo boolean Cualquier otro tipo
(Excepto al tipo
String)
Cualquier clase C - Cualquier clase
R siempre que C no
sea
subclase de R y R no sea subclase de
C
(Excepto a la clase String)
- Cualquier interfase I si C es
“final” y no
implementa I
- Cualquier vector (Excepto si C es
de
la clase Object)
Cualquier interfase I - Cualquier
clase C (Excepto si C es
String) si es “final” y no
implementa I
- Cualquier interfase K si I y K
declaran
métodos con la misma cabecera y
distinto tipo de dato de retorno.
Cualquier vector - Cualquier
interfase excepto al
interfase
Cloneable.
-Cualquier otro vector si no hay
conversión entre los tipos de los
elementos (excepto la conversión a
String).
9.6 Vectores o Matrices
Para manejar colecciones de objetos
del mismo tipo estructurados en una
sola
variable se utilizan los vectores20.
En Java, los vectores son en
realidad objetos y
por lo tanto se puede llamar a sus
métodos (como se verá en el capítulo
siguiente).
Existen dos formas equivalentes de
declarar vectores en Java:
1) tipo nombreDelVector [ ];
2) tipo [ ] nombreDelVector;
Ejemplo:
int vector1[], vector2[], entero;
//entero no es un vector
int[] otroVector;
También pueden utilizarse vectores
de más de una dimensión:
Ejemplo:
int matriz [] [];
int [] [] otraMatriz;
Los vectores, al igual que las demás
variables pueden ser inicializados
en el
momento de su declaración. En este
caso, no es necesario especificar el
número
de elementos máximo reservado. Se
reserva el espacio justo para
almacenar los
elementos añadidos en la
declaración.
Ejemplo:
String Días []=
{”Lunes”,”Martes”,”Miércoles”,”Jueves”,
”Viernes”,”Sábado”,”Domingo”};
Una simple declaración de un vector
no reserva espacio en memoria, a
excepción
del caso anterior, en el que sus
elementos obtienen la memoria
necesaria para ser
almacenados. Para reservar la
memoria hay que llamar
explícitamente a un
constructor new21 de la siguiente
forma:
new tipoElemento[ numElementos] ;
20 También llamados arrays, matrices
o tablas.
21 Véase la sección 12.4
Ejemplo:
int matriz[][];
matriz = new int[4][7];
También se puede indicar el número
de elementos durante su declaración:
Ejemplo:
int vector[] = new int[5];
Para hacer referencia a los
elementos particulares del vector,
se utiliza el
identificador del vector junto con
el índice del elemento entre
corchetes. El índice
del primer elemento es el cero (0) y
el del último, el número de
elementos menos
uno.
Ejemplo:
j = vector[0]; vector[4] =
matriz[2][3];
El intento de acceder a un elemento
fuera del rango de la matriz, a
diferencia de lo
que ocurre en C, provoca una
excepción (error) que, de no ser
manejado por el
programa, será el compilador quien
aborte la operación.
Para obtener el número de elementos
de un vector en tiempo de ejecución
se
accede al atributo de la clase
vector length. No olvidemos que los
vectores en
Java son tratados como un objeto.
class Array1 {
public static void main (String
argumentos[]) {
String colores[] =
{"Rojo","Verde","Azul",
"Amarillo","Negro"};
int i;
for (i=0;i<colores.length;i++)
System.out.println(colores[i]);
}
}
El ejemplo anterior produce la
siguiente salida por pantalla:
Rojo
Verde
Azul
Amarillo
Negro
Arrays multidimensionales
Java permite crear fácilmente arrays
multidimensionales:
/ / :
c04:ArrayMultidimensional.java/ /
creando arrays multidimensionales.
import java.util.*;
public class ArrayMultidimensional {
static Random aleatorio = new
Random();
static int pAleatorio (int modulo) {
return Math. abs (aleatorio. nextInt
( ) ) % modulo + 1;
}
static void visualizar (String S) {
System.out.println (S);
}
public static void main (String[]
args) {
int[l [ ] al = {
{ 1, 2, 3}
{ 4, 5 , 6}
};
for(int i = O; i < al.length; i++)
for (int j = O; j < al [i] . length;
j++)
visualizar ("al [ " + i + "1 [ " + j
+
“j = “ + al[i] [j]);
/ / array 3-D de longitud fija:
int [] [] [] a2 = new int [2] [2]
[4];
for (int i = O; i < a2.length; i+t)
for (int j = O; j < a2 [i] . length;
jt+)
for(int k = O; k < a2[i] [j]
.length;
k++)
visualizar ("a2 [ " + i + "1 [ " + j
+ "][" + k +
“J = “+ a2 [i][j][k]);
/ / array 3-D con vectores de
longitud variable:
int [] [ ] [] a3 = new int
[pAleatorio (7) ] [] [] ;
for (int i = O; i < a3.length; i++)
{
a3 [i] = new int [pAleatorio (5) ]
[] ;
for(int j = O; j < a3[i] .length;
j++)
a3[il [jl = new int[pAleatorio(5)1;
}
for (int i = O; i < a3.length; i++)
for (int j = O; j < a3 [i] .length;
j++)
for(int k = O; k < a3[i] [j]
.length;
k++)
visualizar ("a3 [ " + i + "1 [ " + j
+ "][" + k +
“J = “ + a3 [il [jl [kl ) ;
/ / Array de objetos no primitivos:
Integer [] [] a4 = {
{ new Integer (1) , new Integer (2)
} ,
{ new Integer (3) , new Integer ( 4
) },
{ new Integer (S), new Integer (6) }
,
};
for(int i = O; i < a4.length; i++)
for (int j = O; j < a4 [i] . length;
j++)
visualizar("a4[" + i + "1 [ " + j +
" J = " + a4 [i] [j]);
Integer [] [ ] a5;
a5 = new Integer [3] [] ;
for(int i = O; i < a5.length; i++) {
a5[i] = new Integer[3];
for (int j = O; j < a5 [i] .length;
j++)
a5 [i] [ j ] = new Integer (i* j) ;
}
for(int i = O; i < a5.length; i++)
for(int j = O; j < a5[i] .length;
j++)
visualizar ("a5 [ " + i + "1 [ " + j
+
“ J = “J + a5[i] [j]);
}
} / / / : -
El código utilizado para imprimir
utiliza el método length, de forma
que no
depende de tamaños fijos de array.
El primer ejemplo muestra un array
multidimensional de tipos
primitivos. Se puede
delimitar cada vector del array por
llaves:
Cada conjunto de corchetes nos
introduce en el siguiente nivel del
array.
El segundo ejemplo muestra un array
de tres dimensiones asignado con
new.
Aquí, se asigna de una sola vez todo
el array:
int [] [] [] a2 = new int [2] [2]
[4] ;
Pero el tercer ejemplo muestra que
cada vector en los arrays que
conforman la
matriz puede ser de cualquier
longitud:
El primer new crea un array con un
primer elemento de longitud
aleatoria, y el
resto, indeterminados. El segundo
new de dentro del Ciclo for rellena
los
elementos pero deja el tercer índice
indeterminado hasta que se acometa
el tercer
new.
Se verá en la salida que los valores
del array que se inicializan
automáticamente a
cero si no se les da un valor de
inicialización explícito.
Se puede tratar con arrays de
objetos no primitivos de forma
similar, lo que se
muestra en el cuarto ejemplo, que
demuestra la habilidad de englobar
muchas
expresiones new entre llaves:
El quinto ejemplo muestra cómo se
puede construir pieza a pieza un
array de
objetos no primitivos:
El i*j es simplemente para poner
algún valor interesante en el
Integer.
10 Operadores
Los operadores son partes
indispensables en la construcción de
expresiones.
Existen muchas definiciones técnicas
para el término expresión. Puede
decirse
que una expresión es una combinación
de operandos ligados mediante
operadores.
Los operandos pueden ser variables,
constantes, funciones, literales,
etc. y los
operadores todos los enumerados en
este punto.
10.1 Operadores aritméticos:
Operador Formato Descripción
+ op1 + op2 Suma aritmética de dos
operandos
-op1 - op2
-op1
Resta aritmética de dos
operandos
Cambio de signo
* op1 * op2 Multiplicación de dos
operandos
/ op1 / op2 División entera de dos
operandos
% op1 % op2 Resto de la división
)
++
--op1
op1 --
entera ( o módulo++op1
op1++
Incremento unitario
Decremento unitario
El operador - puede utilizarse en su
versión unaria (- op1) y la
operación que
realiza es la de invertir el signo
del operando.
Como en C, los operadores unarios ++
y -- realizan un incremento y un
decremento respectivamente. Estos
operadores admiten notación prefija
y postfija.
• ++op1: En primer lugar realiza un
incremento (en una unidad) de op1 y
después ejecuta la instrucción en la
cual está inmerso.
• op1++: En primer lugar ejecuta la
instrucción en la cual está inmerso
y
después realiza un incremento (en
una unidad) de op1.
• --op1: En primer lugar realiza un
decremento (en una unidad) de op1 y
después ejecuta la instrucción en la
cuál está inmerso.
• op1--: En primer lugar ejecuta la
instrucción en la cual está inmerso
y
después realiza un decremento (en
una unidad) de op1.
La diferencia entre la notación
prefija y la postfija no tiene
importancia en
expresiones en las que únicamente
existe dicha operación:
++contador; es equivalente a:
contador++;
--contador; contador--;
Es importante no emplear estos
operadores en expresiones que
contengan más
de una referencia a la variable
incrementada, puesto que esta
práctica puede
generar resultados erróneos
fácilmente.
La diferencia es apreciable en
instrucciones en las cuáles están
incluidas otras
operaciones.
Por ejemplo:
cont = 1; cont = 1;
do { do {
…} …}
while ( cont++ < 3 ); while ( ++cont
< 3 );
En el primer caso, el Ciclo se
ejecutará 3 veces, mientras que en
el segundo se
ejecutará 2 veces.
Otro ejemplo:
a = 1; a = 1;
b = 2 + a++; b = 2 + ++a;
• En el primer caso, después de las
operaciones, b tendrá el valor 3 y a
el valor
2.
• En el segundo caso, después de las
operaciones, b tendrá el valor 4 y a
el
valor 2.
10.2 Operadores relacionales
Operador Formato Descripción
> op1 > op2 Devuelve true (cierto)
si op1
es mayor que op2
< op1 < op2 Devuelve true (cierto)
si op1
es menor que op2
>= op1 >= op2 Devuelve true (cierto)
si op1
es mayor o igual que op2
<= op1<= op2 Devuelve true (cierto)
si op1
es menor o igual que op2
== op1 == op2 Devuelve true (cierto)
si op1
es igual a op2
!= op1 != op2 Devuelve true (cierto)
si op1
es distinto de
op2
Los operadores relacionales actúan
sobre valores enteros, reales y
caracteres
(char); y devuelven un valor del
tipo boolean (true o false).
Class Relacional {
public static void main(String
arg[]) {
double op1,op2;
op1=1.34;
op2=1.35;
System.out.println("op1="+op1+"
op2="+op2);
System.out.println("op1>op2 =
"+(op1>op2));
System.out.println("op1<op2 =
"+(op1<op2));
System.out.println("op1==op2 =
"+(op1==op2));
System.out.println("op1!=op2 =
"+(op1!=op2));
char op3,op4;
op3='a'; op4='b';
System.out.println("'a'>'b' =
"+(op3>op4));
}
}
Salida por pantalla:
op1=1.34 op2=1.35
op1>op2 = false
op1<op2 = true
op1==op2 = false
op1!=op2 = true
'a'>'b' = false
Los operadores == y != actúan
también sobre valores lógicos
(boolean).
10.3 Operadores lógicos
Operador Formato Descripción
&& op1 && op2 Y lógico. Devuelve
true
(cierto) si son ciertos op1 y
op2
½½ op1 ½½ op2 O lógico. Devuelve
true
(cierto) si son ciertos op1 o
op2
! ! op1 Negación lógica. Devuelve
true (cierto) si es false op1.
Estos operadores actúan sobre
operadores o expresiones lógicas, es
decir,
aquellos que se evalúan a cierto o
falso (true / false).
class Bool {
public static void main ( String
argumentos[] ) {
boolean a=true;
boolean b=true;
boolean c=false;
boolean d=false;
System.out.println("true Y true = "
+ (a && b) );
System.out.println("true Y false = "
+ (a && c) );
System.out.println("false Y false =
" + (c && d) );
System.out.println("true O true = "
+ (a || b) );
System.out.println("true O false = "
+ (a || c) );
System.out.println("false O false =
" + (c || d) );
System.out.println("NO true = " +
!a);
System.out.println("NO false = " +
!c);
System.out.println("(3 > 4) Y true =
" + ((3 >4) && a) );
}
}
Produciría la siguiente salida por
pantalla:
true Y true = true
true Y false = false
false Y false = false
true O true = true
true O false = true
false O false = false
NO true = false
NO false = true
(3 > 4) Y true = false
10.4 Operadores de asignación
El operador de asignación es el
símbolo igual (=).
op1 = Expresión
Asigna el resultado de evaluar la
expresión de la derecha a op1.
.
Resto del documento disponible para descarga...
|
|
 |
dd |
 |
|
|
|
|
|
|
|
|
|
|
