Post on 01-Apr-2016
description
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