Implementación del ADT racional.

   El Ejemplo Racional muestra una posible implementación de ADT racional definido en la entrada Tipos de Datos Abstractos (ADT).

   Las líneas 7 y 8 definen los atributos de un número racional (p / q). Los detalles relacionados con los métodos de tipo set y get (líneas 25-41), ya han sido comentados en la sección Métodos y atributos de la entrada POO (mensajes y métodos) y no se repetirán aquí.

   Por otro lado, los constructores definidos (líneas 10-23) requieren de una ampliación en su explicación, ya que difieren un poco de lo hasta ahora comentado para los constructores.

   El constructor principal o base es el definido en las líneas 18-23. Observe que dicho constructor recibe dos argumentos, mismos que representan el numerador (n) y el denominador (d) del número racional que se desea inicializar. En la línea 19, el constructor realiza una verificación del denominador (cláusula de condición), de tal forma que si éste es cero, se crea (new) y lanza (throw) una excepción (consulte la sección de Excepciones de la entrada Ejemplos selectos de transición) para indicar el error a través de la clase ArithmeticException. Note también que el mismo comportamiento es considerado en las líneas 30 y 31 para el método estableceDenominador. Una posible salida del programa al presentarse la situación anteriormente planteada, se muestra en la siguiente figura:

Una salida de la excepción generada en el Ejemplo PruebaRacional al intentar crear un número racional cuyo denominador sea cero.

 

   Los constructores de las líneas 10-12 y 14-16 se apoyan del constructor base de las líneas 18-23 para realizar la inicialización del objeto a través del uso de la cláusula this. La cláusula this es una referencia que tienen todos los objetos hacia sí mismos, por lo que en el contexto de los constructores invoca al constructor sobre cargado que corresponda con el tipo y número de argumentos que envía, que para el caso de las líneas 11 y 15 corresponden con el constructor base de las líneas 18-23.

   La implementación de las operaciones de suma y producto aparecen en las líneas 43-50 y 52-59 respectivamente (la implementación de las operaciones resta y división se dejan como ejercicio para el lector). Observe que en las líneas 46 y 47 (55 y 56) se accede directamente a los atributos p y q a través del operador punto (.), es decir, sin hacer uso de los métodos de acceso set y get; ésto es así debido a que el objeto s (m) es de la misma clase que define al método suma (multiplica), por lo que el acceso es concedido sin ningún tipo de inconveniente (recuerde lo planteado en el Ejercicio 2 de la entrada Ejercicios selectos (POO) y analice la diferencia).

   Por otro lado, note también que para el objeto (this) que recibe el mensaje suma (multiplica), los atributos p y q de las líneas 46 y 47 (55 y 56) son accedidos sin ningún tipo de operador ni mensaje, es decir, son accedidos por contexto, ya que el objeto que recibe el mensaje conoce cuáles son sus propios atributos y métodos por lo que dentro del método la expresión:

p * r.obtenDenominador( )

es equivalente a la expresión:

this.p * r.obtenDenominador( )

   Por último en lo que respecta a los método suma y multiplica, es importante resaltar que ambos métodos utilizan un objeto local al método (s y m respectivamente) para almacenar el resultado que generan y poder regresarlo como valor de retorno del método, por lo que es posible deducir que si un método requiere de variables u objetos para realizar su labor, éstos pueden declarase locales al método. En este sentido, sería un error respecto al paradigma declarar dichas variables u objetos como atributos de la clase, ya que no describen alguna propiedad o característica inherente a los objetos que deriven de la clase, sino que son sólo elementos necesarios para el almacenamiento del resultado y la realización del cálculo correspondiente a la responsabilidad (comportamiento) del método. Lo anterior se aplica aún cuando se utilizara una sola variable para almacenar el resultado de cualquiera de las cuatro operaciones aritméticas.

   Finalmente el método toString (líneas 61-63) requiere una mención aparte, ya que este método sobre escribe (razón por la cual se preservó el nombre del método) y en consecuencia re define el comportamiento previamente establecido en el método la clase Object del API de Java. Dicho método tiene como responsabilidad el regresar una representación en cadena del objeto que recibe el mensaje.

   La clase de prueba del Ejemplo Racional es la del Ejemplo PruebaRacional. Una posible salida corresponde a la mostrada en la siguiente figura:

Una posible salida de la ejecución del Ejemplo PruebaRacional. 

 

   Por último, aunque el Ejemplo PruebaRacional se explica a sí mismo, se resaltarán los siguientes aspectos:

• Las líneas 8 y 9 crean los números racionales r1 y r2, donde r1 = 1 / 3 y r2 = 2 / 5.
• Las líneas 13 y 14 envían los mensajes suma y multiplica respectivamente al objeto r1. Note que el argumento de ambos métodos es r2 y que al valor de retorno de dichos métodos (un número racional), le es enviado de manera implícita el mensaje toString para obtener la representación en cadena de los resultados correspondientes. Esto último sucede también con las líneas 11 y 12 pero para los objetos r1 y r2 respectivamente.

Lanzado y encadenamiento.

Lanzar una excepción.
    Antes de poder atrapar una excepción, debe haber en alguna parte un código que cree y lance una. Cualquier código puede lanzar una excepción, pero independientemente de qué o quién lance una excepción siempre es lanzada con la sentencia o cláusula throw.

    El Ejemplo Excepciones muestra lo anterior. Se tienen básicamente dos métodos además de main, uno de ellos (líneas 9-23) crea y lanza una excepción (línea 12) y el otro no (líneas 25-35). Note cómo la excepción lanzada en la línea 12 es atrapada en la línea 13 y relanzada en la línea 16 para que a su vez vuelva a ser atrapada en la línea 40. Es importante que el lector comprenda también los comentarios de las líneas 17 y 22, mismos que se dejan como ejercicio para que se validen y verifiquen.

    En este mismo orden de ideas, resulta conveniente que el lector revise el Ejemplo descrito en la entrada Implementación del ADT Racional en donde también se crea y lanza una excepción en un contexto particular.

   Adicionalmente a lo anterior, se recomienda también revisar la sección Excepciones de la entrada Ejemplos selectos de transición y la de Pila primitiva de la entrada Pilas (implementación), en las que encontrará respectivamente, la jerarquía de clases relacionadas con las excepciones y un ejemplo de creación de una excepción definida por el programador.

Excepciones encadenadas.
   Frecuentemente una aplicación responde a una excepción lanzando otra excepción, dicho de otra forma: la primera excepción causa la segunda. En este sentido puede ser muy útil el saber cuando una excepción causa otra. Las excepciones encadenadas ayudan al programador a realizar ésto.

   Los siguientes son una lista de métodos y constructores de la clase Throwable que dan soporte a las excepciones encadenadas:
          Throwable getCause( )
          Throwable initCause(Throwable)
          Throwable(String, Throwable)
          Throwable(Throwable)

   El argumento Throwable en initCause y en los constructores es la excepción que causó la excepción actual. getCause regresa la excepción que causó la excepción actual e initCause establece la causa de la excepción actual.

   El siguiente fragmento de código muestra un esqueleto de cómo utilizar una excepción encadenada:
           try {
                       . . .

           } catch (IOException e) {
                  throw new SampleException("Other IOException", e);
           }

    En el Ejemplo Excepciones2 se muestra un ejemplo de lanzado y encadenamiento que está en directa relación y continuación con lo expuesto en la sección anterior. Note particularmente las líneas 19 y 20, en donde se crea respectivamente la nueva excepción a partir de otra, y se incorpora al entorno de ejecución de la máquina virtual de Java (relanza). Asegúrese de comprender en su totalidad el ejemplo y de compararlo con el de la sección anterior (Ejemplo Excepciones). 

    Finalmente considere el Ejemplo Excepciones3. Aquí se tiene lo que se conoce como una pila de invocación de métodos, en donde el último en ser llamado es el que provoca o genera la excepción (creaExcepcion( )). Note cómo todos los métodos indican que pueden lanzar una excepción (throws Exception) pero que ninguno de ellos, exceptuando main, hace una manejo o atrapa alguna: todos la dejan pasar. El nivel de profundidad en la pila de invocación de métodos puede ser mayor o menor que el mostrado en el ejemplo en cuestión, aquí lo importante es asegurarse que se comprende el funcionamiento general, el relanzado implícito, y el encadenamiento de una sola excepción transferida entre los métodos involucrados.

Ejercicios selectos (estructuras de datos).

1. Investigue cómo es que se representan los tipos de datos primitivos en una computadora. Es preciso que conozca cómo se representa un tipo de datos int por ejemplo, ¿cuántos bytes le son asignados a un entero? Los números de punto flotante (float y double por ejemplo), también tiene una representación particular dentro de una computadora basada en los conceptos de mantisa y exponente. Investigue dichos conceptos, así como la representación física (hardware) de los tipos de datos en una computadora convencional.
2. Modifique el Ejemplo PruebaRacional para que genere una salida como la de la siguiente figura:  . Asegúrese de probar el caso de error tanto para el constructor como para el método estableceDenominador.
3. Modifique el Ejemplo PruebaRacional para que permita leer datos (números racionales) desde la entrada estándar (teclado).
4. Considere el Ejemplo Racional, ¿qué valor inicial tiene el objeto Racional s y m en las líneas 44 y 53 respectivamente?
5. Modifique el Ejemplo Racional para que, en lugar de acceder directamente a los atributos p y q de los objetos s y m (líneas 46-47 y 55-56 respectivamente), se acceda a ellos y se modifiquen sus correspondientes valores a través del método de tipo set correspondiente.
6. Con base en lo descrito en el blog, modifique el Ejemplo Racional para que cambie la sentencia (línea 46): s.p = p * r.obtenDenominador( ) + q * r.obtenNumerador( ); por: s.p = this.p * r.obtenDenominador( ) + this.q * r.obtenNumerador( ); realice también lo correspondiente para las líneas 47, 55 y 56 respectivamente.
7. El Ejemplo Racional implementa las operaciones de adición (suma) y multiplicación (multiplica). Para que la implementación sea completa, implemente las operaciones aritméticas faltantes de sustracción y división; utilice resta y divide respectivamente para los nombres de los métodos, y ajústese a la especificación de las operaciones definidas en la sección Especificación del ADT racional de la entrada Tipos de datos abstractos (ADT).
8. Además de lo desarrollado en el ejercicio anterior, piense en cómo mejorar la definición del ADT racional discutido en el texto. Tome en cuenta, al menos, los siguientes aspectos:
1. Comparación de igualdad: ¿cuándo se dice que dos números racionales son iguales? Ejemplo: 3 / 21 = 1 / 7.
2. Simplificación: simplificar a su expresión mínima un número racional, ya sea como resultado de una operación, o simplemente como utilidad. Ejemplo: 3 / 21 => 1 / 7. Sugerencia: obtenga el MCD (Máximo Común Divisor) del numerador y denominador a través de un método privado para simplificar el racional a su expresión mínima.
3. Cuando haga la representación en cadena del número racional (toString), considere lo siguiente: ¿qué sucede si  el resultado de la simplificación es, por ejemplo 3 / 1?, ¿tendría sentido presentarlo así?, ¿qué sucede si  el resultado de una operación es 0 / 13 por ejemplo? Si el denominador es 1, sólo presente el numerador, por otro lado, si el numerador es cero, sólo presente éste valor para tener una mejor representación en cadena del objeto Racional.
4. Por último, pero no por ello menos importante, una versión más robusta de Racional podría ser que implementara la interfaz Comparable del API. La idea es aquí definir el método compareTo() para determinar la relación de orden entre dos números racionales; así por ejemplo si r1 = 3 / 4 y r2 = 2 / 5, r1.compareTo(r2) regresaría 1, r2.compareTo(r1) regresaría -1 y 0 si ambos son iguales o equivalentes (vea 8.1).
   
9. Sean c1 y c2 dos números complejos definidos de la siguiente manera: c1 = (a + bi) y c2 = (c + di) donde a, b, c, d son números reales. Utilice las definiciones y operaciones siguientes para abstraer un ADT complejo y utilícelas para realizar una implementación de dicha entidad (como se hizo para el Ejemplo Racional). Escriba también una clase de prueba que permita probar la implementación del ADT complejo así como sus respectivas operaciones aritméticas:
1. La suma de c1 y c2 se define como: c1 + c2 = (a + bi) + (c + di)  = (a + c) + (b + d)i.
2. La resta de c1 y c2 se define como: c1 - c2 = (a + bi) - (c + di)  = (a - c) + (b - d)i.
3. La multiplicación de c1 y c2 se define como: c1 * c2 = (a + bi) * (c + di)  = (ac - bd) + (ad + bc)i.
4. La división es un poco más elaborada debido a que se racionaliza el denominador; es decir, se multiplica el numerador y el denominador por el conjugado del denominador. El conjugado de un número complejo se obtiene cambiando el signo de su componente imaginaria, es decir: si c = a + bi  es un número complejo, su conjugado está dado por c¹ = a - bi, entonces: c1 / c2 = (a + bi) / (c + di)  = [(a + bi) * (c - di)] / [(c + di) * (c - di)] = [(ac + bd) + (bc - ad)i] / (c² + d²).
10. Considere el Ejemplo Racional2, mismo que muestra el uso de la cláusula (palabra reservada) this e implementa algunas cambios respecto del Ejemplo Racional. Estudie y compare ambos ejemplos a fin de entender sus similitudes y diferencias. Tome en cuenta que, desde el punto de vista funcional (características, servicios y comportamiento de la clase) son exactamente iguales. No olvide probar su funcionamiento.
11. En base a la explicación dada en la sección Clases autorreferidas de la entrada Abstracción de estructuras de datos, modifique el Ejemplo Nodo de tal forma que sobre cargue el constructor para que, en caso de crear un objeto sin argumentos: Nodo nodo = new Nodo( ); se construya un objeto como el mostrado en la figura: . Utilice cero para el atributo dato y asegúrese de probar el funcionamiento de su constructor.
12. Diseñe y construya una clase (Cuadratica) que permita instanciar (generar) objetos que representen una ecuación cuadrática de la forma ax^2 + bx + c, donde a, b y c son los coeficientes de la ecuación. Su clase deberá:
1. Considerar el caso de intentar inicializar un objeto cuyo coeficiente a sea cero y proceder a crear y lanzar una excepción.
2. Permitir el cálculo de las raíces reales cuando existan.
3. Lanzar una excepción si las raíces no son reales.

Tipos de datos abstractos (ADT).

   Desde el punto de vista de la programación, es importante que los programadores puedan definir sus propias abstracciones de datos, de tal forma que dichas abstracciones trabajen de manera parecida a las abstracciones o a las primitivas de datos proporcionadas por el sistema subyacente.

   Un tipo de dato abstracto o ADT (Abstract Data Type) es definido por una especificación abstracta, es decir, permite especificar las propiedades lógicas y funcionales de un tipo de dato.

   Desde el punto de vista de los ADT, un tipo de dato es un conjunto de valores y un grupo de operaciones definidas sobre dichos valores. El conjunto de valores y el de las operaciones forman una estructura matemática que se implementa usando una estructura de datos particular de hardware o de software.

   El concepto de ADT está relacionado con la concepción matemática que define al tipo de datos por lo que, al definir un ADT como concepto matemático, no interesa la eficiencia del espacio o del tiempo (los cuales son aspectos relacionados con la implementación del ADT), sino las propiedades y características inherentes a él. La definición de un ADT no se relaciona en lo absoluto con los detalles de la implementación; de hecho, tal vez ni siquiera sea posible implementar un ADT particular en ningún tipo de hardware o software (piense por ejemplo en los números reales y en la propiedad de la densidad de los números reales por ejemplo).

   Un ADT consta de dos partes: una definición de valor y una definición de operador, mismas que se describen a continuación:

1. La definición del valor establece el conjunto de valores para el ADT y consta a su vez de dos partes:
1. Una cláusula de definición.
2. Una cláusula de condición. Para la definición de un ADT racional por ejemplo, una cláusula de condición estaría relacionada con la restricción de que el denominador de un número racional no puede ser cero.
2. En la definición del operador cada operador está definido como una operación abstracta con condiciones previas opcionales, y las condiciones posteriores o postcondiciones.

   Por otro lado, para la implementación de un ADT, es necesario tomar en cuenta los siguientes aspectos:

• Hacer disponible (pública) la definición del nuevo tipo.
• Hacer disponibles un conjunto de operaciones que puedan ser utilizadas para manipular las instancias del tipo definido (métodos públicos de servicios).
• Proteger los datos asociados con el tipo de dato que está siendo definido (atributos privados), de tal forma que dichos datos sólo puedan ser accedidos por medio de los métodos proporcionados para ello.
• Poder generar múltiples instancias del tipo definido, preferentemente, con más de una opción de inicialización, siempre que ésto no entre en contradicción con la definición o restricciones del tipo.

   Es importante resaltar que, asociado con un ADT particular, puede haber una o más implementaciones distintas.

   En resumen, los ADT son un mecanismo de abstracción sumamente importante y, dado que la programación orientada a objetos (POO) se fundamenta en la abstracción, es posible decir que constituye uno de los pilares de la orientación a objetos.

Especificación del ADT racional.
   Existen varios métodos para especificar un ADT, desde notaciones matemáticas hasta descripciones detalladas hechas en lenguaje natural. Lo importante de la especificación es que sea clara y no ambigüa.

   Esta sección, debido a las limitaciones de formato inherentes al blog, hará uso de algo parecido a una notación matemática apoyándose del lenguaje natural para la especificación del ADT racional.

   Sea r un número racional (Q). Se define r como el cociente de dos números enteros, es decir:

r = p / q

donde p, q son números enteros (Z) y q distinto de cero (!=0).

   Las operaciones aritméticas de suma, resta, multiplicación y división de dos números racionales se especifican a continuación.

   Sean r1 y r2 son dos números racionales (Q) definidos como:

r1 = p1 / q1 con p1, q1 números enteros (Z) y  q1 != 0

r2 = p2 / q2 con p2, q2 números enteros (Z) y  q2 != 0

entonces:

1. r1 + r2 = (p1 / q1) + (p2 / q2) = [ (p1 * q2) + (p2 * q1) ] / (q1 * q2).
2. r1 - r2 = (p1 / q1) - (p2 / q2) = [ (p1 * q2) - (p2 * q1) ] / (q1 * q2).
3. r1 * r2 = (p1 / q1) * (p2 / q2) = (p1 * p2) / (q1 * q2).
4. r1 / r2 = (p1 / q1) / (p2 / q2) = (p1 * q2) / (q1 * p2).

   Observe la especificación de los valores para el ADT racional, y la restricción que existe sobre el valor del denominador representado por q1 y q2 respectivamente.

   Finalmente, note que se ha proporcionado también la especificación de las operaciones aritméticas asociadas al ADT.

Un vistazo al lenguaje Java.

   El lenguaje de programación Java (Java es una marca registrada de Oracle Corporation) es amado por muchos y odiado por otros y no participaré en un debate estéril y ocioso. Sólo diré que, como casi todo en la vida, Java tiene sus ventajas y desventajas; lo que es innegable es que es un lenguaje de programación ampliamente difundido y utilizado y en ese sentido, resulta importante conocerlo y familiarizarse con él, independientemente de las posturas ideológicas y preferencias personales.

   Esta entrada del blog no es un tratado del lenguaje; es más, ni siquiera se acerca a un resumen, es más bien un compendio de referencia a la mano para el lector familiarizado con algún lenguaje de programación.

   La referencia obligada para esta entrada y para todo el blog en general es el API (Application Programming Interface) correspondiente a la versión 8 del lenguaje.

Orígenes y características.
   Java es un lenguaje de programación originalmente desarrollado por James Gosling cuando trabajaba en la desaparecida empresa Sun Microsystems, la cual fue adquirida por Oracle Corporation en el año 2009.
 
   El lenguaje fue publicado oficialmente en 1995 y deriva su sintaxis de C y C++; sin embargo, cuenta con menos facilidades de bajo nivel que cualquiera de ellos. Por otro lado, las aplicaciones o programas de Java son generalmente compiladas a bytecodes, los cuales pueden procesarse en cualquier máquina virtual Java (JVM) sin importar la arquitectura de la computadora, permitiendo así una mayor portabilidad del software entre plataformas.
 
   Java es un lenguaje de programación de propósito general, concurrente, basado en clases, y orientado a objetos, diseñado específicamente para tener tan pocas dependencias de implementación como fuera posible. Su intención es permitir que los desarrolladores de aplicaciones escriban el programa una vez, y lo ejecuten en cualquier dispositivo (WORA - Write Once, Run Anywhere).

Estructura general de una clase.
   La estructura general de la definición de una clase en Java es como la que se muestra en el Ejemplo EstructuraJava.

   Las líneas 1-5 muestran el uso de comentarios, se recomienda ampliamente iniciar la definición de cada clase con un comentario que describa el propósito de la clase. También es posible definir comentarios de la forma que se muestra en las líneas 10, 13, 17, y 18.

   La línea 6 muestra la definición de paquetes. Un paquete es un conjunto de clases relacionadas y la palabra reservada package, especifica a qué paquete pertenecen todas las clases definidas en el archivo fuente.

   En Java es posible definir más de una clase por archivo pero sólo una de ellas puede ser pública, y su nombre (identificador) debe corresponder con el nombre del archivo que la contiene. Para el caso del ejemplo anterior, el nombre de la clase es EstructuraJava y el del archivo EstructuraJava.java.

   La línea 7 muestra la importación de clases. Las clases se encuentran ubicadas en paquetes dentro del API, y cuando una clase utiliza alguna clase definida en algún otro paquete, ésto se especifica con la palabra reservada import.

   Las clases se definen por medio de la cláusula class y un identificador. En general, Java define tres niveles de acceso:

1. public (público) hace que una clase, método o atributo sea accesible para cualquier otra clase.
2. protected (protegido) hace a un método o atributo accesible únicamente por las clases del mismo paquete, o por subclases de la clase.
3. private (privado) hace a un método o atributo accesible únicamente desde su propia clase.

   La línea 11 muestra la definición de atributos, los cuales están compuestos por un identificador para el objeto (objeto), y el nombre de la clase de la que se derivará o instanciará. La definición de todos los atributos necesarios para la clase, siguen la misma estructura.

   Las líneas 14-15 muestran la definición de constructores. En la instanciación o generación de nuevos objetos, los objetos se construyen, por lo que no es posible crear un nuevo objeto sin un constructor. Un constructor es el código que se procesa cuando se crea un objeto a través de la cláusula new. La construcción de un objeto es un mecanismo mucho más elaborado del que aquí se describe, pero la explicación a detalle queda fuera de los alcances de esta entrada, y con la generalidad que se ha comentado antes, basta por ahora.

   Finalmente, las líneas 19-20 muestran la definición de métodos. Los métodos siguen los niveles de acceso descritos con anterioridad, pueden o no regresar un objeto de alguna clase (ClaseR) o un tipo de dato primitivo; y puede haber tantos como servicios quiera proporcionar la clase que los define.

Bienvenid@ a Java.
   El Ejemplo Bienvenido1 muestra el primer programa en Java que se describirá. La línea 5 del ejemplo muestra el punto de entrada de cualquier programa en Java: el método main, éste método siempre tendrá la forma que se muestra, la cual se conoce en general como la firma del método. La explicación y los detalles de args se revisará en los Ejemplos selectos de transición.

   En Java sólo es posible enviar mensajes a objetos que definan métodos públicos; sin embargo, la clase Bienvenido1 establece que su método main es static, lo cual quiere decir que puede ser invocado (llamado) sin una instancia específica u objeto que lo reciba. De hecho ésto es un mecanismo que utiliza Java para poder generar clases de utilerías o servicios sin embargo su uso debería ser minimizado, ya que se incurre en el estilo de la programación estructurada al utilizar dichas clases como bibliotecas de funciones.

   Finalmente, la forma más común de imprimir mensajes en la salida estándar (pantalla), es la que aparece en la línea 6 del Ejemplo Bienvenido1. System es una clase de servicios que tiene Java, y entre dichos servicios está el método println del objeto out, el cual recibe como argumento un objeto que representa una cadena (String), y lo envía a la salida estándar imprimiendo un salto de línea al final. La salida del Ejemplo Bienvenido1 se muestra en la siguiente figura:

Salida del Ejemplo Bienvenido1.

   Una versión ligeramente modificada del Ejemplo Bienvenido1 se muestra en el Ejemplo Bienvenido2.

   Observe ahora que en la línea 6 se ha cambiado el método println por el método print. Este último hace lo mismo que el método println con la diferencia de que el método print no imprime un salto de línea al final, de ahí que se haya dejado un espacio al final de la cadena Bienvenid@. La salida del Ejemplo Bienvenido2 es idéntica a la del Ejemplo Bienvenido1.

   Un tercera variación del Ejemplo Bienvenido1 se muestra en el Ejemplo Bienvenido3, el cual muestra el uso de la secuencia de escape \n para introducir un salto de línea en cualquier parte de la cadena que se desea imprimir. La salida del Ejemplo Bienvenido3 se muestra en la siguiente figura:

Salida del Ejemplo Bienvenido 3.

   Finalmente se presenta el Ejemplo Bienvenido4, el cual hace uso de la función printf para imprimir un mensaje en la pantalla. Aquellos lectores que estén familiarizados con el lenguaje de programación C se sentirán cómodos utilizando dicha función.

   Sin entrar mucho en detalles, sólo se indicará que %s es un especificador de formato que le indica a la función printf que imprima una cadena, misma que tomará después de la primera coma (,). Es importante señalar que por cada especificador de formato (tres en el ejemplo) debe existir su correspondiente cadena. La salida del Ejemplo Bienvenido4 es idéntica a la salida del Ejemplo Bienvenido3.

Compilación.
   Existen diferentes entornos de programación o (IDE - Integrated Development Environment) que pueden ser utilizados para desarrollar programas en Java, tales como JavaBeans, JCreator, Eclipse, etc., se recomienda al lector buscar y familiarizarse con alguno de ellos o con algún otro IDE que sea de su preferencia.

   Esta sección describe muy brevemente los pasos para la compilación desde la línea de comandos, ya que los programas de ejemplo de todo el blog pueden ser visualizados y editados en cualquier editor de texto, y compilados con el compilador de Java (javac) sin necesidad de un IDE. Es importante aclarar que se asume que se tiene instalado el jdk (java development kit). Si tiene dudas al respecto, consulte los detalles de instalación del jdk en la página oficial de Java.

   Para saber la versión de Java que tiene instalada, puede escribir desde la línea de comandos:

   $ javac -version

   Lo que deberá aparecer en su pantalla es la versión correspondiente del compilador; si aparece un mensaje distinto, es probable que no tenga instalado el jdk o que las rutas de acceso no sean las correctas.

   Para compilar el programa del Ejemplo Bienvenido1 (descrito en párrafos anteriores), tiene que escribir:

   $ javac Bienvenido1.java

   Cuando un programa se compila siguiendo la idea planteada, se buscarán todas las clases requeridas dentro del directorio de trabajo actual, mismo que corresponde al directorio en donde se haya ejecutado el compilador de Java. Si alguna clase tuviera algún problema, se reportará dicha situación antes de volver a visualizar el símbolo del sistema ($); en otro caso, se visualiza de manera casi inmediata el símbolo del sistema y observará que se han creado nuevos archivos, los cuales corresponden a los nombres de las clases pero con extensión class, mismos que representan los bytecodes que interpreta la máquina virtual de Java.

   La máquina virtual de Java o JVM es la encargada de interpretar y procesar los bytecodes que representan las instrucciones del programa compilado. La JVM está representada por el programa java, por lo que, para ejecutar un programa en Java, se debe proporcionar a la JVM la clase principal, la cual es la que contiene el método main:

   $ java Bienvenido1

   La salida del comando anterior, debería ser el mensaje presentado en la siguiente figura:

Salida esperada después de compilar y ejecutar el Ejemplo Bienvenido1.

 

 

POO (mensajes y métodos).

   Una de las principales inquietudes que expresan los estudiantes acerca del paradigma orientado a objetos está relacionada con los mensajes y los métodos. En este sentido, se iniciará con un ejemplo sumamente sencillo el cual irá evolucionando progresivamente con la finalidad de ilustrar dichos conceptos.

   Métodos sin argumentos.
   El Ejemplo Parvulo1 muestra la definición de la clase Parvulo1, misma que no contiene atributos pero sí un método cuyo identificador o nombre es mensaje.

   El método mensaje tiene como única responsabilidad la impresión en la salida estándar de una cadena (los detalles generales del funcionamiento de println son presentados en la entrada Un vistazo al lenguaje Java).

   En base a lo anterior, la clase Parvulo1 es una especie de plantilla capaz de generar objetos con una única responsabilidad o servicio, y no puede ser instanciada ni ejecutada por sí misma. Para poder instanciar objetos de la clase Parvulo1 y poder visualizar su funcionamiento, se requiere de una clase de prueba que permita generar una instancia de ella.

   La clase de prueba para el Ejemplo Parvulo1 es la clase PruebaParvulo1 que se presenta en el Ejemplo PruebaParvulo1.

   La clase PruebaParvulo1 tiene la estructura de la mayoría de las clases de prueba que se utilizarán en el blog, y está basada en la definición del método main.

   En la línea 7 se define el objeto parvulo cuya clase (tipo) de la que deriva es Parvulo1; así mismo, observe que se genera una instancia por medio de la cláusula new, misma que, entre otras cosas, construye el objeto. Si la clase Parvulo1 tuviera un constructor explícito, sería precisamente aquí en donde se invocaría. Más adelante en esta misma entrada, se profundizará un poco más al respecto.

   Una vez que el objeto existe, es decir, una vez que el objeto ha sido instanciado, es posible entonces interactuar con él por medio de mensajes para solicitarle acciones que correspondan con las responsabilidades o servicios definidos para dicho objeto que, para el caso del objeto parvulo, es sólo una.

   La solicitud del único servicio que puede proporcionar el objeto parvulo se realiza a través del mensaje mensaje, el cual es enviado (invocado) al objeto en la línea 9:

parvulo.mensaje();

   La expresión anterior se interpreta como: "se envía el mensaje mensaje al objeto parvulo". El envío de mensajes no es otra cosa más que la invocación explícita de un método a través de su identificador, es utilizar el método correspondiente para realizar una acción, misma que está relacionada con el comportamiento o las responsabilidades del objeto en cuestión.

   La salida del Ejemplo PruebaParvulo1 se muestra en la siguiente figura. Asegúrese de comprender lo descrito hasta aquí antes de continuar.

Salida del Ejemplo PruebaParvulo1.

   Métodos con argumentos.
   En esta sección se presenta una versión ligeramente distinta del Ejemplo Parvulo1, en el cual se presentó el envío de mensajes sin argumentos. Tómese el tiempo necesario para comparar el Ejemplo Parvulo2 de esta sección con el Ejemplo Parvulo1 de la sección anterior, y compruebe que son esencialmente iguales.

   El parámetro nombre en el método mensaje constituye la diferencia de los ejemplos anteriormente mencionados. En el Ejemplo Parvulo2 el método mensaje (línea 5) define ahora la capacidad de recibir un argumento de tipo cadena (un objeto de la clase String) referido por el objeto nombre. El método mensaje imprime en la salida estándar un cadena conformada por un texto predefinido (línea 6) y la cadena referida por nombre.

   Por otro lado, el Ejemplo PruebaParvulo2 muestra la clase de prueba para el Ejemplo Parvulo2, la cual es también similar a la del Ejemplo PruebaParvulo1 excepto en la forma en que se envía el mensaje al objeto parvulo (línea 10 del Ejemplo PruebaParvulo2). Observe que el mensaje enviado tiene ahora una cadena como argumento, la cual es referida por el objeto nombre del método mensaje (línea 5 del Ejemplo Parvulo2) en el momento en que se le envía el mensaje mensaje al objeto parvulo.

   Asegúrese de realizar una labor analítica al comparar línea a línea tanto las clases Parvulo1 y Parvulo2, como las clases PruebaParvulo1 y PruebaParvulo2 así como de comprender sus diferencias en base a lo que se ha descrito hasta ahora.

   La salida del Ejemplo PruebaParvulo2 se muestra en la siguiente figura:

Salida del Ejemplo PruebaParvulo2.

   Métodos y atributos.
   Por el principio de ocultación de información es conveniente que únicamente se tenga acceso a los atributos de una clase a través de su interfaz. La interfaz de un objeto está representada por sus métodos públicos (public).

   El Ejemplo Parvulo3 hace uso de dicho principio al definir, con un acceso restringido o privado (private), el atributo nombre (línea 6) para la clase Parvulo3. Observe que dicha clase define también tres métodos públicos, los cuales establecen la interfaz de los objetos que sean instanciados:

1. estableceNombre: este tipo de métodos son utilizados comúnmente para ajustar o establecer el valor de un atributo; y al menos en principio, debería haber un método de este tipo por cada atributo que contenga la clase y que se requiera manipular desde el exterior. Este tipo de métodos son comúnmente referidos como métodos de tipo set.
2. obtenNombre: este tipo de métodos son utilizados comúnmente para recuperar u obtener el valor de un atributo, y al igual que antes, debería haber, al menos en principio, un método de este tipo por cada atributo que contenga la clase y que se requiera visualizar desde el exterior. Este tipo de métodos son comúnmente referidos como métodos de tipo get.
3. mensaje: este ha sido descrito con anterioridad. Note que el método está definido como el del Ejemplo Parvulo1 (sin argumentos), pero funciona como el del Ejemplo Parvulo2. Asegúrese de comprender ésto antes de continuar.

   Observe que el método mensaje (líneas 16-18) se vale del método obtenNombre (línea 17) para acceder al atributo nombre pero no necesariamente tiene que ser así, ya que un método puede acceder directamente a los atributos de la clase, siempre y cuando ambos estén definidos dentro de la misma clase (encapsulamiento). Por otro lado, si el atributo tiene un nivel de acceso protegido (protected), los métodos de las clases derivadas por herencia también podrían acceder a los atributos de la clase de la que derivan (clase padre o super clase).

   Los métodos de tipo set sólo deben trabajar sobre un atributo, por lo que habitualmente sólo reciben un argumento, mismo que se corresponde con la clase (tipo) del atributo a modificar (String para el caso del Ejemplo Parvulo3). De manera análoga, los métodos de tipo get no reciben ningún tipo de argumento, y la clase de objetos que regresan está directamente relacionada con la clase del atributo al que accederán (String para el caso del Ejemplo Parvulo3).

   Es importante hacer notar también que la clase Parvulo3, a diferencia de las anteriores, establece ya una característica representada y definida por el atributo nombre, de tal forma que los objetos derivados de ella (párvulos) compartirán dicha característica (un párvulo es un niño pequeño en edad preescolar), aunque cada uno poseerá su propia identidad (nombre).

   El Ejemplo PruebaParvulo3 muestra la clase de prueba para la clase Parvulo3. Al igual que en los ejemplos anteriores para las clases de prueba, observe que en la línea 7 se define y crea el objeto parvulo.

   Las líneas 9 y 11 hacen uso del método obtenNombre a través del envío del mensaje correspondiente, mientras que la línea 10 envía el mensaje estableceNombre con un argumento específico. Finalmente, la línea 12 muestra el envío del mensaje mensaje, el cual debería resultarle ya familiar al lector.

   La salida del Ejemplo PruebaParvulo3 se muestra en la siguiente figura. Observe que inicialmente el atributo nombre del objeto parvulo no está definido, de ahí que se imprima null en la salida estándar, el cual es el valor por omisión en Java para las referencias a objetos que no han sido instanciados, es decir, cuando los objetos todavía no existen y por consiguiente no han sido inicializados.

Salida del Ejemplo PruebaParvulo3.

   Métodos y constructores.
   Un constructor es un método especial que se invoca implícitamente cuando se crea o instancia un objeto por medio de la cláusula new.

   La cláusula new genera la memoria necesaria para representar al objeto correspondiente y lo inicializa por medio de un constructor. En este sentido, puede haber más de una forma de inicializar un objeto y, en consecuencia, más de un constructor.

   El identificador o nombre de los métodos constructores debe coincidir con el identificador o nombre de la clase que los define; en base a lo anterior se tiene que puede haber más de un constructor compartiendo el mismo identificador. El mecanismo que tienen los constructores para distinguirse entre sí, es a través del número y clase o tipo de los parámetros que definen, constituyendo con ello una forma de polimorfismo comúnmente conocida como sobrecarga (la sobrecarga se trata con un poco más de detalle en la siguiente sección). En la creación del objeto, se invoca el constructor que coincida con el número y tipo de argumentos proporcionados a la cláusula new.

   Las líneas 9-11 del Ejemplo Parvulo4 muestran la definición del constructor Parvulo4, observe cómo el nombre del constructor coincide exactamente con el nombre de la clase. Dicho constructor define un único parámetro n el cual es un objeto de la clase String.

   La inicialización que hace el constructor Parvulo4 consiste únicamente de la asignación del objeto n al atributo representado por el objeto nombre.

   Es importante mencionar que la labor de inicialización de un constructor en particular puede ser un proceso mucho más elaborado que el descrito hasta ahora, y que estará en función directa de las responsabilidades de inicialización con que se quiera dotar al constructor y de la problemática en particular que se esté resolviendo por medio del objeto en cuestión.

   Los elementos restantes de la clase Parvulo4 han sido previamente abordados en las secciones anteriores por lo que no se repetirán aquí.

   El Ejemplo PruebaParvulo4 presenta la clase de prueba para el Ejemplo Parvulo4. Observe que a diferencia de los ejemplos anteriores, en la línea 8 se proporciona un argumento al constructor Parvulo4, lo cual hace que desde la creación del objeto parvulo se le esté definiendo un nombre.

   Observe también cómo la secuencia de mensajes subsecuentes coincide con las del Ejemplo PruebaParvulo3, excepto que en la línea 11 del Ejemplo PruebaParvulo4, se envía el mensaje estableceNombre al objeto parvulo para asignarle el nombre completo (con apellidos) al párvulo.

   Asegúrese de comprender antes de continuar, que la siguiente figura muestra la salida correspondiente a la ejecución del Ejemplo PruebaParvulo4:

Salida del Ejemplo PruebaParvulo4.

   Sobrecarga.
   La sobrecarga (overload) es un tipo de polimorfismo que se caracteriza por la capacidad de poder definir más de un método o constructor con el mismo nombre (identificador), siendo distinguidos entre sí por el número y la clase (tipo) de los argumentos que se definen.

   El Ejemplo Parvulo5 muestra la sobrecarga de constructores. Note que las líneas 8-10 definen el mismo constructor que el del Ejemplo Parvulo4 excepto por el nombre, y que se ha añadido o sobrecargado un nuevo constructor (líneas 12-14), el cual recibe tres argumentos que representan el nombre (n), el primer apellido (a1), y el segundo apellido (a2) de un párvulo.

   La sobrecarga de constructores se da porque ambos constructores tiene el mismo identificador (Parvulo5) pero distinto número de parámetros.

   No puede existir sobrecarga para constructores o métodos con el mismo identificador y el mismo número o clase (tipo) de parámetros; tiene que haber algo que los distinga entre sí, ya que en otro caso habría ambigüedad.

   Los métodos restantes del Ejemplo Parvulo5 ya ha sido comentados con anterioridad en otras secciones de esta misma entrada.

   La clase de prueba para el Ejemplo Parvulo5 se muestra en el Ejemplo PruebaParvulo5, la cual es también muy similar a las clases de prueba anteriormente explicadas. Únicamente cabe resaltar la creación del objeto parvulo en la línea 7. Note que ahora se le proporcionan tres argumentos al constructor, lo cual hace que el constructor utilizado sea el definido en las líneas 12-14 del Ejemplo Parvulo5.

   La salida del Ejemplo PruebaParvulo5 aparece en la siguiente figura. Compare dicha salida con la de la figura anterior y asegúrese de comprender la diferencia.

Salida del Ejemplo PruebaParvulo5.