jueves, 31 de octubre de 2013

ESTRUCTURAS DE PROGRAMACIÓN - IV

Bloque try {...} catch (...) finally {...} 
Java incorpora en el propio lenguaje la gestión de errores. El mejor momento para detectar los errores es durante la compilación. Sin embargo prácticamente sólo los errores de sintaxis son detectados en esta operación. El resto de problemas surgen durante la ejecución de los programas. En el lenguaje Java, una Exceplion es un cierto tipo de error o una condición anormal que se lia producido durante la ejecución de un programa. Algunas excepciones son fatales y provocan que se deba finalizar la ejecución del programa. En este caso conviene terminar ordenadamente y dar un mensaje explicando el tipo de error que se lia producido. Otras excepciones, como por ejemplo 110 encontrar un fichero en el que hay que leer o escribir algo, pueden ser recuperables. En este caso el programa debe dar al usuario la oportunidad de corregir el error (definiendo por ejemplo un nuevo path del fichero 110 encontrado).
Los errores se representan mediante clases derivadas de la clase Throwable, pero los que tiene que chequear un programador derivan de Exception (java.lang.Exception que a su vez deriva de Throwable). Existen algunos tipos de excepciones que Java obliga a tener en cuenta. Esto se hace mediante el uso de bloques try. catch y finally. 
El código dentro del bloque tiy está "vigilado". Si se produce una situación anormal y se lanza como consecuencia una excepción, el control pasa al bloque catch. que se hace cargo de la situación y decide lo que hay que hacer. Se pueden incluir tantos bloques catch como se desee, cada uno de los cuales tratará un tipo de excepción. Finalmente, si está presente, se ejecuta el bloque finally. que es opcional, pero que en caso de existir se ejecuta siempre, sea cual sea el tipo de error.
En el caso en que el código de un método pueda generar una Exception y no se desee incluir en dicho método la gestión del error (es decir los bucles try/catch correspondientes), es necesario que el método pase la Exception al método desde el que ha sido llamado. Esto se consigue mediante la adición de la palabra throws seguida del nombre de la Exception concreta, después de la lista de argumentos del método. A su vez el método superior deberá incluir los bloques try/catch o volver a pasar la Exception. De esta forma se puede ir pasando la Exception de un método a otro hasta llegar al último método del programa, el método inainQ.
En el siguiente ejemplo se presentan dos métodos que deben "controlar" una IOException relacionada con la lectura ficheros y una MyException propia. El primero de ellos (metodol) realiza la gestión de las excepciones y el segundo (metodo2) las pasa al siguiente método.

void metodol() {
try {
... // Código que puede lanzar las excepciones IOException y MyException
} catch (IOException el) {// Se ocupa de IOException simplemente dando aviso
System.out.println(el.getMessage());
} catch (MyException e2) {
// Se ocupa de MyException dando un aviso y finalizando la función
System.out.println(e2.getMessage()); return;
} finally { // Sentencias que se ejecutarán en cualquier caso
}]
} // Fin del metodol
void metodo2() throws IOException, MyException {
// Código que puede lanzar las excepciones IOException y MyException
} // Fin del metodo2

El tratamiento de excepciones se desarrollará con más profundidad en el Capítulo 8, a partir de la página 145.

ESTRUCTURAS DE PROGRAMACIÓN - III

Bucles 
Un bucle se utiliza para realizar un proceso repetidas veces. Se denomina también lazo o loop. El código incluido entre las llaves {} (opcionales si el proceso repetitivo consta de una sola línea), se ejecutará mientras se cumpla unas determinadas condiciones. Hay que prestar especial atención a los bucles infinitos, hecho que ocurre cuando la condición de finalizar el bucle {booleanExpression) 110 se llega a cumplir nunca. Se trata de un fallo muy típico, habitual sobre todo entre programadores poco experimentados. 

Bucle while 
Las sentencias statements se ejecutan mientras booleanExpression sea true.

while (booleanExpression) {
statements;
}
Buclefor
La forma general del bucle for es la siguiente:
for (initialization; booleanExpression; increment) {
statements;
}
que es equivalente a utilizar while en la siguiente forma.
initialization;
while (booleanExpression) {
statements;
increment;

}

La sentencia o sentencias initialization se ejecuta al comienzo del for. e increment después de statements. La booleanExpression se evalúa al comienzo de cada iteración: el bucle termina cuando la expresión de comparación toma el valor false. Cualquiera de las tres paites puede estar vacía. La initialization y el increment pueden tener varias expresiones separadas por comas. Por ejemplo, el código simado a la izquierda produce la salida que aparece a la derecha: 
Código:                                    Salida:
for(int i = 1, j = i + 10; i < 5; i++, j = 2*i) {      i = 1 j = 11
System.out.println(" i = " + i + " j = " + j);         i =  2  j  = 4
}                                                      i - 3 j - 6
i =                                                       4 j = 8

Sentencias break y continué 
La sentencia break es válida tanto para las bifurcaciones como para los bucles. Hace que se salga inmediatamente del bucle o bloque que se está ejecutando, sin sin realizar la ejecución del resto de las sentencias. La sentencia continué se utiliza en los bucles (110 en bifurcaciones). Finaliza la iteración "i" que en ese momento se está ejecutando (110 ejecuta el resto de sentencias que hubiera hasta el final del bucle). Vuelve al comienzo del bucle y comienza la siguiente iteración (i+1).

miércoles, 30 de octubre de 2013

ESTRUCTURAS DE PROGRAMACIÓN - II

Bifurcaciones Las bifurcaciones permiten ejecutar una de entre varias acciones en función del valor de una expresión lógica o relacional. Se tratan de estructuras muy importantes ya que son las encargadas de controlar el flujo de ejecución de un programa. Existen dos bifurcaciones diferentes: ify switch. 

  Bifurcación if 
Esta estructura permite ejecutar un conjunto de sentencias en función del valor que tenga la expresión de comparación (se ejecuta si la expresión de comparación tiene valor true). Tiene la forma siguiente:

if (booleanExpression) {
statements;
}

Las llaves {} sirven para agrupar en un bloque las sentencias que se han de ejecutar, y 110 son necesarias si sólo hay una sentencia dentro del if. 

 Bifurcación if else Análoga a la anterior, de la cual es una ampliación. Las sentencias incluidas en el else se ejecutan en el caso de 110 cumplirse la expresión de comparación (false).

if (booleanExpressionl) {
statements1;
} else if (booleanExpression2) {
statements2;
} else if (booleanExpression3) {
statements3;
} else {
statements4;
}
int numero = 61;          // La variable "numero" tiene dos dígitos
if(Math.abs(numero) < 10) // Math.absO calcula el valor absoluto. (false)
System.out.println("Numero tiene 1 dígito ");
else if (Math.abs(numero) < 100) // Si numero es 61, estamos en este caso (true)
System.out.println("Numero tiene 1 dígito ");
else {                    // Resto de los casos
System.out.println("Numero tiene mas de 3 dígitos ");
System.out.println("Se ha ejecutado la opcion por defecto ");
}

Sentencia switch Se trata de una alternativa a la bifurcación if elseif else cuando se compara la misma expresión con distintos valores. Su forma general es la siguiente:
switch (expression) {
case valuel:  statementsl;  break;
case value2:  statements2;  break;
case value3:  statements3;  break;
case value4:  statements4;  break;
case value5:  statements5;  break;
case value6:  statements6;  break;
[default: statements7;]

Las características más relevantes de switcli son las siguientes: 
1. Cada sentencia case se corresponde con un único valor de expression. No se pueden establecer rangos o condiciones sino que se debe comparar con valores concretos. El ejemplo del Apartado 2.3.3.3 no se podría realizar utilizando switch.
2. Los valores no comprendidos en ninguna sentencia case se pueden gestionar en default. que es opcional.
3. En ausencia de break, cuando se ejecuta una sentencia case se ejecutan también todas las case que van a continuación, hasta que se llega a un break o hasta que se termina el switch. Ejemplo:

char c = (char)(Math.random()*26+'a1); // Generación aleatoria de letras minúsculas
System.out.println("La letra " + c );
switch (c) {
case
'a'
//
Se
compara
con
la
letra
a
case
'e'
//
Se
compara
con
la
letra
e
case
'i'
//
Se
compara
con
la
letra
i
case
'o'
//
Se
compara
con
la
letra
o
case
1 u1
//
Se
compara
con
la
letra
u
System.out.println(" Es una vocal "); break;
default:
System.out.println(" Es una consonante ");
}

martes, 29 de octubre de 2013

ESTRUCTURAS DE PROGRAMACIÓN - I

En este apartado se supone que el lector tiene algunos conocimientos de programación y por lo tanto 110 se explican en profundidad los conceptos que aparecen. Las estructuras de programación o estructuras de control permiten tomar decisiones y realizar un proceso repetidas veces. Son los denominados bifurcaciones y bucles. En la mayoría de los lenguajes de programación, este tipo de estructuras son comunes en cuanto a concepto, aunque su sintaxis varía de un lenguaje a otro. La sintaxis de Java coincide prácticamente con la utilizada en C/C++. lo que hace que para un programador de C/C++110 suponga ninguna dificultad adicional. 

Sentencias o expresiones 
Una expresión es un conjunto variables unidos por operadores. Son órdenes que se le clan al computador para que realice una tarea determinada. Una sentencia es una expresión que acaba en punto y coma (:). Se permite incluir varias sentencias en una línea, aunque lo liabimal es utilizar una línea para cada sentencia. Por ejemplo:
i = 0; j =5; x = i + j;// Línea compuesta de tres sentencias

Comentarios 
Existen dos formas diferentes de introducir comentarios entre el código de Java (en realidad son tres, como pronto se verá). Son similares a la forma de realizar comentarios en el lenguaje C++. Los comentarios son tremendamente útiles para poder entender el código utilizado, facilitando de ese modo finuras revisiones y correcciones. Además permite que cualquier persona distinta al programador original pueda comprender el código escrito de una forma más rápida. Se recomienda acostumbrarse a comentar el código desarrollado. De esta forma se simplifica también la tarea de estudio y revisión posteriores. Java interpreta que todo lo que aparece a la derecha de dos barras "//" en una línea cualquiera del código es un comentario del programador y 110 lo tiene en cuenta. El comentario puede empezar al comienzo de la línea o a continuación de una instrucción que debe ser ejecutada. La segunda forma de incluir comentarios consiste en escribir el texto entre los símbolos /*...*/. Este segundo método es válido para comentar más de una línea de código. Por ejemplo:

// Esta línea es un comentario
int a=l; // Comentario a la derecha de una sentencia
// Esta es la forma de comentar más de una línea utilizando
// las dos barras. Requiere incluir dos barras al comienzo de cada línea
/* Esta segunda forma es mucho más cómoda para comentar un número elevado de líneas
ya que sólo requiere modificar
el comienzo y el final. */


En Java existe además una forma especial de introducir los comentarios (utilizando /**...*/ más algunos caracteres especiales) que permite generar automáticamente la documentación sobre las clases y packages desarrollados por el programador. Una vez introducidos los coméntanos, el programa javadoc.e.xe (incluido en el JDK) genera de forma automática la información ele forma similar a la presentada en la propia documentación del JDK. La sintaxis de estos comentarios y la forma de utilizar el programa javadoc.exe se puede encontrar en la información que viene con el JDK

lunes, 28 de octubre de 2013

Precedencia de operadores

El orden en que se realizan las operaciones es fundamental para determinar el resultado de una expresión. Por ejemplo, el resultado de x/y*z depende de qué operación (la división o el producto) se realice primero. La siguiente lista muestra el orden en que se ejecutan los distintos operadores en un sentencia, de mayor a menor precedencia:

postfix operators
[] . (params) expr++ expr--
unary operators
++expr --expr +expr -expr ~ !
creation or cast
new (type)expr
multiplicative
* / %
additive
+ -
shifit
« >> »>
relational
<><=>= instanceof
equality
== ! =
bitwise AND
&
bitwise exclusive OR
-
bitwise inclusive OR
1
logical .AND
&&
logical OR
1 1
conditional
? :
assigmnent
= += -= *= /= %= &= |= «=

En Java, todos los operadores binarios, excepto los operadores de asignación, se evalúan de izquierda a derecha. Los operadores de asignación se evalúan de derecha a izquierda, lo que significa que el valor de la derecha se copia sobre la variable de la izquierda.

domingo, 27 de octubre de 2013

Operadores que actúan a nivel de bits

Java dispone también de 1111 conjunto de operadores que actúan a nivel de bits. Las operaciones de bits se utilizan con frecuencia para definir señales o flags. esto es. variables de tipo entero en las que cada 11110 de sus bits indican si una opción está activada o no. La Tabla 2.5 muestra los operadores de Java que acn'ian a nivel de bits.
En binario, las potencias de dos se representan con un único bit activado. Por ejemplo, los números (1. 2. 4. 8. 16. 32. 64. 128) se representan respectivamente de modo binario en la forma (00000001. 00000010. 00000100, 00001000. 00010000. 00100000. 01000000. 10000000). utilizando sólo 8 bits. La suma de estos números permite construir una variable flags con los bits activados que se deseen. Por ejemplo, para construir una variable flags que sea 00010010 bastaría hacer flags=2+16. Para saber si el segundo bit por la derecha está o no activado bastaría utilizar la sentencia, if (flags & 2 == 2) {...} La Tabla 2.6 muestra los operadores de asignación a nivel de bits.

sábado, 26 de octubre de 2013

Operador de concatenación de cadenas de caracteres (+)

El operador más (+) se utiliza también para concatenar cadenas de caracteres. Por ejemplo, para escribir una cantidad con 1111 rótulo y unas unidades puede utilizarse la sentencia: System.out.println("El total asciende a " + result + " unidades"); donde el operador de concatenación se utiliza dos veces para construir la cadena de caracteres que se desea imprimir por medio del método println(). La variable numérica result es convertida automáticamente por Java en cadena de caracteres para poderla concatenar. En otras ocasiones se deberá llamar explícitamente a 1111 método para que realice esta conversión.

viernes, 25 de octubre de 2013

Operadores lógicos

Los operadores lógicos se utilizan para construir expresiones lógicas, combinando valores lógicos (true y/o false) o los resultados de los operadores relaciónales. La Tabla 2.4 muestra los operadores lógicos de Java. Debe notarse que en cienos casos el segundo operando 110 se evalúa porque ya no es necesario (si ambos tienen que ser true y el primero es false. ya se sabe que la condición de que ambos sean true 110 se va a cumplir). Esto puede traer resultados 110 deseados y por eso se han añadido los operadores (&) y (|) que garantizan que los dos operandos se evalúan siempre.

Operadores relaciónales

Los operadores relaciónales sirven para realizar comparaciones de igualdad, desigualdad y relación de menor o mayor. El resultado de estos operadores es siempre un valor boolean (true o false) según se cumpla o no la relación considerada. La Tabla 2.3 muestra los operadores relaciónales de Java.
Estos operadores se utilizan con mucha frecuencia en las bifurcaciones y en los bucles. que se verán en próximos apartados de este capítulo.

jueves, 24 de octubre de 2013

Operadores incrementales

Java dispone del operador incremento (++) y decremento (--). El operador (++) incrementa en una unidad la variable a la que se aplica, mientras que (--) la reduce en una unidad. Estos operadores se pueden utilizar de dos formas: 

1. Precediendo a la variable (por ejemplo: ++/). En este caso primero se incrementa la variable y luego se utiliza (ya incrementada) en la expresión en la que aparece. 
2. Siguiendo a la variable (por ejemplo: /++). En este caso primero se utiliza la variable en la expresión (con el valor anterior) y luego se incrementa. 

En muchas ocasiones estos operadores se utilizan para incrementar una variable fuera de una expresión. En este caso ambos operadores son equivalente. Si se utilizan en una expresión más complicada, el resultado de utilizar estos operadores en una u otra de sus formas será diferente. La actualización de contadores en bucles for es una de las aplicaciones más frecuentes de estos operadores.

Operador condicional ?:

Este operador, tomado de C/C++. permite realizar bifurcaciones condicionales sencillas. Su forma general es la siguiente: booleanExpression ? resl : res2 
donde se evalúa booleanExpression y se devuelve resl si el resultado es true y res2 si el resultado es false. Es el único operador temario (tres argumentos) de Java. Como todo operador que devuelve un valor puede ser utilizado en una expresión. Por ejemplo las sentencias: x=l ; y=10; z = (x

miércoles, 23 de octubre de 2013

OPERADORES DE JAVA

Java es un lenguaje rico en operadores, que son casi idénticos a los de C/C++. Estos operadores se describen brevemente en los apartados siguientes. 
  Operadores aritméticos Son operadores binarios (requieren siempre dos operandos) que realizan las operaciones aritméticas habituales: suma (+). resta (-). multiplicación (*). división (/) y resto de la división (%). 
  Operadores de asignación Los operadores de asignación permiten asignar un valor a una variable. El operador de asignación por excelencia es el operador igual (=). La forma general de las sentencias de asignación con este operador es: variable = expression; Java dispone de otros operadores de Tabla 2.2. Otros operadores de asignación, asignación. Se trata de versiones abreviadas del operador (=) que realizan operaciones '•acumulativas" sobre una variable. La Tabla 2.2 muestra estos operadores y su equivalencia con el uso del operador igual (=).
Operadores uiiarios Los operadores más (+) y menos (-) imarios sirven para mantener o cambiar el signo de una variable, constante o expresión numérica. Su uso en Java es el estándar de estos operadores.
Operador instanceof El operador instanceof permite saber si un objeto pertenece o no a una determinada clase. Es un operador binario cuya forma general es. objectName instanceof ClassName y que devuelve true o false según el objeto pertenezca o no a la clase.

martes, 22 de octubre de 2013

Casos especiales: Clases Bigluteger y BigDecimal

Java 1.1 incorporó dos nuevas clases destinadas a operaciones aritméticas que requieran gran precisión: Bigluteger y BigDecimal. La forma de operar con objetos de estas clases difiere de las operaciones con variables primitivas. En este caso hay que realizar las operaciones utilizando métodos propios de estas clases (add() para la suma, subtract() para la resta. divide() para la división, etc.). 
Se puede consultar la ayuda sobre el package java.math. donde aparecen ambas clases con todos sus métodos. Los objetos de tipo Bigluteger son capaces de almacenar cualquier número entero sin perder información durante las operaciones. Análogamente los objetos de tipo BigDecimal permiten trabajar con el número de decimales deseado.

sábado, 19 de octubre de 2013

Visibilidad y vida de las variables

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

viernes, 18 de octubre de 2013

Cómo se definen e inicializan las variables

Una variable se define especificando el tipo y el nombre de dicha variable. Estas variables pueden ser tanto de tipos primitivos como referencias a objetos de alguna clase perteneciente al API de Java o generada por el usuario. Si no se especifica un valor en su declaración, las variable primitivas se inicializan a cero (salvo boolean y char. que se inicializan a false y '\0'). Análogamente las variables de tipo referencia son inicializadas por defecto a un valor especial: nuil. Es importante distinguir entre la referencia a un objeto y el objeto mismo. Una referencia es una variable que indica dónde está guardado un objeto en la memoria del ordenador (a diferencia de C/C++. Java no permite acceder al valor de la dilección, pues en este lenguaje se han eliminado los punteros). Al declarar una referencia todavía no se encuentra "apuntando*' a ningún objeto en particular (salvo que se cree explícitamente un nuevo objeto en la declaración), y por eso se le asigna el valor nuil. Si se desea que esta referencia apunte a un nuevo objeto es necesario crear el objeto utilizando el operador new. Este operador reserva en la memoria del ordenador espacio para ese objeto (variables y funciones). También es posible igualar la referencia declarada a otra referencia a un objeto existente previamente. 
Un tipo particular de referencias son los arrays o vectores, sean éstos de variables primitivas (por ejemplo, un vector de enteros) o de objetos. En la declaración de una referencia de tipo array hay que incluir los corchetes []. En los siguientes ejemplos aparece cómo crear un vector de 10 números enteros y cómo crear un vector de elementos MyClass. Java garantiza que los elementos del vector son inicializados a nuil o a cero (según el tipo de dato) en caso de no indicar otro valor.

Ejemplos de declaración e inicialización de variables:
int x;            // Declaración de la variable primitiva x. Se inicializa a 0
int y = 5;        // Declaración de la variable primitiva y. Se inicializa a 5
MyClass unaRef;          // Declaración de una referencia a un objeto MyClass.
// Se inicializa a nuil
unaRef = new MyClass();     // La referencia "apunta" al nuevo objeto creado
// Se ha utilizado el constructor por defecto
MyClass segundaRef = unaRef; // Declaración de una referencia a un objeto MyClass.
// Se inicializa al mismo valor que unaRef
int [] vector;       // Declaración de un array. Se inicializa a nuil
vector = new int[10]; // Vector de 10 enteros, inicializados a 0
double [] v = {1.0, 2.65, 3.1};// Declaración e inicialización de un vector de 3
// elementos con los valores entre llaves
MyClass [] lista=new MyClass[5];// Se crea un vector de 5 referencias a objetos
// Las 5 referencias son inicializadas a nuil
lista[0] = unaRef;          // Se asigna a lista[0] el mismo valor que unaRef
lista[l] = new MyClass(); // Se asigna a lista[l] la referencia al nuevo objeto
// El resto (lista [2] ...lista [4] siguen con valor nuil


En el ejemplo mostrado las referencias unaRef. segundaRef y lis ra[0] actuarán sobre el mismo objeto. Es equivalente utilizar cualquiera de las referencias ya que el objeto al que se refieren es el mismo.

sábado, 12 de octubre de 2013

PROGRAMACIÓN EN JAVA - Tipos Pvimitivos de Variables

Tipos Pvimitivos de Variables 
Se Hainan tiposprimitivos de variables de Java a aquellas variables sencillas que contienen los tipos de informacion mas habituales: valores boolean. caracteres yvalores numericos enteros o de pnnto flotante. Java dispone de ocho tipos primitivos de variables: un tipo para almacenar valores true y false {boolean)-, un tipo para almacenar caracteres {char), y 6 tipos para guardar valores numericos. cuatro tipos para enteros {byte, short, int y long) y dos para valores reales de punto flotante (float y double). Los rangos y la memoria que ocupa cada uno de estos tipos se muestran en la Tabla 2.1.
Tabla 2.1. Tipos primitivos de variables en Java.
Los tipos primitivos de Java tienen algunas características importantes que se resumen a continuación: 
1. El tipo boolean no es mi valor numérico: sólo admite los valores true o false. El tipo booleati no se identifica con el igual o distinto de cero, como en C/C++. El resultado de la expresión lógica que aparece como condición en un bucle o en una bifurcación debe ser boolean. 
2. El tipo citar contiene caracteres en código UNICODE (que incluye el código ASCII), y ocupan 16 bits por carácter. Comprende los caracteres de prácticamente todos los idiomas. 
3. Los tipos byte. short. int y long son números enteros que pueden ser positivos o negativos, con distintos valores máximos y mínimos. A diferencia de C/C++. en Java no hay enteros unsigned. 
4. Los tipos float y don ble son valores de punto flotante (números reales) con 6-7 y 15 cifras decimales equivalentes, respectivamente. 
5. Se utiliza la palabra void para indicar la ausencia de un tipo de variable determinado. 
6. A diferencia de C/C++. los tipos de variables en Java están perfectamente definidos en todas y cada una de las posibles plataformas. Por ejemplo, un int ocupa siempre la misma memoria y tiene el mismo rango de valores, en cualquier tipo de ordenador. 
7. Existen extensiones de Java 1.2 para aprovechar la arquitectura de los procesadores Intel, que permiten realizar operaciones de punto flotente con una precisión extendida de 80 bits.

PROGRAMACIÓN EN JAVA - Nombres de Variables

Nombres de Variables 
Los nombres de variables en Java se pueden crear con mucha libertad. Pueden ser cualquier conjunto de caracteres numéricos y alfanuméricos. sin algunos caracteres especiales utilizados por Java como operadores o separadores ( ..+-*/ etc.). Existe una serie de palabras resecadas las cuales tienen un significado especial para Java y por lo tanto no se pueden utilizar como nombres de variables. Dichas palabras son:
(*) son palabras reservadas, pero no se utilizan en la acftial implementación del lenguaje Java.

viernes, 11 de octubre de 2013

PROGRAMACIÓN EN JAVA - VARIABLES

Una variable es un nombre que contiene un valor que puede cambiar a lo largo del programa. De acuerdo con el tipo de información que contienen, en Java hay dos tipos principales de variables: 
1. Variables de tipos primitivos. Están definidas mediante un valor único que puede ser entero, de punto flotante, carácter o booleano. Java permite distinta precición y distintos rangos de valores para estos tipos de variables (ehar. byte. short. int. long.float. double, boolean). Ejemplos de variables de tipos primitivos podrían ser: 123. 3456754. 3.1415, 12e-09. 'A'. Truc, etc. 
2. Variables referencia. Las variables referencia son referencias o nombres de una información más compleja: arrays u objetos de una determinada clase. Desde el punto de vista del papel o misión en el programa, las variables pueden ser: 
1. Variables miembro de una clase: Se definen en una clase, fuera de cualquier método; pueden ser tipos primitivos o referencias. 
2. Variables locales: Se definen dentro de un método o más en general dentro de cualquier bloque entre llaves {}. Se crean en el interior del bloque y se destruyen al finalizar dicho bloque. Pueden ser también tipos primitivos o referencias.

PROGRAMACIÓN EN JAVA

En este capítulo se presentan las características generales de Java como lenguaje de programación algorítmico. En este apartado Java es muy similar a C/C++, lenguajes en los que está inspirado. Se va a intentar ser breve, considerando que el lector ya conoce algunos otros lenguajes de programación y está familiarizado con lo que son variables, bifurcaciones, bucles, etc.

jueves, 10 de octubre de 2013

ESTRUCTURA GENERAJL DE UN PROGRAMA JAVA - II

Herencia 
La herencia permite que se pueden definir nuevas clases basadas en clases existentes, lo cual facilita re-utilizar código previamente desarrollado. Si una clase deriva de otra (extends) hereda todas sus variables y métodos. La clase derivada puede añadir nuevas variables y métodos y/o redefinir las variables y métodos heredados. En Java. a diferencia de otros lenguajes orientados a objetos, una clase sólo puede derivar de una única clase, con lo cual no es posible realizar herencia múltiple en base a clases. Sin embargo es posible "5111111131" la herencia múltiple en base a las interfaces. 
Concepto de Interface 
Una interface es un conjunto de declaraciones de funciones. Si una clase implementa (implements) 1111a interface. debe definir todas las funciones especificadas por la interface. Una clase puede implementar más de una interface. representando una forma alternativa de la herencia múltiple. A su vez. una interface puede derivar de otra o incluso de varias interfaces. en cuyo caso incorpora todos los métodos de las interfaces de las que deriva.
Concepto (le Interface
Una interface es un conjunto de declaraciones de funciones. Si una clase iniplenienta (implements) una interface. debe definir todas las funciones especificadas por la interface. Una clase puede implementar más de una interface. representando una forma alternativa de la herencia múltiple. A su vez. una interface puede derivar de otra o incluso de varias interfaces. en cuyo caso incorpora todos los métodos de las interfaces de las que deriva.
Concepto de Package
Un package es una agrupación de clases. Existen una serie de packages incluidos en el lenguaje (ver jerarquía de clases que aparece en el API de Java). Además el usuario puede crear sus propios packages. Lo habimal es juntar en packages las clases que estén relacionadas. Todas las clases que formen parte de un package deben estar en el mismo directorio.

La jerarquía de clases de Java (API) 
Durante la generación de código en Java. es recomendable y casi necesario tener siempre a la vista la documentación on-line del API de Java 1.1 ó Java 1.2. En dicha documentación es posible ver tanto la jerarquía de clases, es decir la relación de herencia entre clases, como la información de los distintos packages que componen las librerías base de Java. 
Es importante distinguir entre lo que significa herencia y package. Un package es una agrupación arbitraria de clases, una forma de organizar las clases. La herencia sin embargo consiste en crear nuevas clases en base a otras ya existentes. Las clases incluidas en un package no derivan por lo general de una única clase. En la documentación on-line se presentan ambas visiones: "Package Index" y "Class Hierarcliy". tanto en Java 1.1 como en Java 1.2. con pequeñas variantes. La primera presenta la estructura del API de Java agrupada por packages. mientras que en la segunda aparece la jerarquía de clases. Hay que resaltar una vez más el hecho de que todas las clases en Java son derivadas de la clase java.lang.Object. por lo que heredan todos los métodos y variables de ésta. 
Si se selecciona una clase en particular, la documentación muestra una descripción detallada de todos los métodos y variables de la clase. A su vez muestra su herencia completa (partiendo de la clase java.lang.Object).

ESTRUCTURA GENERAJL DE UN PROGRAMA JAVA - I

El anterior ejemplo presenta la estrucmra habimal de un programa realizado en cualquier lenguaje orientado a objetos u OOP (Object Orí en red Programming), y en particular en el lenguaje Java. Aparece una clase que contiene el programa principal (aquel que contiene la función main()) y algunas clases de usuario (las específicas de la aplicación que se está desarrollando) que son utilizadas por el programa principal. Los ficheros fílente tienen la extensión *.java. mientras que los ficheros compilados tienen la extensión *.class. 
Un fichero fuente (*.java) puede contener más de una clase, pero sólo una puede ser public. El nombre del fichero fílente debe coincidir con el de la clase public (con la extensión *.java). Si por ejemplo en un fichero aparece la declaración {public class MiClase {...}) entonces el nombre del fichero deberá ser MiClase.java. Es importante que coincidan mayúsculas y minúsculas ya que MiClase.java y miclase.java serían clases diferentes para Java. Si la clase no es public. no es necesario que su nombre coincida con el del fichero. Una clase puede ser public o package (default). pero 110prívate o protected. Estos conceptos se explican posteriormente.
De ordinario una aplicación está constituida por varios ficheros *.class. Cada clase realiza unas funciones particulares, permitiendo construir las aplicaciones con gran medularidad e independencia entre clases. La aplicación se ejecuta por medio del nombre de la clase que contiene la función inain() (sin la extensión *.class). Las clases de Java se agrupan en packages, que son librerías de clases. Si las clases 110 se definen como pertenecientes a un package. se utiliza un package por defecto (default) que es el directorio activo. Los packages se estudian con más detenimiento el Apartado 3.6. a partir de la página 47.
Concepto de Clase 
Una clase es una agrupación de datos (variables o campos) y de funciones (métodos) que operan sobre esos datos. A estos datos y funciones pertenecientes a una clase se les denomina variables y métodos o funciones miembro. La programación orientada a objetos se basa en la programación de clases. Un programa se construye a partir de un conjunto de clases. 
Una vez definida e implementada una clase, es posible declarar elementos de esta clase de modo similar a como se declaran las variables del lenguaje (de los tipos primitivos int, double. String, ...). Los elementos declarados de una clase se denominan objetos de la clase. De una única clase se pueden declarar o crear numerosos objetos. La clase es lo genérico: es el patrón o modelo para crear objetos. Cada objeto tiene sus propias copias de las variables miembro, con sus propios valores, en general distintos de los demás objetos de la clase. Las clases pueden tener variables static. que son propias de la clase y no de cada objeto.

miércoles, 9 de octubre de 2013

NOMENCLATURA HABITUAL EX LA PROGRAMACIÓN EN JAVA

Los nombres de Java son sensibles a las letras mayúsculas y minúsculas. Así. las variables masa. Masa y MASA son consideradas variables completamente diferentes. Las reglas del lenguaje respecto a los nombres de variables son muy amplias y permiten mucha libertad al programador. pero es habimal seguir ciertas normas que facilitan la lectura y el mantenimiento de los programas de ordenador. Se recomienda seguir las siguientes instrucciones: 
  1.  En Java es habimal utilizar nombres con minúsculas, con las excepciones que se indican en los puntos siguientes. 
  2. Cuando un nombre consta de varias palabras es habimal poner una a continuación de otra, poniendo con mayúscula la primera letra de la palabra que sigue a otra (Ejemplos: elMavorQ, VentanaCerrable. RectauguloGrafico. addWindowListenerQ). 
  3. Los nombres de clases e interfaces comienzan siempre por mayúscula (Ejemplos: Geometría. Rectángulo. Dibujable. Graphics. ArrayList, Iterator). 
  4. Los nombres de objetos, los nombres de métodos y variables miembro, y los nombres de las variables locales de los métodos, comienzan siempre por minúscula (Ejemplos: mainQ, dibujar (), numRectangulos, x. y. r). 
  5. Los nombres de las variables finales, es decir de las constantes, se definen siempre con mayúsculas (Ejemplo: PI)

Consideraciones adicionales sobre el Ejemplo 1

Es muy importante entender los conceptos explicados: esto puede facilitar mucho la comprensión de los capimlos que siguen.

Se puede practicar con este ejemplo creando algunos objetos más en el programa principal o introduciendo alguna otra pequeña modificación.

martes, 8 de octubre de 2013

Clase VeutanaCerrable - II

La sentencia 12 (addwindowiistener (this);) es muy importante y significativa sobre la forma en que el AWT de Java gestiona los eventos sobre las ventanas y en general sobre lo que es la interface gráfica de usuario. Cuando un elemento gráfico -en este caso la ventana- puede recibir eventos del usuario es necesario indicar quién se va a encargar de procesar esos eventos. De ordinario al producirse un evento se debe activar un método determinado que se encarga de procesarlo y realizar las acciones pertinentes (en este caso cenar la ventana y la aplicación). La sentencia 12 ejecuta el método a del Win el o wL i si en er() de la clase Frame (que a su vez lo ha heredado de la clase Window). El argumento que se le pasa a este método indica qué objeto se va a responsabilizar de gestionar los eventos que reciba la ventana implementando la interface WindowListener. En este caso, como el argumento que se le pasa es this. la propia clase VentanaCerrable debe ocuparse de gestionar los eventos que reciba. Así es. puesto que dicha clase implementa la interface WindowListener según se ve en la sentencia 4. Puede notarse que como el constructor por defecto de las sentencias 6-8 no utiliza el método addWindowListener(), si se construye una VentanaCerrable sin tímlo no podrá ser cenada del modo habitual. Así se ha hecho deliberadamente en este ejemplo para que el lector lo pueda comprobar con facilidad.
La interface WindowListener define los siete métodos necesarios para gestionar los siete eventos con los que se puede actuar sobre una ventana. Para cenar la ventana sólo es necesario definir el método windowCiosingQ. Sin embargo, el implementar una interface obliga siempre a definir todos sus métodos. Por ello en las sentencias 15-21 todos los métodos están vacíos (solamente el punto y coma entre llaves), excepto el que realmente interesa, que llama al método exit() de la clase System. El argumento "0" indica terminación normal del programa.

Clase VeutanaCerrable - I

La clase VeutanaCerrable es la última clase de este ejemplo. Es una clase de "utilidad" que mejora algo las características de la clase Frame de Java, de la que deriva. La clase Frame estándar tiene una limitación y es que 110 responde a las acciones normales en Windows para cenar una ventana o una aplicación (por ejemplo, clicar en la cruz de la esquina superior derecha). En ese caso, para cenar la aplicación es necesario recurrir por ejemplo al comando End Task del Task Manager de Windows NT (que aparece con Ctrl+Alt+Supr). Para evitar esta molestia se ha creado la clase VeutanaCerrable. que deriva de Frame e implementa la interface WindowListener. A continuación se muestra el código de la clase VeutanaCerrable.

1. // Fichero VentanaCerrable.java
2. import j ava.awt.*;
3. import j ava.awt.event.*;
4. class VentanaCerrable extends Frame implements WindowListener {
5.       // constructores
6.       public VentanaCerrable() {
7 .      super();
8.                         }
9.      public VentanaCerrable(String title) {
10.         super(title);
11.         setSize (500,500);
12.         addWindowListener(this);
13.      }
14.      // métodos de la interface WindowsListener
15.     public void windowActivated(WindowEvent e) {;}
16.     public void windowClosed(WindowEvent e) {;}
17.     public void windowClosing(WindowEvent e) {System.exit(0);}
18.     public void windowDeactivated(WindowEvent e) {;}
19.     public void windowDeiconified(WindowEvent e) {;}
20.      public void windowlconified(WindowEvent e) {;}
21.      public void windowOpened(WindowEvent e) {;}
22.   } // fin de la clase VentanaCerrable

La clase VentanaCerrable contiene dos constructores. El primero de ellos es un constructor por defecto (sin argumentos) que se limita a llamar al constructor de la super-clase Frame con la palabra super. El segundo constructor admite un argumento para poner timlo a la ventana: llama también al constructor de Frame pasándole este mismo argumento. Después establece un tamaño para la ventana creada (el tamaño por defecto para Frame es cero).

lunes, 7 de octubre de 2013

Clase PanelDibujo - III

El poder utilizar nombres de una super-clase o de una interface permite tratar de un modo unificado objetos distintos, aunque pertenecientes a distintas sub-clases o bien a clases que implementan dicha interface. Esta es la idea en la que se basa el polimorfismo.
Ahora ya se está en condiciones de volver al código del método paintQ. definido en las sentencias 14-22 de la clase PanelDibujo. El método paintQ es un método heredado de Container. que a su vez re-define el método heredado de Component. En la clase PanelDibujo se da una nueva definición de este método. Una peculiaridad del método paintQ es que. por lo general, el programador 110 tiene que preocuparse de llamarlo: se encargan de ello Java y el sistema operativo. 
El programador prepara por 1111a parte la ventana y el panel en el que va a dibujar, y por otra programa en el método paintf) las operaciones gráficas que quiere realizar. El sistema operativo y Java llaman a paintQ cada vez que entienden que la ventana debe ser dibujada o re-dibujada. El único argumento de paintQ es un objeto g de la clase Graphics que. como se ha dicho antes, constituye el contexto gráfico (color de las líneas, tipo de letra, etc.) con el que se realizarán las operaciones de dibujo.


La sentencia 15 (Dibujable dib;) crea una referencia de la clase Dibujable. que como se ha dicho anteriormente, podrá apuntar o contener objetos de cualquier clase que iniplemente dicha interface. La sentencia 16 (iterator it;) crea una referencia a un objeto de la interface Iterator definida en el package java.util. La interface Iterator proporciona los métodos hasNextQ. que chequea si la colección de elementos que se está recorriendo tiene más elementos y nextQ. que devuelve el siguiente elemento de la colección. Cualquier colección de elementos (tal como la clase ArrayList de Java, o como cualquier tipo de lista vinculada programada por el usuario) puede implementar esta interface, y ser por tanto utilizada de un modo uniforme. En la sentencia 17 se utiliza el método iteratorf) de la clase ArrayList (it = v. iterator <);). que devuelve una referencia Iterator de los elementos de la lista v. Obsérvese la diferencia entre el método iteratorf) de la clase ArrayList y la interface Iterator. En Java los nombre sde las clases e interfaces siempre empiezan por mayúscula, mientras que los métodos lo hacen con minúscula. Las sentencias 18-21 representan un bucle while cuyas sentencias -encelladas entre llaves {...}- se repetirán mientras haya elementos en la enumeración e (o en el vector v).
Lo que se acaba de explicar puede parecer 1111 poco complicado, pero es típico de Java y de la programación orientada a objetos. La ventaja del método paintf) así programado es que es absolutamente general: en ningún momento se hace referencia a las clases RectauguloGrafico y CirculoGrafico. cuyos objetos son realmente los que se van a dibujar. Esto permite añadir nuevas clases tales como  TrianguloGrafico. PoligonoGrafico. LineaGrafica. etc.. sin tener que modificar para nada el código anterior: tan sólo es necesario que dichas clases implenienten la interface Dibujable. Esta es una ventaja no pequeña cuando se trata de crear programas extensibles (que puedan crecer), flexibles (que se puedan modificar) y reutilizables (que se puedan incorporal' a otras aplicaciones).

domingo, 6 de octubre de 2013

Clase PanelDibujo - II

Las sentencias 2-4 imponan las clases necesarias para construir la clase PanelDibujo. Se importan todas las clases del package java. awt. La clase ArrayList y la interface Iterator pertenecen al package java.util. y sirven para tratar colecciones o conjuntos, en este caso conjuntos de figuras dibujables.

La sentencia 5 indica que la clase PanelDibujo deriva de la clase Panel, heredando de ésta y de sus super-clases Container y Component todas sus capacidades gráficas. La sentencia 7 (prívate ArrayList v;) crea una variable miembro v que es una referencia a un objeto de la clase ArrayList (nótese que no es un objeto, sino una referencia o un nombre de objeto). Las sentencias 9-12 definen el constructor de la clase, que recibe como argumento una referencia va a un objeto de la clase ArrayList. En esta lista estarán almacenadas las referencias a los objetos -rectángulos y círculos- que van a ser dibujados. En la sentencia 10 (super (new FlowLayout o );) se llama al constructor de la super-clase panel, pasándole como argumento un objeto recién creado de la clase FlowLayout. Como se verá más adelante al hablar de construcción de interfaces gráficas con el AWT. la clase FlowLayout se ocupa de distribuir de una deteiminada forma (de izquierda a derecha y de arriba abajo) los componentes gráficos que se añaden a un "container" tal como la clase Panel. En este caso no tiene mucha importancia, pero conviene utilizarlo.
Hay que introducir ahora un aspecto muy importante de Java y. en general, de la programación orientada a objetos. Tiene que ver con algo que es conocido con el nombre de Polimorfismo. La idea básica es que una referencia a un objeto de una determinada clase es capaz de sen-ir de referencia o de nombre a objetos de cualquiera de sus clases derivadas. Por ejemplo, es posible en Java hacer lo siguiente:
Geometría geoml, geom2;
geoml = new RectanguloGrafico(0, 0, 200, 100, Color.red);
geom2 = new CirculoGrafico(200, 200, 100, Color.blue);

Obsérvese que se han creado dos referencias de la clase Geometría que posteriormente apuntan a objetos de las clases derivadas RectauguloGrafico y CirculoGrafico. Sin embargo, hay una cierta limitación en lo que se puede hacer con las referencias geoml y geom2. Por ser referencias a la clase Geometría sólo se pueden utilizar las capacidades definidas en dicha clase, que se reducen a la utilización de los métodos perimetroQ y areaQ.
De la misma forma que se ha visto con la clase base Geometría, en Java es posible utilizar una referencia del tipo correspondiente a una interface para manejar objetos de clases que implementan dicha interface. Por ejemplo, es posible escribir: 
Dibujable dibl, dib2;
dibl = new RectanguloGrafico(0, 0, 200, 100, Color.red);
dib2 = new CirculoGrafico(200, 200, 100, Color.blue);

Clase PanelDibujo - I

La clase que se describe en este apartado es muy importante y quizás una de las más difíciles de entender en este capimlo introductorio. La clase PanelDibujo es muy importante porque es la responsable final de que los rectángulos y círculos aparezcan dibujados en la pantalla. Esta clase deriva de la clase Panel, que deriva de Container, que deriva de Component, que deriva de Object. Ya se ha comentado que Object es la clase más general de Java. La clase Component comprende todos los objetos de Java que tienen representación gráfica, tales como botones, bañas de desplazamiento, etc. Los objetos de la clase Container son objetos gráficos del A ff 'T (Abstract Windows Tooíkit: la librería de clases de Java que permite crear interfaces gráficas de usuario) capaces de contener otros objetos del AWT. La clase Panel define los Container más sencillos, capaces de contener otros elementos gráficos (como otros paneles) y sobre la que se puede dibujar. La clase PanelDibujo contiene el código que se muestra a continuación.

1. // fichero PanelDibujo.java
2 .        import j ava.awt.*;
3.   import java.útil.ArrayList;
4.   import java.útil.Iterator;
5.   public class PanelDibujo extends Panel {
6.       // variable miembro
7.       private ArrayList v;
8.       // constructor
9.      public PanelDibujo(ArrayList va) {
10.         super(new FlowLayout());
11.         this.v = va;
12.      }
13.      // redefinición del método paint()
14.     public void paint(Graphics g) {
15.         Dibujable dib;
16.         Iterator it;
17.         it = v.iterator() ;
18.         while(it.hasNext()) {
19.            dib = (Dibujable)it.next();
20.            dib.dibujar(g);
21.         }
22.         }
23.
} // Fin de la clase PanelDibujo

sábado, 5 de octubre de 2013

Clase CirculoGrafico

A continuación se define la clase CirculoGrafico. que deriva de la clase Circulo e implementa la interface Dibujable. Esta clase es muy similar a la clase RectauguloGrafico y 110 requiere explicaciones especiales.

// fichero CirculoGrafico.java
import java.awt.Graphics;
import java.awt.Color;
public class CirculoGrafico extends Circulo implements Dibujable {
// se heredan las variables y métodos de la clase Circulo
Color color;
// constructor
public CirculoGrafico(double x, double y, double r, Color unColor) {
// llamada al constructor de Circulo
super(x, y, r);
this.color = unColor;
}
// métodos de la interface Dibujable
public void dibujar(Graphics dw) {
dw.setColor(color);
dw.drawOval((int)(x-r),(int)(y-r),(int)(2*r),(int)(2*r));
}
public void setPosicion(double x, double y) {
r
}
} // fin de la clase CirculoGrafico

viernes, 4 de octubre de 2013

Clase RectauguloGrafico - II

Las sentencias 2 y 3 importan dos clases del package java.awt. Otra posibilidad sería importar todas las clases de dicho package con la sentencia (import java. awt.*;).
La sentencia 4 indica que RectauguloGrafico deriva de la clase Rectángulo e implementa la interface Dibujable. Recuérdese que mientras que sólo se puede derivar de una clase, se pueden implementar varias interfaces. en cuyo caso se ponen en el encabezamiento de la clase separadas por comas. La sentencia 6 (color color;) define una nueva variable miembro que se suma a las que ya se tienen por herencia. Esta nueva variable es un objeto de la clase Color.
Las sentencias 8-13 definen el constructor general de la clase, al cual le llegan los cinco argumentos necesarios para dar valor a todas las variables miembro. En este caso los nombres de los argumentos también coinciden con los de las variables miembro, pero sólo se utilizan para pasárselos al constructor de la super-clase. En efecto, la sentencia 11 (super(xi, yi, x2, y2);) contiene una novedad: para dar valor a las variables heredadas lo más cómodo es llamar al constructor de la clase padre o super-clase. al cual se hace referencia con la palabra super.
Las sentencias 14-18 y 19-21 definen los dos métodos declarados por la interface Dibujable. El método dibujarf) recibe como argumento un objeto dw de la clase Graphics. Esta clase define un contexto para realizar operaciones gráficas en un panel, tales como el color de las líneas, el color de fondo, el tipo de letra a utilizar en los rótulos, etc. Más adelante se verá con más detenimiento este concepto. La sentencia 16 (dw.setcoior (color),-) hace uso un método de la clase Graphics para determinar el color con el que se dibujarán las líneas a partir de ese momento. La sentencia 17 (dw. drawRect ( (int) xl, (int)yl, (int) (x2-xl) , (int) (y2-yl) ) ;) llama a Otl'O método de esa misma clase que dibuja un rectángulo a partir de las coordenadas del vértice superior izquierdo, de la anchura y de la altura.
Java obliga a iniplementar o definir siempre todos los métodos declarados por la interface. aunque no se vayan a utilizar. Esa es la razón de que las sentencias 19-21 definan un método vacío,
que sólo contiene un carácter punto y coma. Como no se va a utilizar 110 importa que esté vacío, pero Java obliga a dar una definición o implementación 

Clase RectauguloGrafico - I

La clase RectauguloGrafico deriva de Rectángulo (lo cual quiere decir que hereda sus métodos y variables miembro) e implementa la interface Dibujable (lo cual quiere decir que debe definir los métodos declarados en dicha interface). A continuación se incluye la definición de dicha clase.

1. // Fichero RectanguloGrafico.java
2.   import java.awt.Graphics;
3.   import java.awt.Color;
4.   class RectanguloGrafico extends Rectángulo implements Dibujable {
5.       // nueva variable miembro
6.      Color color;
7.       // constructor
8.      public RectanguloGrafico(double xl, double yl, double x2, double y2,
9.                          Color unColor) {
10.         // llamada al constructor de Rectángulo
11.         super(xl, yl, x2, y2);
12.         this.color = unColor; // en este caso this es opcional
13.      }
14.      // métodos de la interface Dibujable
15.     public void dibujar(Graphics dw) {
16.         dw.setColor(color) ;
17.         dw.drawRect((int)xl, (int)yl, (int)(x2-xl), (int)(y2-yl));
18.      }
19.     public void setPosicion(double x, double y) {
20.         ; // método vacío, pero necesario de definir
21.      }
22.         } // fin de la clase RectanguloGrafico

jueves, 3 de octubre de 2013

Interface Dibujable

El diagrama de clases de la Figura 1.2 indica que las clases RectanguloGrafico y CirculoGrafico son el resultado, tanto de las clases Rectángulo y Circulo de las que derivan, como de la interface Dibujable. que de alguna manera interviene en el proceso. 
El concepto de interface es muy importante en Java. A diferencia de C++, Java 110 permite herencia múltiple, esto es. 110 permite que una clase derive de dos clases distintas heredando de ambas métodos y variables miembro. La herencia múltiple es fuente de problemas, pero en muchas ocasiones es una característica muy conveniente. Las interfaces de Java constituyen una alternativa a la herencia múltiple con importantes ventajas prácticas y de "estilo de programación".
Una interface es 1111 conjunto de declaraciones de métodos (sin implementación. es decir, sin definir el código de dichos métodos). La declaración consta del tipo del valor de retomo y del nombre del método, seguido por el tipo de los argumentos entre paréntesis. Cuando una clase implementa una determinada interface. se compromete a dar una definición a todos los métodos de  la interface. En cierta forma una interface se parece a una clase abstract cuyos métodos son todos abstract. La ventaja de las interfaces es que 110 están sometidas a las más rígidas normas de las clases: por ejemplo, una clase 110 puede heredar de dos clases abstract. pero sí puede implementar varias interfaces.
Una de las ventajas de las interfaces de Java es el establecer pautas o modos de funciona- miento similares para clases que pueden estar o 110 relacionadas mediante herencia. E11 efecto, todas las clases que implementan una determinada interface soportan los métodos declarados en la interface y en este sentido se comportan de modo similar. Las interfaces pueden también relacionarse mediante mecanismos de herencia, con más flexibilidad que las clases. Más adelante se volverá con más detenimiento sobre este tema, muy importante para muchos aspectos de Java. El fichero Dibujablejava define la interface Dibujable. mostrada a continuación.

1.   // fichero Dibujable.java
2.   import java.awt.Graphics;
3.   public interface Dibujable {
4.     public void setPosicion(double x, double y);
5.     public void dibujar(Graphics dw) ;
6.   }

La interface Dibujable está dirigida a incorporar, en las clases que la implenienten, la capacidad de dibujar sus objetos. El listado muestra la declaración de los métodos setPosicionQ y dibujar(). La declaración de estos métodos 110 tiene nada de particular. Como el método dibujar() utiliza como argumento un objeto de la clase Graphics, es necesario importar dicha clase. Lo importante es que si las clases RectanguloGrafico y CirculoGrafico implenientan la interface Dibujable sus objetos podrán ser representados gráficamente en pantalla.