Java. Parte III

ArticleCategory: [Artikel Kategorie]

AuthorImage:[Bild des Autors]

AuthorName:[Name des Autors]

AboutTheAuthor:[Über den Autor]

Abstract:[Zusammenfassung]

ArticleIllustration:[Titelbild des Artikels]

ArticleBody:[Der eigentliche Artikel]

Introducción

CLASES. PAQUETES. INTERFACES. CLASES ABSTRACTAS. SUPER. THIS. STATIC. MATRICES. STRING

Se puede hacer que ciertos métodos sean sobrescritos por las subclases utilizando el identificador de tipo abstracto. Es responsabilidad de la subclase implementarlo ya que no posee ninguna implementación de la superclase. La forma general:

Cualquier clase que contenga uno o más métodos abstractos se tiene que declarar como abstract, para declararla simplemente, se utiliza la palabra abstract al principio de la declaración de la clase. No se puede crear instancias de estos tipos de clases. Aunque sí pueden ser utilizadas para crear referencias a objetos. Es posible crear una referencia de una clase abstracta para que pueda ser utilizada como referencia a un objeto de una subclase. Gracias a este mecanismo se puede decidir en tiempo de ejecución cuál de las versiones de un método sobrescrito se debe ejecutar.

Para que un método haga referencia al objeto que lo invocó, Java define una palabra clave this, es siempre una referencia al objeto sobre el que ha sido llamado el método. Se utiliza siempre que se quiera hacer una referencia a un objeto del tipo de la clase actual.

Para definir métodos de una clase que puedan ser utilizados por sí mismo sin referirse a una instancia específica se precede en la declaración del método con la palabra clave static. El método puede ser referenciado sin haber creado ningún objeto de esa clase. El ejemplo más común es en la declaración de main() ya que es llamado sin que exista ningún objeto.

Super se puede utilizar para dos cosas: para llamar al constructor de la superclase y para acceder a un miembro de la superclase que ha sido ocultado por un miembro de la subclase.

Paquetes: son contenedores de clases que se utilizan para dividir en compartimentos el espacio de nombres de clases, los paquetes son un componente básico de los programas, para definirlos hay que utilizar el comando package como primera sentencia del archivo fuente. Cualquier clase que se defina dentro de este archivo pertenece a ese paquete, estos definen un conjunto de espacios de nombres particionados en los que se almacenan las clases.
 

Import paquete1. [paquete2].(nombre_clase | *) ;

Todas las clases estándar están almacenadas en algún paquete con nombre Java, con la sentencia import importamos paquetes enteros en nuestros programas y así una clase incluida en el paquete importado puede ser referenciada directamente. El formato general se la sentencia import es:
 

[public ] nombre_interface{  tipo metodo1 (parámetros); tipo variable_final1=valor;  tipo metodo2 (parámetros); tipo variable_final2=valor; ...  tipo metodo (parámetros); tipo variable_finaln=valor;  }

Interfaces: En las clases que definimos como interfaces especificamos qué es lo que hace, pero no cómo lo hace. Tienen el mismo aspecto que una clase pero sin variables de instancias y con métodos declarados sin cuerpos. Definiendo una interfaz cualquier clase puede implementarla. Este mecanismo permite implementar totalmente el polimorfismo "una interfaz múltiples métodos". Las interfaces están es jerarquías distintas de las de las clases, por lo que es posible que varias clases sin relación implementen la misma interfaz. El formato general de una interfaz sería:

Observa que los métodos declarados no tienen cuerpo, son métodos abstractos ya que no se pueden implementar en la declaración de una interfaz, cada clase que incluye una interfaz debe implementar todos los métodos. El acceso a la interfaz es public o no se utiliza, en este último caso se utiliza el modificador de acceso por defecto y la interfaz estará solo disponible para los otros miembros de paquete en la que ha sido declarada. Si se declara public la interfaz puede ser utilizada por cualquier código.

Las variables se pueden declarar dentro de las declaraciones de la interfaz y son implícitamente "final" y static lo que indica que sólo se puede modificar la clase que las implementa y además pueden ser inicializadas con un valor constante.
 

[public] class nombre_clase [extends superclase] [implements interfaz1, [interfaz2]....] { //cuerpo  }

Una vez definida la interfaz una o varias clases pueden implementarla, para ello hay que incluir la sentencia implements en la definición de la clase y crear los métodos definidos por la interfaz. El formato general será:

El formato del método implementado debe coincidir exactamente con el formato del tipo especificado en la definición de la interfaz.

Las interfaces a igual que las clases pueden utilizar la herencia, incluyendo la palabra clave extends.

Para poder realizar ejemplos de todo los que llevamos hasta ahora , estudiaremos dos clases que nos serán muy útiles la clase String y las matrices.

Matrices: Las matrices, como casi todo el mundo sabe, son un grupo de variables del mismo tipo, a las que se hace referencia con el mismo nombre. Se pueden crear matrices de cualquier tipo y pueden tener una o más dimensiones. Además las matrices no son un tipo simple de datos por lo que, por definición, todo lo que no es un tipo simple de datos es un objeto en Java, y las matrices habrá que tratarlas como tal.

La forma general de la definición de una matriz es:
 

Esta declaración establece una variable tipo matriz pero realmente no existe ninguna matriz hasta que no resolvemos memoria con el operador new.

Donde tipo específica el tipo de los datos que van a ser asignados, tamaño el número de elementos de la matriz. La memoria necesaria para cada matriz la reserva dinámicamente, una vez reservada se puede acceder a un elemento específico de la misma indicando su índice entre corchetes.

La definición de una matriz se puede hacer en una sola línea:
 

String: a igual que las tablas los string son otra estructura básica para cualquier lenguaje de programación y a igual que los array los String en Java no son un tipo básico por lo que se implementa como un objeto. Dispone de un conjunto completo de operaciones que facilita su utilización.

Hay algo importante en la clase String, cuando se crea un objeto de este tipo no puede ser modificado (no se pueden modificar los carácteres que forman la cadena). Java nos permite hacerlo aunque lo que ocurre es que creamos un nuevo objeto con las modificaciones ya realizadas, esta implementación la realiza Java por eficiencia del lenguaje. Existe una clase paralela a la String llamada StringBuffer que permite ser modificada.

Como toda clase que se precie la clase String y StringBuffer tiene varios constructores:
 

Si tenemos creado el string del ejemplo anterior, podemos hacer:

Con lo que las dos instancias creadas tendrán el mismo contenido.
 

String cadena = "aAbB";

Una forma muy común de crear un String es utilizar literales:

Ya que Java crea automáticamente un objeto String por cada literal de tipo cadena que haya en el programa.

Una vez creada nuestra instancia podemos realizar multitud de operaciones que corresponde con los métodos definidos en esta clase, repasaremos los más interesantes: donde c = "aAbB"
 

Ejemplo: repasaremos en este ejemplo algunos de los temas que hemos visto, en este ejemplo desarrollaremos una clase que nos sirva para contar los distintos caracteres que le enviamos en un String. La clase la instanciaremos desde otra clase principal que recibe la cadena a analizar desde la línea de comandos:
 

Class Contar{
char La_Matriz[] = new char[128];

void Caracteres(String La_Cadena){
int Indice;
char car; 
for(Indice=0 ; Indice<La_Cadena.length() ; Indice++){
car = La_Cadena.charAt(Indice);  
++La_Matriz[car]; 
} 
}

void Resultado (){
int Indice, Resultado;
char car;
for (Indice=0;Indice < 128;Indice++){
car=(char)Indice;
Resultado =(int)La_Matriz[Indice];
If (Resultado > 0){ 
        System.out.println("del caracter " 
             + car + " hay :" 
             + Resultado
             + " Caracteres" );
} 
} 
} 

class Pcontar {

public static void main(String arg[]) {
String cadena = "";
int i;
for(i=0; i<arg.length ;i++){
cadena = cadena + arg[i]; } 
Contar Frases = new Contar();  
System.out.println(cadena); 
Frases.Caracteres(cadena); 
Frases.Resultado(); }
}

PROGRAMACION CONCURRENTE

El paradigma de la orientación a objetos y la ejecución en subprocesos permite a usuario interactuar con varios objetos simultáneamente. De quí en adelante supondré que el lector conoce los conceptos básicos de programación concurrente: hilo de ejecución, sección crítica, semáforo, recurso etc. Estos conceptos están perfectamente explicados en cualquier buen libro sobre sistemas operativos.

Existen dos formas de crear una clase que admita ejecutarse en subprocesos múltiples:

• crear una clase Thread
• utilizando la interfaz Runnable

Para crear subprocesos hijos extendiendo la clase Thread:
 

 
Class nombre_clase extends Thread { 
Public void run() { 
// cuerpo de ejecucion del subproceso. 
} 
}

Para instanciar la clase y crear el subproceso concurrente con el hilo principal haremos:
 

Y llamaremos al método start() que invoca al método run(), iniciando el subproceso y volviendo al hilo principal.

Si lo hacemos con la interfaz Runnable:
 

Class nombre_clase implements Runnable { 
Public void run() { 
// cuerpo subproceso 
} 
}

Nombre_clase nombre_instancia = new nombre_clase; 
New Thread(nombre_instancia).Start();

Normalmente se utilizará este último método ya que por una norma no escrita se extiende una clase si ésta va a ser mejorada o sobrescrita y éste no es el caso de la clase Thread.

Otros métodos útiles para controlar el estado y ejecución de un subproceso serán:
 

Cuando uno o varios subprocesos comparten un recurso, ya sea un dispositivo físico o simplemente variables y se pueden producir "condiciones de carrera" (esto es, errores de ejecución debido a una ejecución no secuencial) se debe implementar la sincronización entre los hilos para asegurar que solo uno está accediendo al recurso en un instante dado. Java proporciona un soporte único a nivel de lenguaje, utilizando el concepto de semáforo, este no es mas que un objeto que puede ser utilizado por un solo subproceso en un instante determinado. Esto se pude hacer por dos vías:

Restringiendo el acceso a un método, utilizando la palabra clave synchronized en la definición del método.
 

Class nombre_clase { Syschronized void metodo () {

la segunda vía sería con la sentencia syschronized, la llamada a los métodos se realiza dentro de un bloque de código sincronizado.
 

Sysnchronized (objeto){    // sentencias que deben ser sincronizadas }

Java implementa métodos para facilitar la comunicación eficiente entre subprocesos:
 

Ejemplo:

En el siguiente programa veremos como utilizamos la concurrencia e Java, para ello creamos una clase que escribe en la salida estándar si un número es divisible por otro. El programa principal recibe como parámetro el limite de la serie y llama concurrentemente a la primera clase de tres formas para obtener los múltiplos de 2, 3 y 5 de forma concurrente.
 

Class Cmultiplos implements Runnable {
int limite, multiplo;
Thread t;
Cmultiplos (int h , int m){
limite = h;
multiplo = m;
t = new Thread(this, "hijo");
t.start();
}

public void run() {
for (int i = 1;i < limite + 1; i++) {
int mod = i % multiplo;
if (mod == 0){
System.out.println( i + " es multiplo de " 
                    + multiplo);
} 
}
}
}
  

class Multiplos {

public static void main (String arg[]) {
int parametro=Integer.valueOf(arg[0]).intValue();
new Cmultiplos(parametro,2);
new Cmultiplos(parametro,3);
new Cmultiplos(parametro,5);
}
}

EXCEPCIONES EN JAVA

try {
// código que puede generar una excepción
} catch (excepción 1 nombre){
 // gestión excepcion1 }
} catch (excepción2 nombre){
// gestión de excepcion2 }
} finally {
//código
} 

Para manejar excepciones lo realizaremos con la ayuda de:

Try:

crea un bloque de código donde puede producirse una excepción.

Catch:

recoge las instrucciones generadas y las trata.

Finally:

recoge el código que necesitamos que se ejecute incluso aunque se genere una excepción.

E/S EN JAVA

La entrada-salida más habitual será la realizada con los dispositivos por defecto: la consola como salida y el teclado como entrada (ya lo hemos utilizado en algunos ejemplos anteriores).

En la cima de la jerarquía de clases de E/S se encuentra las clases InputStream y OutputStrean de las cuales se derivan el resto de las clases, la entrada y salida estándar están encapsuladas en la variables de objeto int y out de la clase System, dichas variables de objeto son de los tipos InputStrean y OutputStream respectivamente. Por lo que:
 

La salida estándar la conocemos de ejemplos anteriores por lo que veremos la utilización de System.int con el método principal que es Read(), el formato general será:
 

Con este método, por cada llamada lee un único carácter y lo devuelve como un valor entero. Devuelve -1 cuando encuentra el final del flujo. Como podemos observar hay que controlar la excepción IOException.

Además de la E/S básico, el dispositivo más importante para comunicarse con el mundo exterior es el sistema de archivos. La clase File proporciona un método independiente para guardar información referente a un archivo, se utiliza para obtener modificar la información asociada a un archivo.

Los objetos File se pueden crear utilizando uno de los tres constructores siguiente (los ejemplos utilizan un archivo en /usr/local/texto/articulo.txt):
 

La clase file define muchos métodos, donde los más destacados pueden ser:
 

FileInputStream : crea un InputStream que se puede utilizar para leer el contenido de un archivo. Los constructores más habituales son:
 

Donde ruta es el nombre completo del directorio de un archivo y obj es un objeto de tipo File. Si el archivo no existe genera una excepción.

Métodos definidos por fileinputstream:
 

La clase FileOutputStream crea un OutputStream que se utiliza para escribir en un archivo. Sus dos constructores más habituales son:
 

Donde ruta es nuevamente el directorio completo de un archivo y obj un objeto de tipo File, puede lanzar una excepción IOException. Los métodos más interesantes que define esta clase son:
 

Java permite los flujos con bufer, esto permite realizar las operaciones de E/S con varios bytes a la vez incrementándose el rendimiento. Se define las clases:
 

RandomAccessFile
 

RandomAccesFile(File obj, string modo) RandomAccesFile(String archivo, String modo)

Ofrece múltiples métodos para interacciones con un archivo, en esta clase se aúnan todas las funciones de las clases anteriores más la posibilidad de acceder a un archivo que se encuentre en cualquier lugar y además es posible determinar con exactitud la posición del archivo desde el cual se desea recuperar los datos. Se definen los siguientes constructores:

Donde obj especifica el nombre del archivo que se desea abrir a igual que archivo pero este como un String. En ambos casos modo determina el tipo de acceso al archivo:

Ejemplo :
En el siguiente ejemplo veremos como accedemos a un fichero secuencial, leeremos carácter a carácter y como en un ejemplo anterior calcularemos el numero de caracteres que hay distintos en el fichero:
 

import java.io.*;
class Fichero {

public static void main(String args[]){ 
int i, j ;
char c;
char linea[] = new char [256];
String archivo= args[0]; 
FileInputStream fichero;
try { 
fichero = new FileInputStream(archivo);
}catch (FileNotFoundException e) {
System.out.println("archivo no encontrado");
Return;
} 
try {
do {
i = fichero.read();
if (i != -1)
++linea[i];
} while (i != -1);
}catch(IOException e){
System.out.println("error e/s");
return;
}
try {
fichero.close();
}catch(IOException e){
System.out.println("error e/s");
return;
}
for (j=0;j<256;j++) {
if (linea[j] > 0)
System.out.println("del caracter: "
                   + (char)j
                   + " hay :"
                   + (int)linea[j]);
}
}
}

PAQUETES

Paquete java.lang:

Es el más íntimamente relacionado con el lenguaje. Contiene :

• La clase Object madre de todas las clases.
• Clases correspondientes a los tipo base: Boolean, Character, Byte, Short, Integer, Long, Float, Void , a estas clases se les llaman envolventes y se utilizan cuando se quieren utilizar los tipos básicos como objetos.
• Math, proporciona funciones matemáticas avanzadas.
• String y StringBuffer para gestionar las cadenas de caracteres.
• Throwable, Exception y Error para la gestión de errores.
• Tread y ThrreadGroup para la gestión de los procesos concurrentes.
• Runtime y System para acceder a funciones de bajo nivel la JVM y del sistema anfitrión.

Dentro de las clases señalaremos:

Clase Math:

Esta Pseudoclase define las principales cosntantes matemáticas y las funciones más habituales. La función Log se refiere a los logaritmos neperianos.

public static final Double E=2.718281828459045
public static final Double PI=3.14592653589793
public static Double abs(Double a)
public static float abs(float a)
public static int abs(int a)
public static native Double acos(Double a)
public static native Double asin(Double a)
public static native Double atan(Double a)

idem para las funciones: cos, exp, floor, log, max, min, round, sin, sqrt, tan.

Clase Object:

Esta clase es la antecesora de todas las demás. Define comportamientos predeterminados para los métodos comunes a todos los objetos.

Clase OutOfMemoryError:

Error que señala la falta de memoria. Típico error que en los ejemplos y manuales no se utiliza pero que en la vida real se debe de usar para controlar la falta de memoria en la ejecución de programas.

Clase String, StringBuffer, Thread :

Estas clases ya las hemos repasamos en capítulos anteriores, indicar que pertenecen a este paquete.

Clase System:

Se utiliza para manipular algunas funciones relacionadas con el sistema operativo. En particular define los principales flujos de entrada, salida y error.

Paquete java.util:

Este paquete define clases de utilidad. Se agrupan en las familias siguientes:

• clases estructuras de datos: Hashtable, Vector, Enumeration.
• clases de gestión de fechas.
• gestión de internacionalización.
• gestión de eventos, etc.

Clase Calendar:

Clase abstracta que permite la conversión entre un objeto Date y valores enteros de tipo Día, Mes, Año, etc. Permite también efectuar operaciones aritméticas sobre las fechas. Esta clase define constantes que representan los meses, los días, y ciertos métodos de cálculo.

public static final int ERA=0
public static final int YEAR=1
public static final int MONTH=2
public static final int SUNDAY=1
public static final int MONDAY=2
.......
public static final int JUNARY=0
public static final int FEBRUARY=1
.......
public static sysnchronized Calendar getinstance()
public static sysnchronized Calendar getinstance(TimeZone, zone)
......
public int getFirstDaysinFirstWeek()
public final Date getTime()
protected void setTimeinMillis(long)
public final void set(int year, int month, int date)

Clase Hashtable:

define una estructura de datos tipo matriz con claves hashing. Asocia un valor con una clave permitiendo recuperar el valor muy rápidamente. Se utiliza cuando se quiera almacenar valores con un índice no numérico.

Clase Properties:

extensión de la clase anterior que permite leer y escribir en un flujo una lista de pares clave-valor:

// constructores
public Properties()
public Properties(Properties defecto)
// métodos
public String getProperty(String key)
public void list(PrintSttream out)
public Enumeration propertyNames()

Clase Random:

devuelve números pseudoaleatorios.

Clase Timezone:

Representa un uso horario, se utiliza con Calendar y devuelve el uso dado por el sistema.

Clase Vector:

Define una estructura de datos tipo vector(matriz dinámica).

Paquete Java.io:

Contiene todas las clases relativas a las entradas y salidas. Contine:

• Un conjunto de clases para gestionar los flujos de bytes.
• Un conjunto de clases para gestionar los flujos de caracteres.
• Un conjunto de clases para los accesos a los archivos.

Muchas de las clases aquí mencionadas las hemos visto en los últimos capítulos de este articulo:

Clase File:

define un conjunto de atributos estáticos dependientes del sistema.

Clase InputStream:

clase abtracta que es el prototipo de todos los objetos que manipulan un flujo de entrada.

Clase FileInputStream:

esta clase es un InputStream asociada a un archivo.

Clase FileNotFoundException:

esta excepcion se activa automáticamente cuando se intenta crear un objeto que referencia a un archivo que no existe.

Clase OutputStream:

clase abstracta que es el prototipo de todos los objetos que manipulan un flujo de salida.

Clase FileOutputStream:

flujo de salida asociado a un archivo.

Clase PipedInputStream:

esta clase permite conectar un flujo de entrada a un flujo de salida.

Clase RandomAccesFile:

propone un interfaz de lectura y escritura a un archivo.

Paquete Java.net:

Este paquete proporciona los mecanismos de trabajo en red. Java admite los protocolos TCP y UDP. Las clases que se utilizan mas frecuentemente son:

• La clase URL, que representa un URL de Internet.
• La clase Socket y ServerSocket que permiten establecer conexiones TCP/IP según la interfaz Socket.
• DatagramaPacket y DatagramaServer, para establecer conexiones UDP.
• InetAdress que representa un dirección ICP/IP.

Clase ContenHandler:

clase abstracta que es el prototipo de clases especializadas en la interpretación del contenido de un flujo, un caso tipo es el del protocolo HTTP.

Clase HttpUrlConnection:

esta clase está especializada en la gestión de protocolos HTTP. Es utilizada automáticamente por un objeto URL cuando se habré una conexión.

Clase InetAddress:

encapsula las diferentes formas de vincular direcciones Internet a un nombre de anfitrión, por lo tanto encpsula tanto los direcciones IP numéricas como el nombre de domino de esas direcciones.

public String getHostName()
public byte[] getAddress()

Clase ServerSocket:

posee la capacidad de escucha de un puerto TCP. Se trata de un elemento fundamental en el diseño de un servidor.

//constructores
public ServerSocket(int puerto)
public ServerSocket(in puerto, int ba)
//métodos
public Socket accept()
public void close()
public InetAdress getInetAdress()

Clase URL:

permite definir un modo de representación uniforme para el nombrado de objetos.

Paquete Java.applet:

Es paquete aporta las funcionalidades para crear y gestionar los applets.

Clase Applet:

para crear su propia applet tendrá que derivar esta clase y especificar los métodos siguientes:

getAppletInfo:

devuelve información sobre el applet.

getParameterInfo:

idem pero de los parámetros del applet.

Init:

llamada al inicio del applet.

Start:

llamada para lanzar el applet.

Stop:

llamada para parar al applet.

Destroy:

llamada para liberar los recursos ocupados por el applet.

No se preocupe, los dos siguientes artículos los dedicaremos por completo a este paquete.

Paquete Java.awt:

Este paquete engloba toda la interfaz gráfica. Es el que más a crecido y más rápidamente evoluciona y cambia. Tiene innumerables clases y métodos, intentaremos ver los más representativos:

Clase BorderLayout:

Es el gestor de organización con limites.

Clase Button:

crea un botón de control.

Clase Canvas:

crea una ventana sin una semántica asociada.

Clase CardLayout:

gestor de organización con tarjetas.

Clase Chekbox:

cuadro de comprobación.

Clase Choise:

crea una lista emergente.

Clase Color:

gestiona los colores.

Clase Dialog:

crea una ventana de diálogo.

Clase Event:

encapsula eventos.

Clase FileDialog:

crea ventanas para seleccionar archivos.

Clase FlowLayout:

gestor de organización lineal.

Clase Font:

encapsula un tipo de letra.

Clase Frame:

crea una ventana estándar.

Clase Graphics:

encapsula el entorno gráfico.

Clase Image:

encapsula imágenes gráficas.

Clase Label:

crea una etiqueta.

Clase List:

crea una lista donde el usuario puede elegir un elemento.

Clase Menu:

crea un menú desplegable.

Clase MenuBar:

crea una barra de menú.

Clase MenuItem:

crea un elemento de un menú.

Clase Polygony:

encapsula un polígono.

Clase Rectangle:

ídem rectángulo.

Clase Scrollbar:

crea una barra de desplazamiento.

Clase Textarea:

crea un control para un área de texto.

Clase Window:

crea una ventana sin marco, si menú, ni título.

Habrá observado que en estos capítulos y en estas paginas HTML no se ha encontrado nada en movimiento, es decir ningún Applet que distrajese nuestra vista. No soy muy partidario de ello pero como aperitivo a los capítulos siguientes que estarán dedicados a los paquetes gráficos y los applets incluiré aquí éste que me pareció muy interesante y está basado en el juego incluido en las librerías gráficas de Linux (y UNIX) y la idea viene del manual: Tutorial de Java. Manual en castellano en formato HTML obtenido de la dirección www.fie.us.es/info/internet/JAVA. Agustín Froufe.

He cambiado algunas cosas en el fuente para adaptarlo a mi forma de ser (Los Ojos más redondos y con un poco de estrabismo). El fuente va incluido con el artículo. (para activarlo hay que pasar el puntero del ratón por la imagen).
 

Conclusiones:

Referencias:

• JAVA manual de referencia. Patrick Naughton Herbert Schildt. Mcgraw-Hill.
• Programando con JAVA. Tim Ritchey. Prentice Hall.
• Tutorial de Java. Manual en castellano en formato HTML obtenido de la dirección www.fie.us.es/info/internet/JAVA. Agustín Froufe.
• The Java Tutorial. Manual en ingles en formato HTML obtenido en la dirección www.javasoft.com. Sun.
• Tutoriales de la propia instalación del JDK.
• Java cliente-servidor.Cédric Nicolas, Chistophe Avare y Frederic Najman. Gestión 2000.
• De esta misma serie: Java. Parte I y Java. Parte II