Curso de Java

C.C. El Recreo, Torre Sur, Piso 7, Oficina 7

Caracas – Venezuela

Teléfonos: +58 212 7612523 – 7628438

Website: http://www.benllisoft.com/

Email: cursos@benllisoft.com

Fecha: 27/03/2010

Autores:

Ing. Raymond Garcia

Lic. Jose Andrade

Entender los conceptos de orientado a objetos con el

lenguaje de programación Java.

Tabla de contenido Introducción .................................................................................................... 1

Programación Orientada a Objetos ................................................................... 1

Objeto, Clase, mensajes y Métodos .................................................................... 1

Objeto y clase ............................................................................................... 1

Mensajes y métodos ...................................................................................... 1

Componentes de un mensaje ....................................................................... 2

Métodos .................................................................................................... 2

Crear Objetos ............................................................................................... 2

Ejemplo práctico con contadores ................................................................... 2

Tour por java ................................................................................................... 3

Tipos primitivos ............................................................................................. 3

Definición de Objetos ..................................................................................... 3

Definición de variable .................................................................................. 4

Definición de métodos ................................................................................. 4

Instanciar objetos .......................................................................................... 5

Acceso a métodos y variables......................................................................... 5

Visibilidad e independencia de los atributos ...................................................... 5

Sobrecarga ................................................................................................... 6

Inicialización y constructores .......................................................................... 6

Expresiones, sentencias y mecanismos de control .............................................. 7

Operadores ................................................................................................ 7

Sentencias de control de flujo ...................................................................... 9

Clasificación, Generalización y especialización ................................................... 13

Variables dentro de una clase ..................................................................... 13

Los métodos en java, métodos de una clase ................................................. 13

Creando una clase y objetos ......................................................................... 14

Herencia ....................................................................................................... 16

Entendiendo la herencia ............................................................................... 16

Herencia se Usa o se Abusa de esta característica ......................................... 16

Ventaja de la Herencia .............................................................................. 16

Herencia en Java ......................................................................................... 17

Interfaces ................................................................................................... 17

Polimorfismo .................................................................................................. 17

Ventaja del Polimorfismo .............................................................................. 18

Modularidad ................................................................................................... 20

Herencia múltiple ........................................................................................... 23

Manejo de Excepciones ................................................................................... 23

Operaciones con Entrada y salida de Datos ........................................................ 25

Genéricos y Framework Collection .................................................................... 27

Interfaz Gráfica y Windows .............................................................................. 28

Creación de ejecutables .................................................................................. 32

Benllisoft

1 Curso de Java

Introducción

La programación orientada a objetos ha estado en práctica por varios años, los fundamentos de

orientado a objetos fueron introducidos en 1960 por medio lenguaje simula, estos fueron aceptados con

el leguaje smalltak80.

Hoy en día muchos utilizan este procedimiento para programar, ¿pero que es en si la programación

orientada a objetos?, que la hace diferente de la programación tradicional y por consiguiente atractiva.

Programación Orientada a Objetos

El enfoque procedimiento de programación fue el enfoque de facto en los primeros días de

programación. Aquí, el código es modular basado en los procesos de un sistema. La resolución de

problemas que implican el análisis de estos procesos en términos de las tareas de procedimiento

realizado y la producción de un sistema cuya representación se basa en el flujo de procedimiento de los

procesos.

Programación orientada a objetos, por el contrario, se modelan objetos y sus interacciones en el espacio

del problema y la producción de un sistema basado en estos objetos y sus interacciones.

Dado que el mundo real el dominio de un problema se caracteriza por los objetos y sus interacciones,

una aplicación de software desarrollado con la programación orientada a objetos conseguirá en un

sistema producción informático una representación más cercana del dominio del problema del mundo

real de lo que sería el caso si el enfoque de programación se utilizado es el procedimental

Objeto, Clase, mensajes y Métodos

Objeto y clase

Una clase es una plantilla que define la estructura y la creación de objetos con los mismos atributos y

métodos de la clase.

Una diferencia importante entre los objetos y la clase está en la forma como se tratan a los atributos

métodos de los objetos y clases. Una clase es una definición acerca de los objetos, el los atributos y los

métodos en una clase son declaraciones que no contienen valores. Sin embargo, los objetos son

instancias creadas de una clase. Cada uno tiene sus propios atributos y métodos. Los valores del

conjunto de atributos describen el estado de los objetos.

Tenga en cuenta que la definición de la clase Vendedor es diferente de la del cliente clase ya que los

clientes y vendedores se comportan de manera diferente, los clientes realizar pedidos y vendedores de

recibir órdenes.

Mensajes y métodos

Los objetos se comunican entre sí por el envío de mensajes. Un mensaje es una llamada a método de

un objeto. Es decir que existe un objeto que recibe un mensaje y objetos que envía el mensaje.

Un objeto responde a un mensaje mediante la ejecución de uno de sus métodos. Se puede colocar

adicional información, conocido como argumentos, que puede acompañar a una llamada al método. Esta

parametrización permite una mayor flexibilidad en el paso de mensajes. El conjunto de métodos

colectivamente define el comportamiento dinámico de un objeto. Un objeto puede tener tantos métodos

según sea necesario.

Benllisoft

2 Curso de Java

Componentes de un mensaje

Un identificador de objeto que indica el receptor del mensaje, nombre de un método, y argumentos.

Métodos

Un mensaje es válido si el receptor tiene un método que se corresponde con el nombre del método en

el mensaje y los argumentos adecuados, en su caso, se suministran con el mensaje. Sólo los mensajes

válidos son ejecutados por el receptor.

Crear Objetos

En la programación orientada a objetos, los objetos son creados a partir de las clases, cada objeto tiene

su propio estado. Para ilustrar se utiliza el ejemplo con contadores.

Ejemplo práctico con contadores

A pesar que cada contador tiene la misma definición de atributos y métodos, los valores de atributos no

lo son. Esto sugiere que el estado de objeto varía con respecto a los otros

Benllisoft

3 Curso de Java

Tour por java

El lenguaje de programación Java permite la creación de objetos que en última instancia, participar en la

comunicación de mensajes. Hemos visto que los objetos pueden tener diferente comportamiento y que

es más conveniente para especificar los objetos a través de la clasificación, es decir, clase de

construcciones.

Antes de examinar las definiciones de clase especificados por el usuario, Java también proporciona los

valores primitivos.

Tipos primitivos

Tipo primitivo Bit Rango rango

byte 8 -128 127

short 16 –32768 32767

int 32 –2147483648 2147483647

long 64 –9223372036854775808 922337203685477580

float 32

double 64

char

boolean true false

Definición de Objetos

Sobre la base de los valores primitivos con el apoyo del lenguaje apropiado, otras entidades a ser

manipulados por el usuario son el diseñado de objeto que se definen a través de construcciones de

clase. La construcción de clase en Java se compone de la palabra clave class seguida del nombre de la

clase y llaves {}, que delimitan la declaración de los atributos y los métodos de sus instancias. La clase

contra el introducido en el capítulo 2 tendría el siguiente formulario en Java:

Los Atributos de los objetos pueden ser objetos anidado o tipos primitivos utilizados para representar el

objeto. Un método manipula el objeto alterando los valores del atributo. El atributos numero y método

add() en la clase Contador que se muestran a continuación son representativos de estado de un objeto

y operación:

Benllisoft

4 Curso de Java

El atributo numero es también conocida como una variable de instancia ya que se produce en cada

objeto o instancia de la clase Contador. Esto implica, además, que un atributo es independiente de que

en otra instancia. En el mismo sentido, un método manipula los atributos de los objetos en la misma

instancia. Esto ocurre cuando un método es invocado y el código correspondiente en su cuerpo se

ejecuta.

En nuestro ejemplo reciente, invocando el método add () de un objeto se incrementará el número

correspondiente atributo.

Definición de variable

Definición de las variables en Java tomar el siguiente formato, donde el nombre del tipo T precede a la V

Nombre de variable:

T v

Todas las variables tienen que ser definidas en Java, lo que permite al compilador verificar durante la

compilación que las operaciones en el objeto asociado a la variable son legítimas.

Definición de métodos

Una definición de método se compone de dos partes diferenciadas: el

encabezado o nombre del método y su cuerpo rodeado de código de

implementación las llaves {..}

Los métodos pueden tener una forma genérica como la que se

muestra T m(R1 p1, R2 p2, ... Rn pn) donde T es el tipo de dato a

retornar m es en nombre del método y Rn y pn el tipo y nombre del

parámetro.

Los parámetros se definen de manera normal como

La implementación de un método consiste en un conjunto de

sentencias rodeadas por {}, por lo regular dicho métodos modifican

el estado de un objeto, en el caso del ejemplo de la clase contador el método add incrementa el valor de

la variable numero.

Un bloque consiste en un conjunto de declaración de variables, expresiones o estructuras de control.

Una versión expandida de la clase contador es la siguiente se ha agregado un nuevo método que

inicializa la variable numero a 0, adicional de una variable que cuanta las veces que se ha inicializado.

Benllisoft

5 Curso de Java

Instanciar objetos

Una clase proporciona una descripción de los objetos de esa clase, y sirve como un plantilla para los

objetos que se creen. Para crear un objeto se utiliza la llamada a la palabra reservada new. La expresión

“new Contador ()” devuelve una instancia recién creada de la clase Contador. Sin embargo, para que

este nuevo objeto usador, se le asigna a una variable adecuada.

De esta forma se pueden crear diferentes objetos con una misma clase

Acceso a métodos y variables

Dado que los atributos y los métodos de un objeto se consideran sus características, estos se accede a

través del operador "." con respecto a un objeto propio.

De la misma forma se puede hacer la llamada a los métodos

Visibilidad e independencia de los atributos

Acceder a atributos de los objetos directamente es admisible, pero

no es ideal, ya que cualquier cambio en la representación del objeto

se propaga a código que es dependiente, lo que resulta en alta costo

de mantenimiento de software.

Una práctica común de programación orientada a objetos es ocultar

la información a hacer representaciones de objetos (atributos y

métodos) inaccesibles a los clientes para que las modificaciones en

un (servidor) representaciones de objeto no se propagan demasiado.

Esta disociación o desacoplamiento de las dependencias reduce el

costo de mantenimiento de software.

Limitar el acceso a atributos de objetos en Java se logra

principalmente por los dos especificadores limitación public y private.

Mientas que la acceso de los atributos ahora es privado el acceso de estos ya no es posible para estos

casos es necesario hacer métodos de acceso como y

, estos métodos proveen acceso a los detalles internos de una clase.

Benllisoft

6 Curso de Java

Sobrecarga

En java la construcción métodos que están en un clase, pueden compartir el mismo nombre siempre y

cuando se distingan por:

1. El numero de parámetros.

2. Diferencia entre el tipo de parámetros.

Este criterio hace que se pueda hacer coincidencia entre métodos

que comparten un mismo nombre, ejemplo se quiere agregar a la

clase contador un nuevo método que incremente con un número

distinto de uno

Inicialización y constructores

Construcción e inicialización se ven como dos operaciones separadas,

actualmente la programación OO provee un mecanismo para unir

estas dos operaciones, se usan los constructores es un método que se

invoca cuando se está instanciando un objeto.

Características:

1. tiene el mismo nombre de la clase

2. no tiene tipo de retorno

los constructores proveen flexibilidad, al igual que los métodos estos pueden ser sobrecargados

Benllisoft

7 Curso de Java

Expresiones, sentencias y mecanismos de control

Una de las operaciones que es muy común en la programación es la asignación

v = E;

La asignación se compone de una variable a la izquierda que contiene o "mantiene" la valor especificado

a través de la expresión de la derecha. Puede ser un valor literal, como 3, una variable que contiene el

valor deseado, como el número, o un operador con los correspondientes operandores.

Operadores

Los operadores aritméticos

Java incluyen la suma, resta, división, multiplicación y resto

Cuando se divide entre variables del mismo tipo el resultado obtenido será del tipo usado, mientras si se

usan variables de distintos tipo el resultado arrojado será del tipo de variable más alto.

Benllisoft

8 Curso de Java

Operadores lógicos

Los operadores lógicos en java incluye en && , || y ¡

&& devuelve verdadero si ambos son verdaderos

X Y X && Y

True True True

True False False

False True False

false False False

|| devuelve verdadero si por lo menos uno es verdadero

X Y X || Y

True True True

True False True

False True True

false False False

¡ delvuelve verdadero si el operador es falso

X ¡X

True False

False True

Operadores relacionales

Los operadores de igualdad “==” y desigualdad “!=” operan sobre todos los objetos y variables y

retornan un resultado booleano

Los siguientes operadores se aplican solo a tipos de datos numéricos

< Menor

> Mayor

<= Menor que

>= Mayor que

Benllisoft

9 Curso de Java

Sentencias de control de flujo

Aparte de las declaraciones simples, hay declaraciones de flujo de control que afectan a la ejecución de

órdenes de los estados. Estas declaraciones se agrupan generalmente bajo condicional y las estructuras

iterativas.

Condicional

Las sentencias condicionales permiten evaluar una condición, su estructura es la siguiente

La sentencia S solo será ejecuta si la expresión E es verdadera, una ligera variación de este tipo de

sentencia es el sino

La sentencia S solo será ejecuta si la expresión E es verdadera sino se ejecuta R. aparte de la condición

simple y la condición sino existe el switch que permite la selección múltiple

Benllisoft

10 Curso de Java

Sentencias iterativas

Algunas veces es necesario que una pieza de nuestro código se corra más de una vez, además de los

condicionales el lenguaje de programación java provee ciclos.

Los ciclos al igual que los condicionales poseen una expresión que se tiene que evaluar.

Esta condición puede ser verdadera o falsa. El programa va ejecutar las sentencias mientras la condición

sea verdadera

La diferencia principal en la cantidad de veces que se ha de ejecutar el cuerpo del ciclo, los if

ejecutan su cuerpo una solo vez, mientras que los ciclos lo han de ejecutar mientras la

condición que se está evaluando sea verdadera.

En esta versión del juego de adivinanza

se ha modificado de tal manera que se

repita hasta que el usuario adivine el

número.

Benllisoft

11 Curso de Java

Sentencia Do… while

La sentencia do … while es similar a While, en el while el programa verifica que la condición sea cierta si

esta es falsa el cuerpo del while nunca se ejecuta.

En el do… while una vez ejecutada en cuerpo de do..while se verifica que la condición sea cierta.

Scanner sc=new Scanner(System.in); Int Numero=0; Boolean adivinaste=false;

Do

{ System.out.println(“Adivine un numero”); Numero=sc.nextInt(); If(Numero==4) {

System.out.println(“Correcto!”); Adivinaste=true; } Else { System.out.println(“Intente de nuevo”); }

}while(adivinaste==true)

Benllisoft

12 Curso de Java

Sentencia FOR

La sentencia FOR provee una manera compacta de poder iterar sobre un conjunto de valores.

En java la sintaxis es la siguiente

Consideraciones:

1. La parte de inicialización es ejecutada una vez.

2. Cuando la parte de terminación sea falsa el ciclo se termina. 3. La parte de incremento se ejecuta después de finalizado un ciclo, se acepta de igual

forma el decremento.

Ejemplo

Error de sintaxis: usar comas en vez de punto y comas.

En algunos casos el for puede ser representado por un while

Benllisoft

13 Curso de Java

Clasificación, Generalización y especialización

Una clase es una plantilla que se usa para la creación de objetos. Cuando se crea una clase se describe

como la JVM debe hacer para crear un objeto de tipo de la clase.

Una clase no es un objeto pero a partir de una clase se puede construir muchos objetos.

Variables dentro de una clase

Las variables que están dentro de una clase pero no están dentro de un método se conocen como

variables de instancias.

Los métodos en java, métodos de una clase

En el argot de la programación estructurada se conocen como procedimientos o funciones, en el mundo

OO se conocen como métodos. Y un método son las cosas que una clase en particular puede ejecutar

Como se puede esperar de un lenguaje de programación se puede pasar valores por medios de los

métodos.

Benllisoft

14 Curso de Java

Creando una clase y objetos

Lo primero que vamos hacer es modelar una clase perro, crear una plantilla para crear objetos de tipo

perro. Primero identificamos sus atributos y algunas de las acciones que un perro debe realizar.

Las variables raza, nombre y tamaño dentro de la clase Perro se conocen como variables de instancias,

y se conocen con ese nombre ya que son variables que se harán únicas para cada perro que se cree.

Dentro de la clase main vamos crear dos perros a partir de

la clase Perro, un perro es spark y otro Fido, ambos objetos

son creados y le son asignados valores a sus propias

variables de instancia tamaño.

Cada variable es única para cada perro y no se comparten,

el tamaño de spark es 40 y el tamaño de Fido es 10.

Ambos perros usan el método ladrar pero

al igual que las variables son métodos

que manejan cada perro.

Ahora modifiquemos el comportamiento

basado en el estado del perro y volvamos

a ejecutar el código.

Benllisoft

15 Curso de Java

Un poco más allá ahora haremos nuestra propia jauría

de perros.

Por ahora se está asignando el valor directamente por

el operador punto.

Mejorando el diseño OO. La regla fundamental en

marcas las variables de instancias como privadas y

proveer métodos de acceso para las mismas estos

métodos son conocidos como getter y setter.

Benllisoft

16 Curso de Java

Herencia

Entendiendo la herencia

Cuando se diseña con herencia se coloca código que es común en una clase, la clase que tiene el código

en común se conoce como superclase o clase padre.

En el argot de java se dice que cuando una clase hereda de otra clase entonces la clase que hereda es la

subclase, y se dice que la subclase extiende de la superclase.

En si la herencia significa que la subclase obtiene todo aquello, que se pueda, de la superclase.

En el diseño de OO no podemos ir por el mundo heredando cosas por el simple hecho de reutilizar el

código, entonces la pregunta que surge es cuando heredar.

Para saber si una subclase puede heredar es necesario hacer la prueba de ES-UN. Esta funciona en un

solo sentido

Por ejemplo un triangulo es una figura, aquí funciona

Un gato es un felino.

Un perro es un canino.

Un estudiante es una persona

Todos los ejemplos de arriba funcionan y son razonables, es bueno pensar que entre ellos puede existir

una relación de herencia.

Una silla hereda de una casa perece razonable, si aplicamos la prueba de es un

Una silla es un casa ó un Casa es una silla

De ninguna de las dos formas es razonable por tanto no se puede aplicar la herencia entre estas dos

entidades, entre ellas si existe una relación pero no es una relación de ES-UN, Una casa tiene Sillas, en

este caso la casa tiene una referencia a las sillas lo cual suena razonable.

Si el diseño de una familia de herencia está bien diseñado entonces todo el árbol tendrá lógica.

Si la clase B hereda de la clase A entonces la Clase B es una clase A.

Más aun si la clase C hereda de la clase B entonces la Clase C es una Clase A.

Herencia se Usa o se Abusa de esta característica

He aquí unas pequeñas reglas que se pueden aplicar para evitar su abuso

1. Hacer herencia cuando una clase sea más específica que otra. 2. Hacer Herencia cuando el comportamiento debe ser compartido entre múltiples clases. 3. No hacer herencia cuando no se pase la prueba de ES-UN.

Ventaja de la Herencia

1. Evitar Duplicar el código. Solo modifico el código común a las clases 2. Defines un protocolo común entre un grupo de clases

La segunda ventaja de la herencia te garantiza que todas las clases que están bajo una superclase

comparten un conjunto de métodos en común que son lo que tiene la superclase.

Benllisoft

17 Curso de Java

Con esto estás diciendo todas mis subclases pueden hacer estas cosas por medio de estos métodos que

has heredado.

¿Y para que me ayuda eso?

Sacamos ventaja del polimorfismo

¿Y eso con que se come?

Podemos hacer referencia a las subclases por medio de la superclase.

Herencia en Java

En Java la herencia solo existe herencia de un nivel, es decir, una clase hija solo puede heredar de una

sola clase padre.

public class Padre {

int valorX; }

public class Hijo extends Padre {

int valorY; }

En el ejemplo anterior la clase Hijo esta heredando todas las características de la clase Padre, por lo que

también tendrá una variable llamada valorX.

Algo que Java no permite directamente es la herencia múltiple, esto es, que una clase especifica herede

desde dos o más clases Padres. Para poder simular esto podemos crear una interfaz que simulara ser las

otras clases padres.

Interfaces

Una interfaz es una clase Java que no tiene métodos implementados, ya que su implementación será

definida por una segunda clase la cual usara esta interfaz

Polimorfismo

Para entender como el polimorfismo trabaja es necesario entender la manera tradicional de declarar una

referencia y crear un objeto.

1. Creamos la variable de referencia que es p de tipo Perro 2. Creamos nuestro Objeto Perro con el operador NEW. 3. Asignamos nuestro objeto al variable de referencia mediante el operador de =

Lo importante aquí es que la referencia y el objeto son del mismo tipo Perro

Con polimorfismo la referencia y el objeto pueden

ser diferentes

Benllisoft

18 Curso de Java

Con polimorfismo la variable de referencia puede ser la superclase, se puede hacer polimorfismo cuando

existe una relación ó herencia entre una subclase y su superclase.

De tal manera a una subclase extender de una superclase la subclase puede ser asignada a la variable

de referencia de la superclase.

Aun no queda aquí, un método puede tener Argumentos que se basen en Polimorfismo o puede devolver

referencias a objetos que se basen en polimorfismo.

Veamos un Ejemplo Guiado:

Digamos que queremos hacer que un veterinario se encargue de inyectar a los diferentes animales que

hemos creado, primero vamos a crear a un veterinario

Ahora vamos hacer una clase Main donde creemos algunos Animales y se los dejamos al veterinario

El parámetro animal puede tomar cualquier tipo de animal en el argumento y ya que todos comparten

el mismo protocolo o los mismos métodos gracias a la clase padre cuando el veterinario va a pinchar

dentro del método le decimos al animal que haga un ruido y él lo hará.

Ventaja del Polimorfismo

Al usar polimorfismo en nuestro lógica de negocios y usar argumentos que se basen en polimorfismos

estamos haciendo nuestro código lo suficientemente genérico, nuestra lógica de negocios no se verá

afectada no se vea afectada y de esa manera podemos crear subclases y agregarlas a nuestra lógica.

Benllisoft

19 Curso de Java

Recordemos al veterinario si creamos una nueva clase Ballena el veterinario puede manejar la nueva

clase. Lo único que debemos estar pendientes es que ballena sea un animal.

Benllisoft

20 Curso de Java

Modularidad

Que tienen en común un perro, un gato, un tigre, un león, un pato y un hipopótamo?

Todos ellos son animales

Al hacer nuestro diseño debemos pensar en las características comunes que compartirán todos estos

animales comencemos con las variables de instancia. Se usara notación UML simplificada.

Se han declarado 5 variables de instancias

Foto: representará la foto del animal.

Comida: el tipo de comida que el animal puede comer {carne, matas}

Hambre: la cantidad de hambre que tiene el animal.

Espacio: representa un espacio bidimensional (640 * 480) donde el animal se

desplazara

Localización: coordenadas X y Y donde el animal se encuentra actualmente.

Benllisoft

21 Curso de Java

Todos las animales tendrán 4 métodos cada uno hará su propio ruido, comerá una comida distinta,

dormirá y podrá desplazarse.

A partir de este momento creamos las subclases a partir de la súper clase, el diagrama quedará como

el siguiente.

Dado que cada animal puede tener un comportamiento distinto en el caso de comer y hacer ruido se

sobrescribirán esos métodos.

Creamos la súper clase le ponemos

abstracto dado que no queremos se

creen objetos tipo Animal y

declaramos el método hacerRuido y

Comer como abstractos de esa forma

obligamos a que las subclases a

implementar dichos métodos.

Benllisoft

22 Curso de Java

Creando las subclases

Pero antes de seguir en nuestro diseño, podemos mejorar buscando otras oportunidades de

herencia.

Benllisoft

23 Curso de Java

Herencia múltiple

En ciertos casos una clase debe heredar de dos clases padres diferentes pero lamentablemente

Java no permite heredar 2 clases directamente. Para solventar este problema podemos utilizar

interfaces para simular la herencia múltiple. Cuando vamos a definir que una clase hereda de 2 o más

clases se indica que una de ellas se hereda directamente y el resto de ellas se implementan con

interfaces.

Class Hijo extends PadreA implements PadreB, PadreC { @Override Public void metodoImplementado() {

}

}

La única desventaja que existe de esta implementación es que se deben redefinir los cuerpos de

todos los métodos que son heredados por las interfaces.

Manejo de Excepciones

Una excepción es un evento que se realizo de forma incorrecta al momento de ejecutar una

aplicación Java. Estos eventos pueden ser almacenados en una variable de tipo Exception y en ella

estará toda la información referente a ese evento en particular.

El manejo de excepciones se realiza con el fin de manejar posibles errores o problemas en

nuestro programa al momento de ejecución. Este sistema por tres bloques:

try

{ //En este bloque colocaremos el código que posiblemente nos genere un error o una excepción. } catch(Exception e) {

//Luego en caso de que ocurra un erros aquí haremos su correspondiente tratamiento, es posible tener varios bloques catch para diversos tipos de errores } Finally { //Haya ocurrido o no una excepción siempre se ejecutara este bloque, muy útil cuando hay que hacer manejos de datos finales o cerrar archivos.

}

La excepción queda guardada en el objeto que declaramos en el catch, luego si queremos ver qué tipo

de excepción o mostrar por consola su contenido podemos usar el método e. printStackTrace ();

Los tipos de excepciones más comunes son:

IOException: problemas con archivos

IndexOutOfBoundsException: Error al sobrepasar los límites de un arreglo

NumberFormatException: error con el formato de un numero

Benllisoft

24 Curso de Java

Una utilidad de saber manejar las excepciones es que a futuro podemos crear nuestras propias

excepciones. La ventaja de esto es que las podemos utilizar para controlar eventos que son definidos

por nuestra lógica. Si queremos crear nuevas excepciones podemos hacerlo con el siguiente código:

class NuevaExp extends Exception

{ String mensaje; public NuevaExp(String causa) { mensaje=causa; } public String getMessage()

{ return mensaje; }

}

Luego de esto, si queremos invocar a nuestra nueva excepción lo podemos hacer con la palabra

reservada throw: throw new NuevaExp(“sin motivo”);

Benllisoft

25 Curso de Java

Operaciones con Entrada y salida de Datos

El manejo de archivos en Java se hace a partir de 2 pasos, el primero es abrir el archivo y con esto

“almacenarlo” en un objeto que manejara todo lo relacionado a él, y el segundo paso es crear un Buffer

o canal de comunicaciones para poder extraer los datos correctamente

Paso 1 Paso 2

Archivos Secuenciales

FileReader fr=new FileReader(“arch.txt”) Scanner sc=new Scanner(fr);

FileWriter fw=new FileWriter(“arch.txt”,boolean agregar)

BufferedWriter bw=new BufferedWriter(fw);

Archivos de objetos

FileInputStream fi=new FileInputStream(“arch.txt”);

ObjectInputStream ois=new ObjectInputStream(fi);

FileOutputStream fo=new

FileOutputStream(“arch.txt”, boolean

agregar);

ObjectOutputStream oos=new

ObjectOutputStream(fo);

Luego de esto procedemos a leer el archivo, dependiendo si es un archivo secuencial u orientado a

objetos tendremos diversos métodos para la lectura y escritura:

Secuencial

Metodos del Scanner Bw.write(String cadena);

Orientado a Objetos

(tipo del objeto)ois.readObject(); Oos.writeObject(obj);

Ejemplo de lectura-escritura secuencial:

FileReader fr=new FileReader(“arch.txt”); Scanner sc=new Scanner(fr);

System.out.println(“Lei del archivo”+sc.nextLine()); fr.close(); FileWriter fw=new FileWriter(“arch.txt”);

BufferedWriter bw=new BufferedWriter(fw); bw.write(“Esto es un ejemplo”); bw.newLine(); bw.write(“Agregue un espacio y continue”); bw.close();

Dependiendo del sistema operativo que utilicemos, la separación de líneas será distinta. Para evitar

problemas, la clase BufferedWriter tiene un método llamado newLine() que agrega un separador de

líneas acorde al sistema con el que se esté trabajando.

Ejemplo de lectura-escritura orientada a objetos:

FileInputStream fi=new FileInputStream(“arch.txt”); ObjectInputStream ois=new ObjectInputStream(fi); System.out.println(“Lei del archivo”+(String)ois.readObject()); fi.close(); FileOutputStream fo=new FileOutputStream(“arch.txt”);

ObjectOutputStream oos=new ObjectOutputStream(fo); String objeto=”Soy un ejemplo”; oos.writeObject(objeto); oos.close();

Benllisoft

26 Curso de Java

Luego de conocer como es el funcionamiento de las clases operadoras de archivos, necesitamos una

manera de que el usuario pueda seleccionar dinámicamente un archivo. La clase FileDialog me permite

mostrar una ventana para seleccionar un archivo tanto para lectura como escritura.

FileDialog fdVentana=new FileDialog(this,"Titulo de la Ventana",modo);

En la línea anterior creamos una instancia de ventana de selección en el objecto fdVentana. En la

variable modo puede contener los valores “FileDialog.LOAD” o “FileDialog.SAVE” según queramos que la

ventana maneje el abrir o guardar archivos respectivamente.

Luego invocamos a esta ventana con el comando fdVentana.setVisible(true). Al cerrar la ventana,

podemos saber si el usuario tomo una decisión valida utilizando el método fdVentana.isValid(), y en caso

afirmativo, podemos utilizar los métodos fdVentana.getDirectory() y fdVentana.getFile() para conocer al

ruta y el archivo seleccionado.

if(cuadroAbrir.isValid()) {

try { FileInputStream f=new FileInputStream(cuadroAbrir.getDirectory() + cuadroAbrir.getFile()); Scanner sc=new Scanner(f);

} Catch(Exception e)

{ }

}

Ademas de esto podemos pre-definirle el tipo de archivo a buscar utilizando el método

fdVentana.setFile(“*.txt”) para buscar solo archivos de texto y podemos pre-definirle la carpeta por

defecto utilizando el método fdVentana.setDirectory(“c:\”);

Benllisoft

27 Curso de Java

Genéricos y Framework Collection

Las colecciones son conjuntos de elementos muy parecidos a los arreglos con la diferencia que su

cantidad puede ser variable y se adaptan al momento a nuevas capacidades

ArrayList y Vector son dos clases que permiten el almacenamiento de información dinámicamente, las

diferencias entre estas dos son mínimas (almacenamiento e hilos) y por eso podemos escoger

indistintamente cualquiera de las dos al momento de almacenar información.

Los métodos más comunes de estas dos clases son:

Add() Agrega elementos al contenedor

Clear() Limpia por completo el contenedor

Contains(Object o) Devuelve TRUE si „o‟ existe en el contenedor

Remove(int index) Elimina el elemento en la posición index

Get(int index) Devuelve el elemento que está en la posición index

isEmpty() Devuelve TRUE si el contenedor esta vacio

Size() Devuelve la cantidad de elementos que están en el contenedor

Stack

El Stack o Pila es una estructura de datos que permite colocar objetos unos sobre otros con la condición

que para eliminar objetos debe ser desde el ultimo hasta el primero. Los métodos de esta clase son:

Push(Objecto o) Apila el objeto en la pila

Pop() Desapila el ultimo objeto

Peek() Devuelve el objeto que está en el tope de la pila

isEmpty() Devuelve TRUE si al pila esta vacia

Benllisoft

28 Curso de Java

Interfaz Gráfica y Windows

Java posee una librería para el manejo de interfaces graficas llamado AWT. Esta librería está basada en

componentes y permite anidar elementos gráficos unos dentro de otros para manejarlos como objetos.

Ejemplo:

Esta interfaz…

Se traduce como…

Para colocar elementos en una interfaz gráfica podemos hacerlo con diversos tipos de ventanas:

Window: Ventana de nivel superior, sin barra de título ni borde.

Frame: Marco, es decir, ventana con borde, título y barra de menú.

FileDialog: Ventana de dialogo para desplegar archivos.

A continuación un pequeño código de ejemplo que crea una ventana y la muestra por pantalla:

package interfaces;

import java.awt.*; public class Main extends Frame{

Benllisoft

29 Curso de Java

Main() { setTitle("Ventana de Java"); setSize(100,200); setVisible(true); }

public static void main(String[] args) { new Main(); } }

Los Objetos derivados de la clase Component que se incluyen en el AWT son los que aparecen a

continuación:

Button

Canvas

Checkbox

Choice

Container

Panel

Window

o Dialog

o Frame

Label

List

Scrollbar

TextComponent

o TextArea

o TextField

Elemento Panel

Cuando queremos agregar elementos y ordenarlos de cierta manera podemos agruparlos dentro de

un panel. Podemos crear un panel vacio o con un tipo de orden especifico, para esto necesitamos

crear un objeto que nos manejara el orden llamado Layout

Los tipos de Layout más utilizados son:

FlowLayout: Es el administrador por defecto, va colocando los elementos de izquierda a

derecha según cómo van siendo agregados.

Benllisoft

30 Curso de Java

BorderLayout: Administra los objetos en 5 secciones: North,South, East,West y Center.

Para agregar cierto elemento a cierta zona se hace con add(String zona, Component obj) donde

zona será una de las zonas antes mencionadas.

GridLayout: Permite colocar los elementos en forma de Rejilla, es decir en filas y

columnas. Se puede llamar usando GridLayout(int filas, int columnas)

Elemento Button

Permite agregar un botón, si deseamos que ese botón tenga un texto sobre el podemos usar los

métodos setLabel(String etiqueta) o para saber que etiqueta posee podemos usar getLabel().

Elemento MenuBar

La clase MenuBar permite crear una barra que almacena diversos menús, para crear estos menues

debemos primero crear la categoría con la clase Menu() y a esta le vamos a agregar sub-elementos

usando la clase MenuItem().

Luego de esto, si queremos agregar nuestra barra de menús a la ventana actual utilizamos el

método setMenuBar(MenuBar barra) donde barra es el objeto que almacena todo nuestro menú.

Ejemplo:

MenuBar miBarra=new MenuBar();

Menu menuArchivo=new Menu(“Archivo”);

MenuItem elementoAbrir=new MenuItem(“Abrir..”);

menuArchivo.add(elementoAbrir);

miBarra.add(menuArchivo);

setMenuBar(miBarra);

Para agregarle elementos al menú usamos Menu(String nombreMenu) y para colocarle elementos a

ese menú usamos MenuItem(String nombreElemento)

Elemento TextField y TextArea

Permite agregar un area de texto, lo agregamos usando TextField(int tamañoLinea) o TextArea(int

filas, int columnas)

Manejo de Eventos

El manejo de eventos de los diversos componentes de AWT se consigue implementando las

interfaces WindowListener, MouseListener o ActionListener. Al hacer esto se crean una serie de

Benllisoft

31 Curso de Java

métodos que permiten el manejo de eventos, ya sean eventos de ventanas, de eventos de ratón, o

eventos que debería hacer por defecto ese tipo de objeto, respectivamente.

Ejemplo:

public void windowOpened(WindowEvent e) {

}

public void windowClosing(WindowEvent e) {

System.exit(0);

}

public void windowClosed(WindowEvent e) {

}

public void windowIconified(WindowEvent e) {

}

public void windowDeiconified(WindowEvent e) {

}

public void windowActivated(WindowEvent e) {

}

public void windowDeactivated(WindowEvent e) {

}

Aunque implementemos todos estos métodos, como paso final necesitamos indicar que la clase que

implemento WindowListener es un manejador de eventos, eso se logra colocando la instrucción

addWindowListener(this), también existen addActionListener(this) y addMouseListener(this)

Ejemplo:

public class Main extends Frame implements WindowListener{

Main()

{

setTitle("Ejemplo de ventanas");

setSize(100,200);

setVisible(true);

Benllisoft

32 Curso de Java

boton b=new boton("Prueba");

add(b);

addWindowListener(this);

}

En el caso de ActionListener, el método actionPerformed() solo se activara con la función más

“típica” de ese objeto, por ejemplo, en un botón se activara cuando se haga click sobre él, en un

cuadro de texto se activara al hacer <INTRO>, en una lista se activara al seleccionar un objeto, etc.

Como este método es tan diverso, y puede ser usado por una gran cantidad de elementos, podemos

definir comportamientos a los objetos que luego serán reconocido por el método

actionPerformed(). Para agregar una “acción” a un objeto lo hacemos mediante el método

setActionCommand(String acción), la cual le asigna a determinado objeto esa cadena “acción” que

le indicamos, y luego, si necesitamos identificar cierto componente por su acción, lo podemos

hacer gracias al método String comando=e.getActionCommand(); el cual me devolverá el mismo

comando que le indique con el método anterior, así sabremos si el objeto en cuestión tiene una

tarea en particular.

public void actionPerformed (ActionEvent e)

{

String comando = e.getActionCommand();

if (comando.equals("Borra"))

metodoParaBorra();

else if (comando.equals("Crea"))

metodoParaCrea();

else if (comando.equals("Modifica"))

metodoParaModifica();

}

Creación de ejecutables

Luego de haber culminado algún proyecto, es de utilidad crear un ejecutable para que pueda ser

utilizado el código sin necesidad de una interfaz de desarrollo. Java nos permite crear un ejecutable con

el comando “jar” de la siguiente manera:

jar cmf archivo-file archivos-entrada

Donde los parámetros se explican a continuación:

cmf La letra c indica que se creara un nuevo archivo

jar. La letra m indica que se incluye un archivo de manifiesto la letra f indica que le estamos añadiendo el

nombre del archivo entre los parámetros

Archivo-file El nombre del nuevo archivo Jar

Archivos-entrada La lista de archivos que serán agregados al Jar, en caso de trabajar con paquetes, se debe solo

agregar el paquete que contiene las clases.

El archivo de manifiesto es un archivo de texto que indica donde está la clase principal de la aplicación.

Este archivo con la siguiente línea:

Main-Class: paquete.Main