Guion1 Java2007

____________________________________________________________________________________
UNIVERSIDAD DON BOSCO
FACULTADES DE INGENIERÍA Y ESTUDIOS TECNOLÓGICOS
JAVA, CICLO 02/2007, guión de clase #1
Prof.: Ing. Carlos Tejada
Contenido:
1. Introducción a Java.
2. Elementos básicos del lenguaje.
3. Programación orientada a Objetos con Java.
4. Clases abstractas e interfaces.
5. Packages
6. Excepciones
7. Applets
1. INTRODUCCIÓN A JAVA
A finales de los años ochenta Sun Microsystems decide introducirse en el mercado de la electrónica de
consumo y más concretamente en los equipos domésticos, incluyendo la televisión interactiva. Java, nace como
un lenguaje ideado en sus comienzos para programar electrodomésticos. En sus primeras versiones, se llamó
OAK.
Java es un lenguaje orientado a objetos desarrollado por la empresa Sun Microsystems. Entre sus
características se destacan las siguientes:
 Basado en C++, comparte su sintaxis y muchos elementos del lenguaje, además de ser orientado a objetos
 Es un lenguaje multiplataforma, capaz de producir programas que se ejecutan bajo cualquier sistema
operativo y arquitectura de computación, utilizando el intérprete correspondiente
 Posee soporte para manejo de datos tanto a nivel local como en red, lo cual lo vuelve ideal para desarrollar
aplicaciones para Internet
 El kit de desarrollo de Java (j2sdk) está disponible gratis para varios sistemas operativos
 De alto nivel que posee asignación automática de memoria y ventajas que facilitan su aprendizaje y su uso
 Con Java es posible crear varios tipos de programas: aplicaciones gráficas, applets, servicios web y otros.
1/73
____________________________________________________________________________________
Java dispone de tres especificaciones para ser usadas en diferentes escenas:
J2SE (Java 2 Standard Edition)
J2EE (Java 2 Enterprise Edition)
J2ME (Java 2 Micro Edition)
J2SE provee todas las rutinas y librerías básicas para desarrollar aplicaciones con la plataforma Java,
incluyendo acceso a bases de datos, CORBA, acceso remoto, seguridad, etc. Es el que trataremos en este
curso.
J2EE es la plataforma creada por Sun para desarrollar aplicaciones de empresa multicapa. Esta construida
sobre J2SE y añade características de comunicación, arquitectura escalable y manejo de transacciones. Se usa
para desarrollar aplicaciones distribuidas. Entre sus aplicaciones más usadas se encuentra el desarrollo de
páginas Web del lado del servidor con JSP (Java Server Pages) y Servlets.
J2ME es la edición de Java dirigida a los dispositivos portátiles, como PDA, teléfonos móviles, etc. Posee su
propia máquina virtual.
1.1. Objetivos de diseño de los creadores de JAVA
 Lenguaje familiar: Java no sería un lenguaje totalmente nuevo, se parecería a lo que conocemos como C++,
así que no le sería tan complicado recalar en los programadores escépticos.
 Lenguaje orientado a objetos: Para que un lenguaje pueda considerarse orientado a objetos debe soportar
como mínimo las características de: encapsulación, herencia, polimorfismo, enlace dinámico.
 Lenguaje robusto: Uno de los problemas más comunes en los lenguajes de programación es la posibilidad
de escribir programas que pueden bloquear el sistema. Algunas veces este bloqueo puede ser inmediato,
pero en otras ocasiones llega a aparecer inesperadamente porque, por ejemplo, la aplicación accede a
zonas de memoria que no estaban siendo ocupadas por otros programas hasta ese momento. Un ejemplo
claro de lenguaje no robusto es C. Al escribir código en C o C++ el programador debe hacerse cargo de la
gestión de memoria de una forma explícita, solicitando la asignación de bloques a punteros y liberándolos
cuando ya no son necesarios. En Java, los punteros, la aritmética de punteros y las funciones de asignación
y liberación de memoria (malloc( ) y free( ) ) no existen. En lugar de los punteros se emplean referencias a
objetos, los cuales son identificadores simbólicos. El gestor de memoria de Java lleva una contabilidad de
las referencias a los objetos. Cuando ya no existe una referencia a un objeto, éste se convierte en candidato
para la recogida de basura (garbage collection).
2/73
____________________________________________________________________________________
 Lenguaje de alto rendimiento (múltiples threads): Una de las características del lenguaje es que soporta la
concurrencia a través de threads. En ocasiones puede interesarnos dividir una aplicación en varios flujos de
control independientes, cada uno de los cuales lleva a cabo sus funciones de manera concurrente. Cuando
los distintos flujos de control comparten un mismo espacio lógico de direcciones, se denominan threads.
 Lenguaje portable: El principal objetivo de los diseñadores de Java, y dado el gran crecimiento de las redes
en los últimos años, fue el de desarrollar un lenguaje cuyas aplicaciones una vez compiladas pudiesen ser
inmediatamente ejecutables en cualquier máquina y sobre cualquier sistema operativo. Por ejemplo, un
programa desarrollado en Java en una estación de trabajo Sun que emplea el sistema operativo Solaris,
debería poderse llevar a un PC que utilice sistema operativo Windows NT.
 Lenguaje lo más simple posible: mantiene las facilidades básicas del lenguaje en un mínimo y proporcionar
un gran número de extras con las librerías de clases.
 Lenguaje seguro: Se pretendía construir un lenguaje de programación que fuese seguro, esto es, que no
acceda a los recursos de manera incontrolada. Se eliminó la posibilidad de manipular mediante punteros y la
capacidad de transformación de números en direcciones de memoria evitando así todo acceso ilegal a la
memoria. Esto se asegura porque el compilador Java efectúa una verificación sistemática de conversiones.
1.2. Creación de aplicaciones
Para crear cualquier tipo de aplicación en Java, sólo es necesario instalar el kit de desarrollo de Java (j2sdk) en
cualquiera de los sistemas operativos soportados (Linux, Window$, Mac, etc.). Con el j2sdk, el proceso consta
de 3 etapas:
 Edición del código: Puede usarse cualquier editor de texto para escribir el código fuente de la aplicación. A
diferencia de ciertos lenguajes ``visuales'', Java permite la libre elección del editor para el código. Los
archivos de código fuente en Java poseen la extensión ``.java''.
 Compilación: El código fuente terminado es compilado, transformándose en un archivo ``.class''. Este archivo
no es un ejecutable puro, tiene un formato intermedio denominado código de bytes (bytecode), capaz de ser
procesado por el intérprete de Java en cualquier plataforma.
 Ejecución: El programa compilado se envía al intérprete de Java (conocido también como máquina virtual) el
cual se encarga de ejecutarlo. En el caso de los applets, el navegador llama al intérprete y ejecuta el código
3/73
____________________________________________________________________________________
en el área asignada dentro de la página web.
Una de las ventajas más importantes de Java es el hecho que se puede escoger cualquier sistema operativo
como plataforma de desarrollo, ya que la compilación y ejecución no son dependientes del sistema.
1.3. Java, la Java Virtual Machine y otros lenguajes
Tanto la sintaxis como los elementos fundamentales de Java están basados en C y sobre todo en C++. Pero a
diferencia de C y C++, Java no genera ejecutables que dependen del sistema operativo y tampoco es un
lenguaje de bajo nivel, es decir, con un control directo del hardware. Tampoco es un lenguaje script que se
interpreta y se ejecuta en el momento, como ocurre con JavaScript y VisualBasicScript. En realidad Java se
ubica en un lugar intermedio entre los lenguajes compilados puros y los interpretados puros (scripts).
Debido a que todo programa en Java tiene que pasar por el intérprete o máquina virtual, se presenta una
desventaja con respecto a lenguajes como C y C++, ya que Java no se ejecuta en forma tan rápida o eficiente
comparado con programas hechos en C o C++, que son lenguajes de bajo nivel diseñados para un alto
desempeño.
1.4. Ejecución de un programa en java.
 Para que descubra como funciona Java intente lo siguiente:
 Primero deberá crear un directorio en la cual se va a guardar el código fuente y los programas compilados,
se sugiere asignarle un nombre corto para que sea fácilmente accesible desde la línea de comandos.
 Ahora abra el block de notas ó un IDE y escriba el siguiente código:
class Programa1{
public static void main(String arg[]){
System.out.println(''Primer programa en java...'');
}
}
 Guarde el código anterior en un archivo llamado Programa1.java en su directorio de trabajo
 Luego abra una ventana de DOS y cámbiese al directorio de trabajo
 Compile el programa con el siguiente comando: javac Programa1.java
4/73
____________________________________________________________________________________
 Si el código no contiene errores, aparecerá un nuevo archivo llamado Programa1.class, de lo contrario se
mostrará un mensaje indicando la línea que contiene el error; en ese caso vuelva al block de notas, revise el
código e intente compilar otra vez
 Para ejecutar el programa, use este comando: java Programa1
 Lo anterior deberá mostrar el mensaje ''Primer programa en java...'' en la ventana de DOS .
5/73
____________________________________________________________________________________
2. ELEMENTOS BÁSICOS DEL LENGUAJE
2.1. Instrucciones del lenguaje
Existen varios tipos de instrucciones en java:
• Instrucción simple
• Instrucción condicional
• Instrucción iterativa
Una instrucción simple debe finalizar en punto y coma, y puede ser una expresión con operadores, una llamada
a un método, una declaración de variable o una instrucción compuesta por varias instrucciones simples:
int a = 5; //Declaración de variable
System.out.println(a); //Llamada a método
a = a+4; // Expresión con operadores
System.out.println(++a); //instrucción compuesta de llamada a método y operador ++
Para definir una variable se emplea la misma sintaxis que para la definición de un atributo en una clase, pero sin
utilizar los modificadores de visibilidad, ni los modificadores de atributos.
Además, en una instrucción simple pueden aparecer operadores, los hay de dos tipos: los que actúan sobre un
operador, o los que lo hacen sobre dos. Los operadores los clasificaremos por su empleo:
2.2. Operadores aritméticos:
Operador Uso Descripción

+ ope1 + ope2 Suma ope1 y ope2 (*)
ope1 ope2 Resta ope1 de ope2
* ope1 * ope2 Multiplica ope1 y ope2
/ ope1 / ope2 Divide ope1 por ope2
% ope1 % ope2 Obtiene el modulo de dividir ope1 por ope2
++ ope++ Incrementa ope en 1; evalúa el valor antes de
incrementar
++ ++ope Incrementa ope en 1; evalúa el valor después de
incrementar
ope Decrementa ope en 1; evalúa el valor antes de
incrementar
ope Decrementa ope en 1; evalúa el valor después de
incrementar
6/73
____________________________________________________________________________________
(*) En java también se emplea el operador + para concatenar cadenas de texto.
2.3. Operadores relacionales:
Operador Uso Devuelve verdadero si

> ope1 > ope2 ope1 es mayor que ope2
>= ope1 >= ope2 ope1 es mayor o igual que ope2
< ope1 < ope2 ope1 es menor que ope2
<= ope1 <= ope2 ope1 es menor o igual que ope2
= = ope1 = = ope2 ope1 y ope2 son iguales
! = ope1 != ope2 ope1 y ope2 son distintos
Nota: Los operadores relacionales siempre devuelven un valor booleano.
Hay que hacer especial mención a los operadores == y !=, además de ser empleados en los tipos básicos del
lenguaje pueden ser utilizados para comparar dos objetos, o más específicamente, comparar dos referencias a
objetos. Al comparar dos referencias a objetos lo que realmente se comprueba es si ambas referencias apuntan
al mismo objeto o no. No confundir esto con comparar dos referencias de tipo String, no se compararía si el
texto es el mismo, sino si ambas referencias apuntan al mismo objeto String. Para comparar String es necesario
hacerlo mediante los métodos que para ellos existen dentro de la clase String, como por ejemplo equals:
String cad1 = "Texto";
String cad2 = "Texto2";
boolean resultado = cad1.equals(cad2);
2.4. Operadores lógicos:
Operador Uso Devuelve verdadero si

&& ope1 && ope2 ope1 y ope2 son verdaderos
| | ope1 | | ope2 uno de los dos es verdadero
! ! ope ope es falso (niega ope)
Nota: Los operadores logicos siempre devuelven un valor booleano.
2.5. Variables
Identificadores son conjuntos de letras y/o números que se utilizan para simbolizar todos los elementos que en
7/73
____________________________________________________________________________________
un programa, son definibles por el usuario (programador o ingeniero de software) del mismo, como son las
variables donde se almacenan datos, funciones (pequeños módulos con código), etiquetas, clases, objetos, etc.
En java un identificador es una palabra compuesta de letras y/o números de hasta 32 caracteres significativos,
empezando siempre con una letra.
Una variable se define como un identificador que se utiliza para almacenar todos los datos generados durante la
ejecución de un programa.
Existen ciertas reglas en cuanto a variables:
 Claras y con referencia directa al problema.
 No espacios en blanco, ni símbolos extraños en ellas.
 Se pueden usar abreviaturas, pero solo de carácter general.
 No deben ser palabras reservadas del lenguaje.
Ejemplos de buenas variables:
Nombre, Edad, SdoDiario, IngMensual, Perímetro, Calif1, etc.
2.6. Instrucciones Condicionales
Java proporciona las instrucciones if/else, switch para poder tomar decisiones en función del resultado de la
evaluación de una condición o variable.
Condición If – else
La instrucción if tiene la siguiente estructura:
if (condición)
{
//Código a ejecutar si condición es true
}
else
{
8/73
____________________________________________________________________________________
//Código a ejecutar si condición es false
}
Esta instrucción evalúa la expresión condición, y si es true, ejecuta el código que hay entre las llaves que hay
debajo de if. Si condición fuese false, el código a ejecutar sería el contenido entre las llaves que existen debajo
de else.
La parte else es opcional, es decir, esto también es correcto:
if (condición)
{
//Código a ejecutar si condición es true
}
En este caso si condición es false no sucede nada, la instrucción no ejecuta ninguna instrucción.
Otra simplificación también correcta es que en caso de que sólo exista una instrucción dentro de las llaves (del
if, o del else) se pueden eliminar las llaves, es decir:
if (condición) //instrucción a ejecutar si condición es true;
else //instrucción a ejecutar si condición es false;
Lo que no está permitido eliminar en ningún caso, son los puntos y coma de las instrucciones que empleemos
en la parte verdadera (if) o falsa (else), tengamos o no las llaves.
Condición Switch Case
También existen ocasiones o programas donde se exige evaluar muchas condiciones a la vez, en estos casos,
o se usan una condición compuesta muy grande o se debe intentar convertir el problema a uno que se pueda
resolver usando la instrucción switch();
La instrucción switch() es una instrucción de decisión múltiple, donde el compilador prueba o busca el valor
contenido en una variable contra una lista de constantes ints o chars, cuando el computador encuentra el valor
de igualdad entre variable y constante, entonces ejecuta el grupo de instrucciones asociados a dicha constante,
si no encuentra el valor de igualdad entre variable y constante, entonces ejecuta un grupo de instrucciones
asociados a un default, aunque este ultimo es opcional.
El formato de esta instrucción es el siguiente;
9/73
____________________________________________________________________________________
capturar o asignar variable de condición;
switch(var int o char)
{ case const1: instrucción(es);
break;
case const2: instrucción(es);
break;
case const3: instrucción(es);
break; ..................
default: instrucción(es);
};
2.7. Condiciones Iterativas
Condición While y Do While
While
En este ciclo el cuerpo de instrucciones se ejecuta mientras una condición permanezca como verdadera, en el
momento en que la condición se convierte en falsa el ciclo termina.
Su formato general es:
cargar o inicializar variable de condición;
while(condición)
{
grupo cierto de instrucciones;
instrucción(es) para salir del ciclo;
};
Ejemplo:
x=1;
while(x<=10)
{ List.add("pato");
x++;
};
10/73
____________________________________________________________________________________
While puede llevar dos condiciones, en este caso inicializar 2 variables de condición y cuidar que existan 2 de
rompimiento de ciclo.
El grupo cierto de instrucciones puede ser una sola instrucción o todo un grupo de instrucciones.
La condición puede ser simple o compuesta.
A este ciclo también se le conoce también como ciclo de condición de entrada prueba por arriba, porque este
ciclo evalúa primero la condición y posteriormente ejecuta las instrucciones.
Do While
Su diferencia básica con el ciclo while es que la prueba de condición es hecha al finalizar el ciclo, es decir las
instrucciones se ejecutan cuando menos una vez, porque primero ejecuta las instrucciones y al final evalúa la
condición; también se le conoce por esta razón como ciclo de condición de salida.
Su formato general es:
Cargar o inicializar variable de condición;
do {
//grupo cierto de instrucción(es);
//instrucción(es) de rompimiento de ciclo;
} while (condición);
//ejemplo:
x=1;
do
{ List.add("pato");
x++;
}
while(x<=10);
2.8. Paquetes predefinidos en Java
En Java, un paquete es una colección de clases relacionadas. Como se ha dicho anteriormente, casi toda la
programación en Java se basa en el uso de diferentes clases, incluso para los programas más simples.
Existe un paquete fundamental llamado java.lang que es utilizado en todos los programas, ya que contiene las
11/73
____________________________________________________________________________________
clases básicas del lenguaje, como por ejemplo las clases String, Math y Object. Esta última es la primera en la
jerarquía de todas las clases de Java, es decir, cualquier clase se deriva implícitamente de Object.
Sin embargo, hay muchas clases especializadas disponibles en Java para diferentes tipos de programas
(multimedia,redes,etc.). Dado que no todos los programas necesitan utilizar todas las clases disponibles, la
mayoría se encuentran en paquetes distintos de java.lang. Para poder utilizar estos paquetes, es necesario
incluirlos con la instrucción import, la cual funciona de manera similar a la instruccion #include en C y C++.
Pueden incluirse uno o varios paquetes dentro de un programa, pero debe hacerse al principio del código. Por
ejemplo:
import java.util.Random; // Incluye la clase Random del paquete java.util
import java.awt.Graphics; // Incluye la clase Graphics del paquete java.awt
import java.lang.reflect.*; // Incluye todas las clases del paquete java.lang.reflect
Algunos de los paquetes “Java” más importantes:
- lang: funciones del lenguaje.
- util: utilidades.
- io: entrada, salida.
- text: formateo especializado.
- awt: gráficos e interfaz gráfica.
- awt.event: gestión de eventos.
- applet: programas para la “web”.
- net: redes.
- javax: elementos para aplicaciones web y bases de datos entre otros.
Toda la programación en Java funciona a base de paquetes prácticamente; ya que además de poder utilizar los
paquetes predefinidos es posible utilizar paquetes definidos por el usuario.
12/73
____________________________________________________________________________________
2.9. Lectura de datos desde el teclado utilizando un buffer
Para crear programas que soliciten datos al usuario (en modo texto), es necesario incluir algunas clases del
paquete java.io. Las clases básicas que se utilizan para esto son:
 La clase InputStreamReader para poder leer datos de entrada (teclado)
 La clase BufferedReader que permite guardar los datos en un buffer temporal
 La clase IOException para el manejo de errores de entrada/salida
También se necesita la clase System, que contiene los objetos in (entrada de datos estándar, sin procesar) y
out (salida de datos estándar); tanto la clase como los objetos están disponibles automáticamente al inicio de
cualquier programa, o sea que no es necesario importar la clase ni crear los objetos
Como los datos de entrada se manejan como texto, también puede ser necesario el uso de los métodos
contenidos en las clases Integer y Float para convertir valores enteros y decimales, respectivamente.
Los programas interactivos normalmente realizan la siguiente secuencia de pasos:
1. Crear un objeto BufferedReader, tomando como argumento otro objeto InputStreamReader, el cual a su
vez es creado a partir de System.in
2. Abrir una trampa para errores mediante las instrucciones try y catch
3. Dentro de esta trampa, leer los datos introducidos por el usuario usando el método readLine, estos
datos pueden guardarse en un String
4. Si se necesita, los datos pueden convertirse a números u otro tipo diferente para ser procesados por el
programa
Ejemplo de creación de un BufferedReader:
Teclado = flujo “in”
• Necesitamos el paquete java.io, es decir:
Primera línea del programa: import java.io.*;
13/73
____________________________________________________________________________________
• Establecer el flujo de entrada, el teclado (podría ser un fichero u otro dispositivo de entrada):
Primera línea del main:
BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
• Si en el proceso de entrada de datos hay algo que va mal, el programa puede hacer cosas
incontroladas, para evitarlo se usa una excepción, de la siguiente forma:
public static void main(String[] args) throws IOException {
//Leyendo cadenas de caracteres
String nombreVariable = in.readLine();
La sentencia anterior, inmoviliza la ejecución del programa hasta que escribamos algo por teclado y pulsemos
[Return]. Lo que escribimos se guarda en la variable de texto: nombreVariable.
2.10. Lectura y salida de datos utilizando un JoptionPane del paquete javax.swing.
JOptionPane se deriva de javax.swing; si bien es para aplicaciones gráficas nos puede servir para distintas
cosas como mostrar cuadros de diálogos, trabajar con archivos de texto o secuenciales, etc.
Dado que no existe un nivel tan avanzado de momento en el lenguaje, nos limitaremos a mencionarlo y utilizarlo
para entrada/salida de datos principalmente.
Algunos métodos ó funciones importantes:
 showConfirmDialog: mostrar un cuadro de confirmación(si/no normalmente).
 showInputDialog: solicitar un dato al usuario.
 showMessageDialog: enviar un mensaje a pantalla.
 showOptionDialog: mostrar mas opciones de las comunes.
14/73
____________________________________________________________________________________
2.11. Palabras reservadas
La siguiente lista contiene las palabras reservadas del lenguaje y que no pueden ser utilizadas como
identificadores; es de notar que todas están en minúsculas.
abstract else long synchronized

boolean extends native this
break final new throw
byte finally package throws
case float private transient
catch for protected try
char goto public void
class if return volatile
const implements short while
continue import static assert
default instanceof strictfp enum
do int super
double interface switch
15/73
____________________________________________________________________________________
2.12. Ejemplos
Ejemplo 1(Clase Saludito, archivo Saludito.java): programa que solicita un dato al usuario para mostrarlo en
pantalla.
import java.io.*;
public class Saludito {
public static void main(String [] args) throws IOException {
System.out.print("Escribe tu nombre: ");
String nom=in.readLine();
System.out.println("Adios "+nom);
}
}
La salida de este programa, vista desde el IDE, sería:
init:
depsjar:
compilesingle:
runsingle:
Carlos
Escribe tu nombre: Carlos
Adios Carlos
BUILD SUCCESSFUL (total time: 12 seconds)
Recuerde que es necesario compilar el programa:
 javac Ejemplo1.java (se genera el .class, o sea el bytecode)
 java Ejemplo1
16/73
____________________________________________________________________________________
Ejemplo 2(Clase Ejemplo2, archivo Ejemplo2.java): leer número desde el teclado.
/* Java puede leer fácilmente números y otros tipos de datos si están en forma
binaria y en un archivo.
Pero en el caso de números entrados por teclado, debe leer una cadena y hacer la
conversión en el programa.
Las funciones de conversión se encuentran en el paquete java.text, por lo tanto:
1ª línea de programa: import java.text.*;
Para leer un número real, deberemos escribir:
double x=Double.valueOf(in.readLine().trim()).doubleValue();
Escribe el resto del programa */
import java.text.*;
import java.io.*;
public class Ejemplo2{
public static void main(String [] args) throws IOException {
System.out.print("Escribí un número: ");
double x=Double.valueOf(in.readLine().trim()).doubleValue();
System.out.println("El triple es = "+3*x);
}
}
Vista la salida desde el IDE:
Note que en esta caso aparecen algo desordenadas algunas cosas: el número introducido aparece antes que el
mensaje “Escribí un número:”; esto es un detalle del IDE; el programa siempre funciona bien.
17/73
____________________________________________________________________________________
Ejemplo 3(Clase Ejemplo3, archivo Ejemplo3.java): Fibonacci
import java.text.*;//llamadas a clases preconstruidas
import java.io.*;
public class Ejemplo3{//clase para la serie, tope hasta 50

public static void main(String[] args) throws IOException { //primero el buffered reader
int n;
int arr[]=new int[50];
System.out.print("Escriba hasta adónde sacar la serie:");//mensaje y captura valor

n=Integer.parseInt(in.readLine());//conversión
arr[0]=0; //inicializar los primeros elementos, ya que siempre serán 0 y 1

arr[1]=1;
//llenar los demás elementos

for(int i=2;i<n;i++)
arr[i]=arr[i-1]+arr[i-2];//se llenan los demas elementos; recordemos
//que la serie fibonacci consiste en que cada
//elemento es igual a la suma de los dos anteriores
//mostrar ahora los elementos
for(int i=0;i<n;i++)//mostrar los elementos de la serie
System.out.print(arr[i]+" ");
}
}
La salida de este programa, en el IDE sería:
18/73
____________________________________________________________________________________
Ejemplo 4(Clase Ejemplo4, archivo Ejemplo4.java): Cuadrática
//programa que genera los valores de la ecuación cuadrática

import java.util.*;
import java.text.*;
import java.io.*;
public class Ejemplo4 {

public static void main(String args[]) throws IOException{
//crear primero el buffered reader
//declarar las variables que se necesitarán
float a,b,c,contenido_raiz; //recordemos que la fórmula de la cuadrática es

double x1,x2;
//X=(-b+/-raiz(b*b-4*a*c))/(2*a)
//pedir los datos ahora

System.out.println("Valor de A:");
a=Float.parseFloat(in.readLine());
System.out.println("Valor de B:");
b=Float.parseFloat(in.readLine());
System.out.println("Valor de C:");
c=Float.parseFloat(in.readLine());
//obtener el contenido de la raíz cuadrada

contenido_raiz=b*b-4*a*c;
//evaluar el contenido de la raíz cuadrada, recordemos que no hay raíz cuadrada de

números negativos
if(contenido_raiz<0){
System.out.println("No es posible obtener el contenido de las raices");
}
else{
//evaluar que el contenido del denominador no sea cero
if(2*a==0)
System.out.println("El contenido de la variable A es cero, no es posible
continuar.");
else{
//sacar las raices
x1=(-b+Math.sqrt(contenido_raiz))/(2*a);
x2=(-b-Math.sqrt(contenido_raiz))/(2*a);
//enviar resultados a pantalla
System.out.println("Las raices son X1="+x1+" X2="+x2);
}
}
}
}
19/73
____________________________________________________________________________________
Ejemplo 5: calculo del IVA usando JoptionPane
//programa para calcular el IVA
import javax.swing.JOptionPane;
public class iva {//declaración de la clase
public static void main(String args[]){//método main
Double precio=0.00,impuesto=0.00,total=0.00;//declaración de variables
String prec="";
//pedir precio, mientras sea vacío o cero no se admite
while(precio==0){
prec=JOptionPane.showInputDialog(null,"Introduzca el precio, distinto de cero:");
precio=Double.parseDouble(prec);
}
impuesto=precio*0.13;
total=precio+impuesto;
JOptionPane.showMessageDialog(null,"Precio="+precio+" Iva="+impuesto+" TOTAL="+total);
}
}
Las salidas de este programa serían:
20/73
____________________________________________________________________________________
Ejemplo 6: usando JOptionPane
/*El ejemplo genera un diálogo de confirmación, utilizando el que por defecto proporciona
Swing, del mismo modo que en los ejemplos siguientes se usan algunos de los demás diálogos
predefinidos. Analice el ejemplo y se dará cuenta que empezamos a ahondar en el siguiente
tema que es programación orientada a objetos. Este ejemplo fue tomado de
http://www.itapizaco.edu.mx/paginas/JavaTut/froufe/parte14/cap14-15.html
*/
import java.awt.event.*;
import javax.swing.*;
public class java1420 extends JFrame implements ActionListener {//aplicación de herencias
public java1420() {
JButton boton = new JButton( "Muestra Ventana" );
getContentPane().add( boton,"Center" );
pack();
boton.addActionListener( this );
}
public void actionPerformed( ActionEvent evt ) {

int res = JOptionPane.showConfirmDialog( this,"Responda Yes o No",
"Tutorial de Java, Swing",JOptionPane.YES_NO_OPTION );
String respuesta = null;
if( res == JOptionPane.YES_OPTION )

respuesta = "Si";
else
respuesta = "No";
System.out.println( "Respuesta: "+respuesta );
}
public static void main( String args[] ) {

new java1420().setVisible( true );
}
}
La salida de este programa sería:
21/73
____________________________________________________________________________________
3. PROGRAMACIÓN ORIENTADA A OBJETOS
Antes de empezar, algunos conceptos básicos de programación orientada a objetos
Objeto:
Una entidad individual dentro de un programa que posee atributos y características únicos; los objetos en
programación generalmente se basan en objetos del mundo real.
Clase:
Código que especifica la plantilla de la cual se van a derivar los correspondientes objetos; en la clase se
definen las características comunes de todos los objetos derivados de ella.
Atributo:
Variable dentro de una clase u objeto; los atributos de clase contienen valores comunes a todos los
objetos derivados de ella, mientras que los atributos de objeto contienen valores específicos para cada
objeto individual.
Propiedad:
Sinónimo de atributo.
Método:
Función asociada a una clase que realiza una tarea específica, como cambiar el valor de una propiedad o
crear objetos.
3.1. Definición de una clase
a) Introducción
El elemento básico de la programación orientada a objetos en Java es la clase. Una clase define la forma y
comportamiento de un objeto.
Para crear una clase sólo se necesita un archivo fuente que contenga la palabra clave reservada class seguida
de un identificador legal y un bloque delimitado por dos llaves para el cuerpo de la clase.
class MiPunto {
22/73
____________________________________________________________________________________
Recordemos que un archivo de Java debe tener el mismo nombre que la clase que contiene, y se les suele
asignar la extensión ".java". Por ejemplo la clase MiPunto se guardaría en un archivo que se llamase
MiPunto.java. Hay que tener presente que en Java se diferencia entre mayúsculas y minúsculas; el nombre de
la clase y el de archivo fuente han de ser exactamente iguales.
Aunque la clase MiPunto es sintácticamente correcta, es lo que se viene a llamar una clase vacía, es decir, una
clase que no hace nada. Las clases típicas de Java incluirán variables y métodos de instancia. Los programas
en Java completos constarán por lo general de varias clases de Java en distintos archivos fuente.
Una clase es una plantilla para un objeto. Por lo tanto define la estructura de un objeto y su interfaz funcional,
en forma de métodos. Cuando se ejecuta un programa en Java, el sistema utiliza definiciones de clase para
crear instancias de las clases, que son los objetos reales. Los términos instancia y objeto se utilizan de manera
indistinta. La forma general de una definición de clase es:
class Nombre_De_Clase {
tipo_de_variable nombre_de_atributo1;
tipo_de_variable nombre_de_atributo2;
// . . .
tipo_devuelto nombre_de_método1( lista_de_parámetros ) {
cuerpo_del_método1;
}
tipo_devuelto nombre_de_método2( lista_de_parámetros ) {
cuerpo_del_método2;
}
// . . .
}
Los tipos tipo_de_variable y tipo_devuelto, han de ser tipos simples Java o nombres de otras clases ya
definidas. Tanto Nombre_De_Clase, como los nombre_de_atributo y nombre_de_método, han de ser
identificadores Java válidos.
23/73
____________________________________________________________________________________
b) Los atributos
Los datos se encapsulan dentro de una clase declarando variables dentro de las llaves de apertura y cierre de
la declaración de la clase, variables que se conocen como atributos. Se declaran igual que las variables locales
de un método en concreto.
Por ejemplo, este es un programa que declara una clase MiPunto, con dos atributos enteros llamados x e y.
class MiPunto {
int x, y;
Los atributos se pueden declarar con dos clases de tipos: un tipo simple Java (ya descritos), o el nombre de una
clase (será una referencia a objeto).
Cuando se realiza una instancia de una clase (creación de un objeto) se reservará en la memoria un espacio
para un conjunto de datos como el que definen los atributos de una clase. A este conjunto de variables se le
denomina variables de instancia.
Hay 2 tipos de atributos, dependiendo de la forma en la que están definidos. Los atributos de objetos, también
conocidos simplemente como atributos, son los más comunes y pueden poseer valores diferentes para cada
objeto. A modo de ejemplo: si existe una clase "Carro" con un atributo "color" y se crean varios objetos
derivados de ella, se puede asignar un valor al atributo "color" de un objeto sin afectar a los otros.
El otro tipo de atributo se denomina atributo de clase. Los atributos de clase se diferencian de los atributos
normales en cuanto que si se modifica su valor, el cambio se refleja automáticamente en todos los objetos
derivados de dicha clase.
Los atributos de clase se definen anteponiendo el término static, por ejemplo:
static String apellido;
24/73
____________________________________________________________________________________
Cualquier valor que se asigne al atributo "apellido" será compartido por todos los objetos derivados de esa
clase.
En Java también es posible definir constantes usando el término final, de esta forma:
final int DEPARTAMENTOS=14;
Como en otros lenguajes, las constantes deben tener asignado un valor desde el principio. Además es normal
(no obligatorio) escribir su nombre en mayúsculas para distinguirlas de los atributos normales(variables).
c) Los métodos
Los métodos son subrutinas que definen la interfaz de una clase, sus capacidades y comportamiento.
Un método ha de tener por nombre cualquier identificador legal distinto de los ya utilizados por los nombres de
la clase en que está definido. Los métodos se declaran al mismo nivel que las variables de instancia dentro de
una definición de clase. En la declaración de los métodos se define el tipo de valor que devuelven y a una lista
formal de parámetros de entrada, de sintaxis tipo identificador separadas por comas. La forma general de una
declaración de método es:
tipo_devuelto nombre_de_método( lista-formal-de-parámetros ) {

cuerpo_del_método;
}
Por ejemplo el siguiente método devuelve la suma de dos enteros:
int metodoSuma( int paramX, int paramY ) {

return ( paramX + paramY );
}
En el caso de que no se desee devolver ningún valor se deberá indicar como tipo la palabra reservada void. Así
25/73
____________________________________________________________________________________
mismo, si no se desean parámetros, la declaración del método debería incluir un par de paréntesis vacíos (sin
void):
void metodoVacio( ) { };
Los métodos son llamados indicando una instancia individual de la clase, que tendrá su propio conjunto único
de variables de instancia, por lo que los métodos se pueden referir directamente a ellas.
El método inicia() para establecer valores a las dos variables de instancia sería el siguiente:
void inicia( int paramX, int paramY ) {

x = paramX;
y = paramY;
}
Los métodos son más o menos equivalentes a las funciones en C y se definen en forma similar. Los métodos
pueden admitir desde cero hasta varios argumentos (ya sea valores u objetos), y pueden devolver nada, un
valor u otro objeto.
El método main equivale a la función del mismo nombre en C, y sólo debe estar presente en el código de las
clases que van a ser ejecutadas directamente. Al igual que en C, este método controla la ejecución del
programa.
Los métodos también se clasifican en métodos de objetos (o simplemente métodos) y métodos de clase. Los
métodos de clase son accesibles sin necesidad de crear un objeto basado en esa clase, mientras que para los
métodos normales se presupone que existe ya un objeto que los puede llamar. Un ejemplo del uso de un
método de clase es el siguiente: System.out.println(Math.sqrt(74));
En este caso se manda a pantalla la raíz cuadrada de 74, la cual se ha calculado usando el método sqrt de la
clase Math, sin necesidad de haber creado un objeto derivado de ella. En Java, varios métodos definidos en
26/73
____________________________________________________________________________________
clases diferentes han reemplazado muchas de las funciones presentes en librerías de C.
3.2. La instanciación de las clases: Los objetos
a) Referencias a Objeto e Instancias
Los tipos simples de Java describían el tamaño y los valores de las variables. Cada vez que se crea una clase
se añade otro tipo de dato que se puede utilizar igual que uno de los tipos simples. Por ello al declarar una
nueva variable, se puede utilizar un nombre de clase como tipo. A estas variables se las conoce como
referencias a objeto.
Todas las referencias a objeto son compatibles también con las instancias de subclases de su tipo. Del mismo
modo que es correcto asignar un byte a una variable declarada como int, se puede declarar que una variable es
del tipo MiClase y guardar una referencia a una instancia de este tipo de clase:
MiPunto p;
Esta es una declaración de una variable p que es una referencia a un objeto de la clase MiPunto, de momento
con un valor por defecto de null. La referencia null es una referencia a un objeto de la clase Object, y se podrá
convertir a una referencia a cualquier otro objeto porque todos los objetos son hijos de la clase Object.
b) Constructores
Las clases pueden implementar un método especial llamado constructor. Un constructor es un método que
inicia un objeto inmediatamente después de su creación. De esta forma nos evitamos el tener que iniciar las
variables explícitamente para su iniciación.
El constructor tiene exactamente el mismo nombre de la clase que lo implementa; no puede haber ningún otro
método que comparta su nombre con el de su clase. Una vez definido, se llamará automáticamente al
constructor al crear un objeto de esa clase (al utilizar el operador new).
El constructor no devuelve ningún tipo, ni siquiera void. Su misión es iniciar todo estado interno de un objeto
(sus atributos), haciendo que el objeto sea utilizable inmediatamente; reservando memoria para sus atributos,
27/73
____________________________________________________________________________________
iniciando sus valores...
Por ejemplo:
MiPunto( ) {
inicia( 1, 1 );
Este constructor denominado constructor por defecto, por no tener parámetros, establece el valor 1 a las
variables de instancia x e y de los objetos que construya.
El compilador, por defecto, llamará al constructor de la superclase Object() si no se especifican parámetros en
el constructor.
Este otro constructor, sin embargo, recibe dos parámetros:
MiPunto( int paraX, int paraY ) {

inicia( paramX, paramY );
}
La lista de parámetros especificada después del nombre de una clase en una sentencia new se utiliza para
pasar parámetros al constructor.
Se llama al método constructor justo después de crear la instancia y antes de que new devuelva el control al
punto de la llamada.
Así, cuando ejecutamos el siguiente programa:
MiPunto p1 = new MiPunto(10, 20);
System.out.println( "p1.- x = " + p1.x + " y = " + p1.y );
Se muestra en la pantalla:
p1. x = 10 y = 20
Para crear un programa Java que contenga ese código, se debe de crear una clase que contenga un método
main(). El intérprete java se ejecutará el método main de la clase que se le indique como parámetro.
28/73
____________________________________________________________________________________
c) El operador new
El operador new crea una instancia de una clase (objetos) y devuelve una referencia a ese objeto. Por ejemplo:
MiPunto p2 = new MiPunto(2,3);
Este es un ejemplo de la creación de una instancia de MiPunto, que es controlador por la referencia a objeto p2.
Hay una distinción crítica entre la forma de manipular los tipos simples y las clases en Java: Las referencias a
objetos realmente no contienen a los objetos a los que referencian. De esta forma se pueden crear múltiples
referencias al mismo objeto, como por ejemplo:
MiPunto p3 =p2;
Aunque tan sólo se creó un objeto MiPunto, hay dos variables (p2 y p3) que lo referencian. Cualquier cambio
realizado en el objeto referenciado por p2 afectará al objeto referenciado por p3. La asignación de p2 a p3 no
reserva memoria ni modifica el objeto.
De hecho, las asignaciones posteriores de p2 simplemente libera p2 del objeto, sin afectarlo:
p2 = null; // p3 todavía apunta al objeto creado con new
Aunque se haya asignado null a p2, p3 todavía apunta al objeto creado por el operador new.
Cuando ya no haya ninguna variable que haga referencia a un objeto, Java reclama automáticamente la
memoria utilizada por ese objeto.
Cuando se realiza una instancia de una clase (mediante new) se reserva en la memoria un espacio para un
conjunto de datos como el que definen los atributos de la clase que se indica en la instanciación. A este
conjunto de variables se le denomina variables de instancia.
La potencia de las variables de instancia es que se obtiene un conjunto distinto de ellas cada vez que se crea
un objeto nuevo. Es importante el comprender que cada objeto tiene su propia copia de las variables de
29/73
____________________________________________________________________________________
instancia de su clase, por lo que los cambios sobre las variables de instancia de un objeto no tienen efecto
sobre las variables de instancia de otro.
El siguiente programa crea dos objetos MiPunto y establece los valores de x e y de cada uno de ellos de
manera independiente para mostrar que están realmente separados.
MiPunto p4 = new MiPunto( 10, 20 );

System.out.println("p4.- x = " + p4.x + " y = " + p4.y);
System.out.println("p5.- x = " + p5.x + " y = " + p5.y);
Este es el aspecto de salida cuando lo ejecutamos.
p4. x = 10 y = 20
p5. x = 42 y = 99
3.3. Acceso al objeto
a) El operador punto (.)
El operador punto (.) se utiliza para acceder a las variables de instancia y los métodos contenidos en un objeto,
mediante su referencia a objeto:
referencia_a_objeto.nombre_de_variable_de_instancia
referencia_a_objeto.nombre_de_método( listadeparámetros );
Hemos creado un ejemplo completo que combina los operadores new y punto para crear un objeto MiPunto,
almacenar algunos valores en él e imprimir sus valores finales:

System.out.println ("p6.- 1. X=" + p6.x + " , Y=" + p6.y);
p6.inicia( 30, 40 );
System.out.println ("p6.- 2. X=" + p6.x + " , Y=" + p6.y);
30/73
____________________________________________________________________________________
Cuando se ejecuta este programa, se observa la siguiente salida:
p6. 1. X=10 , Y=20
p6. 2. X=30 , Y=40
Durante las impresiones (método println ()) se accede al valor de las variables mediante p6.x y p6.y, y entre una
impresión y otra se llama al método inicia(), cambiando los valores de las variables de instancia.
Este es uno de los aspectos más importantes de la diferencia entre la programación orientada a objetos y la
programación estructurada. Cuando se llama al método p6.inicia(), lo primero que se hace en el método es
sustituir los nombres de los atributos de la clase por las correspondientes variables de instancia del objeto con
que se ha llamado. Así por ejemplo x se convertirá en p6.x.
Si otros objetos llaman a inicia(), incluso si lo hacen de una manera concurrente, no se producen efectos
laterales, ya que las variables de instancia sobre las que trabajan son distintas.
b) La referencia this
Java incluye un valor de referencia especial llamado this, que se utiliza dentro de cualquier método para
referirse al objeto actual. El valor this se refiere al objeto sobre el que ha sido llamado el método actual. Se
puede utilizar this siempre que se requiera una referencia a un objeto del tipo de una clase actual. Si hay dos
objetos que utilicen el mismo código, seleccionados a través de otras instancias, cada uno tiene su propio valor
único de this.
Un refinamiento habitual es que un constructor llame a otro para construir la instancia correctamente. El
siguiente constructor llama al constructor parametrizado MiPunto(x,y) para terminar de iniciar la instancia:
MiPunto() {
this( 1, 1 ); // Llama al constructor parametrizado
31/73
____________________________________________________________________________________
En Java se permite declarar variables locales, incluyendo parámetros formales de métodos.
No se utilizan x e y como nombres de parámetro para el método inicia, porque ocultarían las variables de
instancia x e y reales del ámbito del método. Si se hubiera hecho, entonces x se hubiera referido al parámetro
formal, ocultando la variable de instancia x:
void inicia2( int x, int y ) {

x = x; // Ojo, no se modifica la variable de instancia!!!
this.y = y; // Se modifica la variable de instancia!!!
}
En Java no existe el concepto de punteros, tal como se entiende en C y C++, aunque sí existe el concepto de
referencias a objetos, el cual es parecido. Veamos este ejemplo:
Carro unCarro,mismoCarro;
unCarro=new Carro();
mismoCarro=unCarro;
Aparentemente "mismoCarro" parece ser una copia de "unCarro", pero en realidad sólo es una referencia al
mismo objeto, de manera que estas 2 líneas hacen exactamente lo mismo:
unCarro.color="rojo";
mismoCarro.color="rojo";
3.4. Mas conceptos de programación orientada a objetos: Herencia, sobreposición y sobrecarga
La herencia es una característica de los lenguajes orientados a objetos que ahorra tiempo y líneas de código a
los programadores. Consiste en reutilizar la definición de una clase para crear otra con características similares,
sin necesidad de copiar y pegar el mismo código (*). De esta forma es posible crear una jerarquía de clases
según sea necesario.
32/73
____________________________________________________________________________________
(*) "Copiar y pegar" código es un mal hábito de programación que resulta en programas innecesariamente
largos, difíciles de depurar y lentos en su compilación y ejecución. Esto es particularmente cierto en lenguajes
orientados a objetos, como C++ o Java.
Para hacer que una clase adquiera los atributos y métodos de otra, se debe agregar el término extends a la
primera línea de la definición de la clase, como en este ejemplo:
class CarroDeportivo extends Carro{

// definición del resto de la clase CarroDeportivo
}
En este caso, la clase "CarroDeportivo" adquiere los métodos y atributos que ya tiene la clase "Carro", además
de poder agregar más métodos y atributos o modificar los que ya existen. De la misma forma se pueden crear
otras clases que heredan todo de "CarroDeportivo" y a la vez de "Carro".
La sobreposición está asociada a la herencia y consiste en reemplazar un método y/o atributo de la clase
original con otro método y/o atributo nuevo con el mismo nombre en la clase heredada. Por ejemplo, si en la
clase original hay un atributo "edad" que es un String, se puede tener un atributo "edad" de tipo entero en la
clase heredada, el cual reemplaza al original (lo mismo aplica para los métodos).
La sobrecarga es un concepto parecido, pero se aplica sólo a los métodos. Consiste en definir en una clase
varios métodos con el mismo nombre, pero con diferentes tipos y/o cantidad de argumentos y (opcionalmente)
diferentes valores de retorno.
Al ejecutar el programa, Java sabe cuál de los métodos debe llamar en base a los argumentos que se utilizan.
33/73
____________________________________________________________________________________
Ejemplo: observe y analice el siguiente ejercicio, siga los pasos para comprender mejor el ejemplo.
Deberá crear un nuevo proyecto en el IDE:
1. Escriba este código:
class Familia{
String domicilio="San Salvador";
static String apellido;
static int miembros;
final String pais="El Salvador";
void atributos(){
System.out.println("La familia "+apellido+" vive en "+domicilio+",
"+pais);
}
Familia f=new Familia();
f.apellido="González";
f.atributos();
}
}
2. Guarde el archivo como "Familia.java" en el directorio de trabajo, compílelo y luego ejecútelo
3. Si todo salió bien, escriba este código en un nuevo archivo:
class Persona extends Familia{

String nombre;
int edad;
void atributos(){
System.out.println("La familia "+apellido+" tiene "+miembros+" miembros");
System.out.println("y vive en "+domicilio+", "+pais);
}
void atrPersona(){
System.out.println(nombre+" "+apellido+", de "+edad+" años,");
System.out.println("vive en "+domicilio+", "+pais);
}
void atrPersona(String nuevoDom){

domicilio=nuevoDom;
atrPersona();
}

String ap;
if(arg.length!=1)
ap="Martínez";
else
ap=arg[0];
Familia fam=new Familia();
Persona juan=new Persona();
Persona maria=new Persona();
34/73
____________________________________________________________________________________
Persona daniel=new Persona();
fam.apellido=ap;
juan.nombre="Juan";
juan.edad=67;
juan.miembros++;
maria.nombre="María";
maria.edad=60;
maria.miembros++;
daniel.nombre="Daniel";
daniel.edad=35;
daniel.miembros++;
juan.atributos();
juan.atrPersona();
maria.atrPersona();
daniel.atrPersona("Santa Ana");
}
}
4. Guarde este archivo como "Persona.java", compílelo y ejecútelo
Intente lo siguiente con el ejemplo anterior:
1. Trate de identificar los tipos de atributos utilizados en ambas clases (normales, de clase, constantes)
2. Intente agregar y utilizar atributos a cualquiera de las clases
3. Determine cuáles métodos y/o atributos se heredan a la clase "Persona" y cuáles son sobrepuestos
4. Examine el funcionamiento de los métodos en la clase "Persona", comparándolos con la clase "Familia"
5. Determine cómo se ha implementado la sobrecarga de métodos en la clase "Persona"
La salida del programa anterior, debió ser la siguiente (en el IDE, al correr el segundo archivo):
35/73
____________________________________________________________________________________
3.5. Jerarquías de clases
Para programar eficientemente en un lenguaje orientado a objetos como Java, es necesario planificar
adecuadamente la estructura de las clases creadas por el programador, tomando en cuenta lo siguiente:
1. Generalmente las clases se estructuran a partir de cosas individuales y reales, dependiendo del
programa.
2. No se debe olvidar que las clases sirven para crear objetos a partir de ellas.
3. La jerarquía de las clases debe tener un orden lógico, recordando que una clase puede tener muchas
clases derivadas.
4. La jerarquía de las clases también debe permitir la máxima reutilización de código.
A modo de ejemplo, un programa podría necesitar de una clase "Alumno". Dicha clase contendría los atributos
necesarios para guardar los datos personales de cada alumno, es decir, de cada objeto creado a partir de ella.
Sin embargo, un alumno puede pertenecer a cualquier centro educativo, o sea que la clase genérica "Alumno"
no es dependiente de un solo centro educativo, el cual podría constituir una clase separada.
También es importante recordar que las clases son plantillas o moldes para la creación de objetos, y que la
característica principal de un programa orientado a objetos es la creación y uso de tales objetos según sea
necesario. Es un error común crear las clases como si ellas fueran objetos, asignando valores iniciales
innecesarios a los atributos y repitiendo código.
Una de las cosas más importantes es planificar con cuidado la jerarquía de clases, sobre todo si se está
creando un programa complejo. Algunos programadores simplifican demasiado la jerarquía de clases, llegando
a crear unas pocas clases con demasiados atributos y métodos que se vuelven difíciles de mantener y depurar.
Otros cometen el error opuesto: crean una jerarquía demasiado extensa con clases casi idénticas, lo cual
también hace difícil el mantenimiento y la depuración.
Una clase bien diseñada permite su reutilización en diferentes programas, reduciendo el tiempo de desarrollo y
la posibilidad de errores. Además hace más fácil su utilización por otros programadores. Casi todo el lenguaje
Java está basado en clases que poseen funcionalidad variada, desde la creación de una interfaz gráfica hasta
la transferencia de datos en red.
36/73
____________________________________________________________________________________
Un buen programa tiene como inicio un buen diseño: es muy recomendable trabajar primero en el diseño
general del programa (jerarquía de clases, lógica, etc.) con papel y lápiz antes de empezar a escribir el código.
3.6. Métodos constructores y destructores
En cualquier clase pueden existir 2 tipos de métodos especiales: los constructores y los destructores. El método
constructor (llamado simplemente constructor) es llamado automáticamente cuando se crea un objeto de una
determinada clase, mientras que el destructor es llamado cuando un objeto es eliminado.
Los constructores poseen estas características:
 Su nombre es igual al nombre de la clase
 Pueden sobrecargarse como cualquier otro método, es decir, puede haber más de un constructor (con
diferentes argumentos)
 Nunca retornan ningún valor
Para ver un ejemplo de una clase con un constructor, observe esta sección de código:
class Pintura{
String tipo;
String color;
Pintura(String t,String c){

tipo=t;
color=c;
}
}
Cada vez que se cree un objeto "Pintura", se podrá definir inmediatamente el tipo y color gracias al constructor:
Pintura p=new Pintura("Acrilico","Verde");
A diferencia de los constructores, el nombre de los destructores es siempre finalize para cualquier clase y se
definen de esta forma:
protected void finalize() throws Throwable{

// Aquí va el código del destructor
}
37/73
____________________________________________________________________________________
Debido a que Java libera automáticamente la memoria de los objetos eliminados, casi nunca es necesario
utilizar destructores (a diferencia de C++).
3.7. Miembros static, final, modificadores de acceso
Como se ha mencionado, los objetos poseen datos y comportamiento, y esto esta encerrado dentro de sí
mismos, pero en ocasiones se requiere compartir información entre objetos. Este mecanismo de comunicación
o mensajes entre objetos, viene dado por unos modificadores de acceso que indica cuándo un campo o método
puede ser conocido por otros objetos.
La siguiente tabla muestra estos modificadores de acceso.
private default protected public
Misma clase Si Si Si Si
Mismo paquete o No Si Si Si
subclase
Mismo paquete. No No Si Si Si
subclase
Diferente paquete No No Si Si
subclase
Diferente paquete No No No Si
nonsubclase
● Default: no requiere ninguna palabra pues es el tipo de acceso que se asume al crear un campo o
método.
● Private: es una palabra que se coloca antes de la variable, campo o método que deseamos ocultar del
resto del programa.
● Protected: las clases hijas durante la herencia pueden acceder a los campos o métodos declarados
protected, de manera directa.
38/73
____________________________________________________________________________________
● Public: como la fachada de la casa, todo el mundo puede verla, no esta oculta, y todos tienen acceso.
● Static. Este modificador establece que una variable permanece con un único valor para cualquier
instancia(objeto) de la clase. Cuando se usa con un método, dicho método puede ser utilizado sin
necesidad de instanciar un objeto de la clase, es decir con el nombre de la clase.metod () para
utilizarse. Otro uso de static es para declarar un bloque static, es decir un bloque se debe de ejecutar
justo al cargar una clase, antes que cualquier otra porción de código. Este bloque actúa como una
rutina para inicialización.
● Final cuando una variable es declarada final, se comporta como una constante. Un método es
declarado final para evitar que sus las clases hijas modifiquen dicho métodos decir evitar que las clases
sobrescriban (overridden) el método de la clase base.
39/73
____________________________________________________________________________________
Mas ejemplos: observe y analice los siguientes ejercicio, siga los pasos para comprender mejor el ejemplo.
1. Escriba este código:
class Recta{
char id;
int x1,y1,x2,y2;
Recta(char nombre,int origenX,int origenY,int finX,int finY){

id=nombre;
x1=origenX;
y1=origenY;
x2=finX;
y2=finY;
coordenadas();
}
Recta(char nombre,int origenX,int origenY,double radio,double angulo){
id=nombre;
x1=origenX;
y1=origenY;
x2=x1+(int)(radio*Math.cos(angulo));
y2=y1+(int)(radio*Math.sin(angulo));
coordenadas();
}
void coordenadas(){
System.out.println("Coordenadas de la recta "+id);
System.out.println("x1 = "+x1+", y1 = "+y1);
System.out.println("x2 = "+x2+", y2 = "+y2);
}
Recta a=new Recta('A',0,0,200.5,Math.PI/6);
Recta b=new Recta('B',0,0,75,150);
}
}
2. Guarde el archivo como "Recta.java" en el directorio de trabajo, compílelo y luego ejecútelo, la salida
del programa en el IDE debió ser la siguiente:
40/73
____________________________________________________________________________________
3. Si todo salió bien, escriba este código en un nuevo archivo:
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
class Datos{
String nombre,apellido;
int edad;
double estatura;
void atributos(){
System.out.println("Su nombre completo es "+nombre+" "+apellido);
System.out.println("Ud. tiene "+edad+" anos");
System.out.println("Su estatura es de "+estatura+" m");
}

BufferedReader buf=new BufferedReader(new
InputStreamReader(System.in));
Datos yo=new Datos();
System.out.print("Escriba su nombre: ");

try{
yo.nombre=buf.readLine();
}catch(IOException e){}
System.out.print("Escriba su apellido: ");
try{
yo.apellido=buf.readLine();
System.out.print("Escriba su edad: ");
try{
yo.edad=Integer.parseInt(buf.readLine());
System.out.print("Escriba su estatura en metros: ");
try{
yo.estatura=Double.parseDouble(buf.readLine());
41/73
____________________________________________________________________________________
yo.atributos();
}
}
4. Guarde este archivo como "Datos.java", compílelo y ejecútelo
Trate de hacer lo siguiente con los ejemplos anteriores:
En el primer programa:
1. Identifique los constructores y cómo son llamados al crear los objetos
2. Observe las diferencias y semejanzas entre los constructores
3. Trate de determinar qué es Math (un objeto, un método, una clase, etc.) y la forma en que se está
utilizando
4. Intente agregar nuevos atributos y/o métodos
En el segundo programa:
1. Identifique cuántos objetos son creados y a qué clase pertenecen
2. Identifique las trampas para errores y trate de determinar por qué se usan
3. Trate de modificar el código de manera que: a) se hereden los atributos y métodos de la clase "Recta" y
b) le pida al usuario los argumentos para crear los objetos "Recta"
42/73
____________________________________________________________________________________
Mas ejemplos generales:
Un lector desde el teclado:
import java.io.*;
public class Lector{
public static double LeerDouble() throws IOException {
InputStreamReader x1 = new InputStreamReader(System.in);
BufferedReader x2 = new BufferedReader(x1);
return Double.parseDouble(x2.readLine());
}
public static int LeerInt() throws IOException {
return Integer.parseInt(x2.readLine());
}
public static String LeerString() throws IOException {
return x2.readLine();
}
public static void show(String msg) {
System.out.println(msg);
}
double a=0, b=0;
int edad=0;
String nombre;
show("Introduzca A?");
a=LeerDouble();
show("Introduzca B?");
b=LeerDouble();
show("Introduzca la edad?");
edad=LeerInt();
show("Introduzca su nombre?");
nombre=LeerString();
show("A+B="+(a+b)+"\n Edad="+edad+"\nNombre="+nombre);
}
}
43/73
____________________________________________________________________________________
Propuesta de Xtecuan! Ufo para una serie fibonacci:
import java.io.*;
public class XteFibonacci{
public static long Fibo(int n){
long s=0;
if(n==0){return s;}
if(n==1){s+=1; return s;}
else{ return (Fibo(n-1)+Fibo(n-2)); }
}//fin Fibo()
public static void showFib(int n){
String cad=" ";
for(int i=0; i<=n; i++){
cad+=" "+Fibo(i);
}
System.out.println(cad+"\n");
}//fin showFib
public static void show(String msg){
}//fin show
public static void main(String[] args) throws IOException{

int n;
show("Ingrese el numero de terminos de la serie: ");
n=Integer.parseInt(x2.readLine());
show("\n\n");
showFib(n);
}//fin main()
}//fin XteFibonnaci
44/73
____________________________________________________________________________________
Serie personal de Xtecuan Ufo!(solo el sabe para que sirve):
import java.io.*;
public class SerieXtecuan{
public static final long valor=1000000;
public static long SumParImpar(int n){
int par,impar, i;
long sumapi;
par=0; impar=0; sumapi=0;
for(i=1;i<=n;i++){
par=2*i;
impar=par-1;
sumapi+=par+impar;
}//fin de for i
return sumapi;
}//fin de SumParImpar()
public static boolean EsPrimo(int x){
int t;
long c;
c=0;
for(int i=1; i<=x;i++){
t=x%i;
if(t==0){c++;}
}
if(c==2){ return true;}
else { return false ;}
}//fin SumPrimos()
public static long SumPrimos(int n){

long s=0;
int cp=0;
for(int i=1;i<=valor;i++){
if(EsPrimo(i)){
s+=i;
cp++;
}
if(cp==n){
break;
}//fin if cp==n
45/73
____________________________________________________________________________________
}//fin for i
return s;
}//fin SumPrimos()
public static void show(String msg){
}//fin show()
int n;
long suma_t=0;
show("Generador de Serie de Xtecuan!!!\n by XteSoft v1.0 2003");
show("Serie_Xtecuan=impar(i)+par(i)+primo(i)");
show("*****************************************************");
show("Ingrese el numero de terminos para el cual desea calcular la serie?\n");
n= Integer.parseInt(x2.readLine());
suma_t=SumParImpar(n)+SumPrimos(n);
show("\n\nSerie_Xtecuan=impar("+n+")+par("+n+")+primo("+n+")="+suma_t+"\n");
}//fin main()
}//fin SerieXtecuan
46/73
____________________________________________________________________________________
4. CLASES ABSTRACTAS E INTERFACES
4.1. Clases abstractas
Las clases abstractas:
● Es una clase que no se instancia.
● Se usa para definir sub – clases.
● Una clase es abstracta si uno de sus métodos no tiene implementación.
● Explícitamente, la abstracción se define con la palabra reservada abstract.
Las clases abstractas se utilizan cuando es prudente definir una abstracción que englobe distintos tipos y se
requiera el uso de elementos tales como el polimorfismo.
El siguiente ejemplo, representa el uso de clases abstractas (ejemplo basado en figuras geométricas);
recordemos que una clase abstracta no es para instanciar, es solamente para definir subclases:
La clase abstracta a utilizar es Figura.java; se recomienda siempre leer los comentarios:
//esta es la clase que utilizaremos como abstracta

public abstract class Figura{//podemos ver la definición como abstract
protected double x;//variables, utilizadas como protected
protected double y;
public Figura(double x,double y){//el contructor de esta clase

this.x=x;//inicialización de valores mediante puntero this
this.y=y;
}
public abstract double area ();//método abstracto, vacío, a ser sustituido en

otras clases
}
Ahora, las clases que heredarán de esta, primero, la clase Circulo:
//esta es una clase que hereda de la abtract Figura

//en este caso representa un círculo
import javax.swing.JOptionPane;//utilizaremos el JOptionPane para capturar datos
public class Circulo extends Figura{//heredamos de la clase Figura

private double radio;//una variable private, miembro de esta clase
public Circulo (double x,double y,double radio){//constructor de esta clase
super(x,y);//llamada al constructor de la super clase
this.radio=radio;//inicialización de un valor extra en esta clase.
}
47/73
____________________________________________________________________________________
public double area(){//nueva definición del método area

return Math.PI*radio*radio;//cálculo del área
}
public static void main(String args[]){
double x,y,radio,area;//variables locales
//pedir los datos;
JOptionPane.showMessageDialog(null,"Cálculo del area para un círculo,
usando clases abstractas");
x=Double.parseDouble(JOptionPane.showInputDialog("Introduzca el valor X del
origen:"));
y=Double.parseDouble(JOptionPane.showInputDialog("Introduzca el valor Y del
origen:"));
radio=Double.parseDouble(JOptionPane.showInputDialog("Introduzca el valor
del radio:"));
Circulo aro=new Circulo(x,y,radio);//creación del objeto, y uso de su

constructor
area=aro.area();//obtener el valor mediante el método de esta clase, no de
la abstract
//enviar una respuesta a pantalla, finalización

JOptionPane.showMessageDialog(null,"El área del círculo es "+area+", con
centro en ("+x+","+y+")");
}
}
Otra prueba, ahora con la clase Cuadrado:
//este es otro ejemplo de abstracción, el cálculo del área para un rectángulo es
//distinto que para un círculo
import javax.swing.JOptionPane;//usamos siempre el JOptionPane para pedir los datos
public class Cuadrado extends Figura{//definición de la clase
public Cuadrado (double x,double y){//creación del nuevo constructor

super(x,y); //el cuál llama al de la superclase
}
public double area(){//nuevo cálculo del área
return x*y;
}
public static void main(String args[]){//main
double x,y,area;//valores de entrada y a calcular
//pedir los datos;
JOptionPane.showMessageDialog(null,"Cálculo del area para un cuadrado,
usando clases abstractas");
x=Double.parseDouble(JOptionPane.showInputDialog("Introduzca el valor de la
base:"));
y=Double.parseDouble(JOptionPane.showInputDialog("Introduzca el valor de la
altura:"));
Cuadrado rect=new Cuadrado(x,y);//nueva llamada al constructor, son menos

datos ahora!!!
area=rect.area();//obtención del valor
48/73
____________________________________________________________________________________
//envío del resultado

JOptionPane.showMessageDialog(null,"El área del cuadrado es "+area);
}
}//fin del programa
Contestemos lo siguiente:
1. ¿porque utilizamos “protected” en la clase abstracta para los valores miembro?
2. ¿cuál es la utilidad de las clases abstractas?
3. ¿cuál es la utilidad según estos ejemplos?
Practique la abstracción; cree un método “volumen” para calcular el volumen en el Cuadrado, (en este caso se
trataría de un cubo, aunque no es necesario que modifique el nombre de la clase), necesitará solicitar un dato
mas que sería la profundidad del cubo. La fórmula para obtener el volumen de un cubo es
V=largo*ancho*profundidad.
4.2. interfaces
Las interfaces:
● Una interfaz es una clase completamente abstracta, es decir; una clase con métodos sin
implementación.
● En Java, las interfaces se declaran con la palabra reservada interface.
● En la interfaz, prácticamente solo van prototipos.
● Una interfaz no se hereda hacia otras clases, se implementa, por medio de la palabra reservada
implements.
La clase abstracta puede tener uno o mas métodos abstraídos, pero puede seguir teniendo funciones miembro
activas con implementación; mientras que la interfaz es mera plantilla ó “cascaron”.
Este ejemplo esta basado en el anterior, solamente que ahora utilizaremos interfaces.
Recuerde que una interfaz es una clase completamente abstracta, o sea, una clase sin implementación.
La interfaz Figura, se le invita siempre a leer los comentarios:
//implementación de la interfaz, ahora sin mas que la definición del método

public interface Figura {
public double area();
}
49/73
____________________________________________________________________________________
Ahora, veamos unas implementaciones de la interfaz, primerlo con la clase Circulo (note los cambios en cuanto
al ejemplo de abstracción):
//trate de notar los cambios respecto al ejemplo de abstracción
import javax.swing.JOptionPane;//utilizaremos el JOptionPane para capturar datos
public class Circulo implements Figura{//ahora ya no es herencia, es implementación

private double radio,x,y;//una variable private, miembro de esta clase
public Circulo (double x,double y,double radio){//constructor de esta clase
this.x=x;
this.y=y;
this.radio=radio;//inicialización de valores, ya no hay llamada a constructor
// de la superclase
}
public double area(){//nueva definición del método area
return Math.PI*radio*radio;//cálculo del área
}
double x,y,radio,area;//variables locales
//pedir los datos;
JOptionPane.showMessageDialog(null,"Cálculo del area para un círculo, usando
interfaces");
x=Double.parseDouble(JOptionPane.showInputDialog("Introduzca el valor X del
origen:"));
y=Double.parseDouble(JOptionPane.showInputDialog("Introduzca el valor Y del
origen:"));
radio=Double.parseDouble(JOptionPane.showInputDialog("Introduzca el valor
del radio:"));
Circulo aro=new Circulo(x,y,radio);//creación del objeto, y uso de su

constructor
area=aro.area();//obtener el valor mediante el método de esta clase, no de
la abstract
//enviar una respuesta a pantalla, finalización

JOptionPane.showMessageDialog(null,"El área del círculo es "+area+", con
centro en ("+x+","+y+")");
}
}
50/73
____________________________________________________________________________________
Ahora, con la clase cuadrado:
//este es otro ejemplo de interfaz, el cálculo del área para un rectángulo es

//distinto que para un círculo
import javax.swing.JOptionPane;//usamos siempre el JOptionPane para pedir los datos
public class Cuadrado implements Figura{//definición de la clase, ahora con
implements
// en vez de extends
private double x,y;
public Cuadrado (double x,double y){//creación del nuevo constructor
//recordemos que ya no existe constructor de superclase
this.x=x;
this.y=y;
}
public double area(){//nuevo cálculo del área
return x*y;
}
public static void main(String args[]){//main
double x,y,area;//valores de entrada y a calcular
//pedir los datos;
JOptionPane.showMessageDialog(null,"Cálculo del area para un cuadrado,
usando interfaces");
x=Double.parseDouble(JOptionPane.showInputDialog("Introduzca el valor de la
base:"));
y=Double.parseDouble(JOptionPane.showInputDialog("Introduzca el valor de la
altura:"));
Cuadrado rect=new Cuadrado(x,y);

area=rect.area();
//envío del resultado

JOptionPane.showMessageDialog(null,"El área del cuadrado es "+area);
}
}
Preguntas:
1. ¿cuál es la utilidad de las interfaces?
51/73
____________________________________________________________________________________
5. PACKAGES
5.1 Claúsula package
Un package es una agrupación de clases afines. Equivale al concepto de librería existente en otros lenguajes o
sistemas. Una clase puede definirse como perteneciente a un package y puede usar otras clases definidas en
ese o en otros packages.
Los packages delimitan el espacio de nombres (space name). El nombre de una clase debe ser único dentro del
package donde se define. Dos clases con el mismo nombre en dos packages distintos pueden coexistir e
incluso pueden ser usadas en el mismo programa. Una clase se declara perteneciente a un package con la
clausula package, cuya sintaxis es:
package nombre_package;
La clausula package debe ser la primera sentencia del archivo fuente. Cualquier clase declarada en ese archivo
pertenece al package indicado.
Por ejemplo, un archivo que contenga las sentencias:
package miPackage;
. . .
class miClase {
. . .
declara que la clase miClase pertenece al package miPackage. La claúsula package es opcional. Si no se
utiliza, las clases declaradas en el archivo fuente no pertenecen a ningún package concreto, sino que
pertenecen a un package por defecto sin nombre. La agrupación de clases en packages es conveniente desde
el punto de vista organizativo, para mantener bajo una ubicación común clases relacionadas que cooperan
desde algún punto de vista.
También resulta importante por la implicación que los packages tienen en los modificadores de acceso.
52/73
____________________________________________________________________________________
5.2 Claúsula import
Cuando se referencia cualquier clase dentro de otra se asume, si no se indica otra cosa, que ésta otra está
declarada en el mismo package. Por ejemplo:
package Geometria;
. . .
class Circulo {
Punto centro;
. . .
}
En esta declaración definimos la clase Circulo perteneciente al package Geometria. Esta clase usa la clase
Punto. El compilador y la JVM asumen que Punto pertenece también al package Geometria, y tal como está
hecha la definición, para que la clase Punto sea accesible (conocida) por el compilador, es necesario que esté
definida en el mismo package. Si esto no es así, es necesario hacer accesible el espacio de nombres donde
está definida la clase Punto a nuestra nueva clase. Esto se hace con la clausula import. Supongamos que la
clase Punto estuviera definida de esta forma:
package GeometriaBase;
class Punto {
int x , y;
}
Entonces, para usar la clase Punto en nuestra clase Circulo deberiamos poner:
package GeometriaAmpliada;
import GeometriaBase.*;
class Circulo {
Punto centro;
. . .
}
Con la claúsula import GeometriaBase.*; se hacen accesibles todos los nombres (todas las clases) declaradas
en el package GeometriaBase. Si sólo se quisiera tener accesible la clase Punto se podría declarar: import
GeometriaBase.Punto;
53/73
____________________________________________________________________________________
También es posible hacer accesibles los nombres de un package sin usar la clausula import calificando
completamente los nombres de aquellas clases pertenecientes a otros packages. Por ejemplo:
package GeometriaAmpliada;
class Circulo {
GeometriaBase.Punto centro;
. . .
}
Sin embargo si no se usa import es necesario especificar el nombre del package cada vez que se usa el
nombre Punto.
La claúsula import simplemente indica al compilador donde debe buscar clases adicionales, cuando no pueda
encontrarlas en el package actual y delimita los espacios de nombres y modificadores de acceso. Sin embargo,
no tiene la implicación de 'importar' o copiar código fuente u objeto alguno. En una clase puede haber tantas
sentencias import como sean necesarias. Las cláusulas import se colocan después de la cláusula package (si
es que existe) y antes de las definiciones de las clases.
5.3. Nombres de los packages
Los packages se pueden nombrar usando nombres compuestos separados por puntos, de forma similar a como
se componen las direcciones URL de Internet. Por ejemplo se puede tener un package de nombre
misPackages.Geometria.Base. Cuando se utiliza esta estructura se habla de packages y subpackages. En el
ejemplo misPackages es el Package base, Geometria es un subpackage de misPackages y Base es un
subpackage de Geometria.
De esta forma se pueden tener los packages ordenados según una jerarquía equivalente a un sistema de
archivos jerárquico.
El API de java está estructurado de esta forma, con un primer calificador (java o javax) que indica la base, un
segundo calificador (awt, util, swing, etc.) que indica el grupo funcional de clases y opcionalmente subpackages
54/73
____________________________________________________________________________________
en un tercer nivel, dependiendo de la amplitud del grupo. Cuando se crean packages de usuario no es
recomendable usar nombres de packages que empiecen por java o javax.
5.4. Ubicación de packages en el sistema de archivos
Además del significado lógico descrito hasta ahora, los packages también tienen un significado físico que sirve
para almacenar los módulos ejecutables (ficheros con extensión .class) en el sistema de archivos del
ordenador.
Supongamos que definimos una clase de nombre miClase que pertenece a un package de nombre
misPackages.Geometria.Base. Cuando la JVM vaya a cargar en memoria miClase buscará el módulo
ejecutable (de nombre miClase.class) en un directorio en la ruta de acceso misPackages/Geometria/Base. Está
ruta deberá existir y estar accesible a la JVM para que encuentre las clases.
Si una clase no pertenece a ningún package (no existe clausula package) se asume que pertenece a un
package por defecto sin nombre, y la JVM buscará el archivo .class en el directorio actual.
Para que una clase pueda ser usada fuera del package donde se definió debe ser declarada con el modificador
de acceso public, de la siguiente forma:
package GeometriaBase;
public class Punto {
int x , y;
}
Si una clase no se declara public sólo puede ser usada por clases que pertenezcan al mismo package.
55/73
____________________________________________________________________________________
Ejemplos:
En este caso vamos a realizar un ejemplo de aplicación de packages definidos por el usuario; recuerde que una
utilidad de crear packages es ordenar sus programas, mejorando otros aspectos relacionados.
El package se maneja internamente como un directorio con los archivos correspondientes a las clases; el
nombre del directorio es el nombre del package.
Para este caso, primero vamos a crear el package “calculos”; en su IDE (netbeans), dentro de su proyecto, tiene
la opción de crear un package, es ahí adonde entramos en este momento para crear el siguiente código (al
package le llamaremos “calculos”, es respecto a unos cálculos y mensajes):
/*
* calculos.java
*/
package formulas;//definimos a que paquete pertenecerá el archivo
public class calculos {//una clase que pertenece al paquete

public static double iva (double precio) {//un método
return precio*1.13;
}
public static String aviso (int hora){//otro método

if(hora>0 && hora<12)
return "Buenos dias!";
else{
if(hora>12 && hora<19)
return "Buenas tardes!";
else
return "Buenas noches!";
}
}
}
Compile el código anterior, dado que no tenemos un método main no es posible correrlo, aunque si lo
hicieramos, funcionara. Bien, ahora, creemos el programa en donde utilizamos al package recien creado, le
hemos llamado Miscelanea a la clase:
/*
*Clase en la que se observa la implementación de paquetes
*/
//llamamos al paquete creado com import, usaremos también JOPtionPane
import javax.swing.JOptionPane;
import formulas.*;
public class Miscelanea {
56/73
____________________________________________________________________________________

//declaración de variables
Double precio;
Integer hora;
//iniciamos con un mensaje

JOptionPane.showMessageDialog(null,"Prueba de package, se pedirán algunos
datos!!!!","Uso de package",JOptionPane.INFORMATION_MESSAGE);
//pedir el precio, recordemos que todo dato que viene

//del JOptionPane viene como String, habrá que convertirlo
precio=Double.parseDouble(JOptionPane.showInputDialog("Introduzca un precio
(sin el $):"));
//calculamos según el package y lo informamos
JOptionPane.showMessageDialog(null,"El precio con IVA
es:"+calculos.iva(precio),"Informe de precio",JOptionPane.INFORMATION_MESSAGE);
//hacemos lo mismo otra vez, pero en este caso lo vamos a probar con otro
método en el mismo paquete
//pedimos el dato correspondiente a la hora
//otra vez hay que convertir, si lo necesitaramos String, no habria
necesidad de convertir
hora=Integer.parseInt(JOptionPane.showInputDialog("Introduzca la hora, solo
el valor entero (p.ej., si son las 3:30pm introduzca 15):"));
//hacemos la llamada a otra clase dentro del mismo paquete
JOptionPane.showMessageDialog(null,calculos.aviso(hora),"Aviso",JOptionPane
.INFORMATION_MESSAGE);
}
}
Una de las salidas del programa sería:
Cambios propuestos:
1. Cree y utilice un método mas en el package.
2. Desglose los métodos “iva” y “aviso” en clases diferentes pero siempre dentro del mismo paquete,
realice también su implementación.
3. Investigue como utilizar formatos de fecha/hora y en lugar de pedir la hora al usuario, que esta sea
recogida por el sistema.
57/73
____________________________________________________________________________________
6. MANEJO DE EXCEPCIONES, ERRORES Y FLUJOS
6.1. Errores y excepciones
Lo que en otros lenguajes se conoce con el término genérico de errores, en Java se clasifica en 2 categorías
posibles: errores y excepciones. La diferencia es que los errores son siempre a nivel de máquina virtual y por lo
tanto el programador no puede hacer nada al respecto, mientras que las excepciones son situaciones
anormales dentro de un programa que necesitan ser manejadas de alguna manera.
Muchos métodos de diferentes clases pueden tirar excepciones cuando algo no resultó bien. Para estar
preparados para cualquier eventualidad, el código que llama a un método que puede tirar excepciones debe
hacerlo dentro de un bloque try y catch:
try{
// Llamada al método que causa la excepción
}
catch(IOException e){
// Código para manejar la excepción
}
En el ejemplo anterior se asume que la excepción esperada es de tipo IOException, o sea una exepción de
entrada/salida (aunque existen muchos tipos de excepciones diferentes). Si se necesita que un método propio
produzca una excepción si algo anda mal, se agrega la instrucción throws a su definición. Por ejemplo:
void miMetodo() throws FileNotFoundException{
// Código del método
}
Aquí se especifica que "miMetodo" puede tirar una excepción de archivo no encontrado
(FileNotFoundException), la cual debe ser atrapada con try/catch cuando el método sea llamado. También es
posible crear excepciones propias, derivando clases de alguna excepción existente.
6.2. Las sentencias throw
Todos los métodos Java utilizan la sentencia throw para lanzar una excepción.
Esta sentencia requiere un sólo argumento, un objeto Throwable. En el sistema Java, los objetos lanzables son
ejemplares de la clase Throwable definida en el paquete java.lang. Aquí tienes un ejemplo de la sentencia
throw.
throw algunObjetoThrowable;
58/73
____________________________________________________________________________________
Si se intenta lanzar un objeto que no es 'lanzable', el compilador rehusa la compilación del programa y muestra
un mensaje de error similar a éste.
testing.java:10: Cannot throw class java.lang.Integer; it must be a subclass
of class java.lang.Throwable.
throw new Integer(4);
^
Echemos un vistazo a la sentencia throw en su contexto. El siguiente método está tomado de una clase que
implementa un objeto pila normal. El método pop() saca el elemento superior de la pila y lo devuelve.
public Object pop() throws EmptyStackException {
Object obj;
if (size == 0)
throw new EmptyStackException();
obj = objectAt(size 1);
setObjectAt(size 1, null);
size;
return obj;
}
El método pop() comprueba si hay algún elemento en la pila. Si la pila está vacía (su tamaño es igual a cero),
ejemplariza un nuevo objeto de la clase EmptyStackException y lo lanza. Esta clase está definida en el paquete
java.util. En páginas posteriores podrás ver cómo crear tus propias clases de excepciones. Por ahora, todo lo
que necesitas recordar es que se pueden lanzar objetos heredados desde la clase Throwable.
6.3. El bloque finally
El paso final en la creación de un manejador de excepción es proporcionar un mecanismo que limpie el estado
del método antes (posiblemente) de permitir que el control pase a otra parte diferente del programa. Se puede
hacer esto encerrando el código de limpieza dentro de un bloque finally.
La primera necesidad de la sentencia finally podría no aparecer de forma inmediata. Los programadores se

preguntan frecuentemente "¿Es realmente necesaria la sentencia finally o es sólo azucar para mi Java?" En
particular los programadores de C++ dudan de la necesidad de esta sentencia porque C++ no la tiene.
6.4. printStackTrace, getStackTrace y getMessage
De la clase Throwable se desprende el método printStackTrace, el cuál imprime la pila de llamadas a métodos.
A menudo esto ayuda en la prueba y depuración. La clase Throwable también proporciona el método
getStackTrace el cuál obtiene la información que imprime printStackTrace. El método getMessage de la clase
Throwable devuelve la cadena descriptiva almacenada en una excepción.
59/73
____________________________________________________________________________________
6.5. Los flujos
Los flujos constituyen la forma general como se procesan datos en Java. Un flujo puede mover datos de una
ubicación a otra, o actuar como un contenedor temporal. Existen 2 clases de flujos: los flujos propiamente
dichos y los filtros. Un filtro es un flujo especial que actúa modificando de alguna forma el contenido de otro(s)
flujo(s), y no tiene sentido usarlo en forma aislada. Como ejemplo de un filtro podemos mencionar los búffers,
que representan áreas donde se almacenan temporalmente los datos para ser procesados poco a poco.
Los flujos son una característica poderosa de Java cuando uno llega a dominar su implementación, ya que por
medio de éstos podemos manejar datos de diferentes formas: crear y leer archivos, procesar datos desde el
teclado, enviar y recibir información a través de Internet o una red local, etc. El paquete java.io posee una gran
variedad de clases especializadas en el manejo de tipos de flujos diferentes.
Ejemplos:
El siguiente archivo maneja las excepciones que podrían darse en el momento de leer un archivo de texto, el
archivo se llama Alfabeto.java
import java.io.*;//clases a utilizar

class Alfabeto{
int i;
try{//ciclo try, o sea tratar de realizar la operación

FileWriter letras=new FileWriter("alfabeto.txt");//buffer para leer
archivos
for(i=65;i<91;i++){
letras.write((char)i);
}
letras.close();
}
catch(IOException e){//si ocurrió un error
System.out.println("Error al crear archivo");
System.out.println(e.getMessage);//obtener la excepción
return;
}
System.out.println("Archivo creado");
}
}
60/73
____________________________________________________________________________________
Las excepciones pueden manejarse en mas de una ocasión en el mismo programa; siguiendo por ejemplo la
siguiente sintaxis:
try{//primer bloque de intento
catch(){//si ocurre un tipo de excepción
catch(){//si ocurre otro tipo de excepción, etc
Note las variantes respecto a flujo en el siguiente ejemplo(el archivo se llama LeerArchivo.java); siempre
utilizamos excepciones con cierta variante respecto al anterior.
import java.io.*;
class LeerArchivo{
String nombreArchivo;
void leer() throws IOException{//otra forma de manejo de excepciones

FileReader archivo=new FileReader(nombreArchivo);
BufferedReader bufferArchivo=new BufferedReader(archivo);//buffer
String linea;
do{//capturar por líneas
linea=bufferArchivo.readLine();
System.out.println(linea);
}while(linea!=null);
}

BufferedReader buf=new BufferedReader(new
InputStreamReader(System.in));//inicializar el buffer
LeerArchivo a=new LeerArchivo();//abrir el archivo
System.out.print("Escriba el nombre de un archivo de texto: ");

try{//bloque try o de intento
a.nombreArchivo=buf.readLine();
a.leer();
}
catch(IOException e){//si ocurre la excepción
System.out.println("Error de lectura - fin del programa");
System.out.println(e.getException);//obtener la excepción
e.printStackTrace();//imprimir pila
}
}
}
61/73
____________________________________________________________________________________
7. APPLETS
7.1 Applets y aplicaciones
Java es conocido por mucha gente como un lenguaje de programación para crear applets, debido a que su
popularidad se debe en buena parte a la gran cantidad de applets disponibles el miles de sitios web diferentes.
Un applet es una especie de "miniaplicación" incorporada a una página web. Para que un usuario pueda
ejecutar un applet, sólo es necesario accesar la página web que lo contiene utilizando cualquier navegador
reciente que soporte Java (Netscape, Mozilla, FireFox, Opera, Konqueror, IE, etc.). Los applets generalmente
hacen cosas relativamente sencillas, como mostrar marquesinas con noticias u otra información, animaciones
interactivas, juegos sencillos, etc.
Desde el punto de vista técnico, un applet puede hacer casi todo lo que haría una aplicación de Java, excepto lo
siguiente:
● Abrir o guardar archivos en la PC de los usuarios
● Transferir datos hacia o desde un servidor distinto al que contiene la página web
● Ejecutar programas en la PC de los usuarios
Esto se debe a razones de seguridad, porque de otra forma los applets podrían robar o destruir datos de
millones de usuarios que se conectan a Internet. Sin embargo, en versiones recientes de Java existen
mecanismos, como las firmas digitales, que permiten validar un applet para que pueda hacer las tareas
descritas anteriormente (con algunas restricciones).
7.2. Programación basada en eventos
A diferencia de los programas creados hasta ahora, los applets son interactivos por naturaleza, es decir,
responden a las acciones del usuario (con el mouse o el teclado). Los applets normalmente poseen métodos
para manejar diferentes eventos, como mover el mouse sobre un área específica, ocultar la ventana que
contiene el applet, presionar ciertas teclas, etc.
La programación basada en eventos es una metodología empleada en muchos lenguajes de programación
"visuales", como por ejemplo Visual Basic. Cuando se crean applets o aplicaciones con una interfaz gráfica en
Java, los conceptos son similares, dado que el orden de ejecución del código está basado en las acciones del
usuario u otros eventos del sistema. Además los applets pueden incluir elementos de una interfaz gráfica, como
cuadros de texto, botones y otros.
7.3. Estructura de un applet
A nivel de código, un applet tiene una estructura un poco diferente a los programas normales en Java. En
primer lugar, todo applet debe derivarse de la clase Applet que se encuentra en el paquete java.applet. Además
debe definirse como public, puesto que los métodos del applet deben ser accesibles para el navegador, el cual
controla su ejecución.
62/73
____________________________________________________________________________________
En lugar de un método main, el código de un applet se distribuye en diferentes métodos que corresponden a
varios eventos fundamentales:
● El método init se ejecuta cuando se carga inicialmente el applet; aquí va el código que necesita
ejecutarse al inicio, como la creación de objetos, el manejo de argumentos y la carga de imágenes
● El método start se ejecuta al reinicializar el applet, por ejemplo después que la ejecución se ha detenido
porque el usuario se trasladó a otra página web y luego regresa a la anterior (que contiene el applet)
● El método stop es llamado cuando el applet se detiene, ya sea por el cambio de página web o por
alguna otra causa
● Uno de los métodos más importantes es paint, el cual es llamado cada vez que hay que actualizar el
área de la ventana donde se muestra el applet; aquí se incluyen llamadas a métodos que dibujan algo
● Existe un método que casi no se utiliza llamado destroy, que se ejecuta cuando el applet finaliza su
ejecución en forma definitiva, por ejemplo cuando se cierra el navegador
No todos los applets utilizan todos los métodos descritos arriba; los más sencillos muchas veces sólo utilizan el
método paint para poder mostrar algo en el área asignada al applet.
Al igual que los programas normales, los applets aceptan argumentos; lo que cambia es la forma como se
pasan y se procesan. En un programa normal, los argumentos se almacenan en un arreglo de tipo String
definido dentro de main, mientras que en un applet es necesario obtener su valor por medio del método
getParameter, como se verá más adelante.
7.4. Uso de applets en páginas web
Después de escribir el código del applet, se compila como cualquier otro programa de Java. Pero en lugar de
ejecutarlo según el procedimiento normal, es necesario crear una página web que contenga la referencia al
archivo "class" del applet. No hace falta crear una página web sofisticada, ni siquiera es obligación poner
etiquietas como <HTML> o <BODY>; simplemente basta que contenga una línea como la siguiente:
<APPLET CODE="Prueba.class" WIDTH=200 HEIGHT=100> </APPLET>
Aquí se asume que el applet está compilado en un archivo llamado "Prueba.class" que se encuentra en el
mismo directorio que la página web. También se le asigna un área dentro de la página equivalente a 200 pixeles
de ancho y 100 de alto.
Una vez que ya tenemos la página web, se puede ejecutar el applet de 2 maneras diferentes:
1. Abrir la página web en un navegador que soporte Java
2. Abrir la página web con el programa appletviewer
63/73
____________________________________________________________________________________
El programa appletviewer es parte del J2SDK y puede ejecutarse desde la línea de comandos (o ventana de

DOS) como en este ejemplo:
appletviewer Pagina.html
Para pasar argumentos a un applet, es necesario incluir etiquetas <PARAM> en medio de la apertura y cierre
de la etiqueta <APPLET>:
<APPLET CODE="Prueba.class" WIDTH=200 HEIGHT=100>
<PARAM NAME="texto" VALUE="Mi primer applet">
</APPLET>
Ejemplo: enviar un simple mensaje a pantalla(archivo Mensaje.java)
import java.awt.Graphics;
import java.awt.Font;
import java.awt.Color;
public class Mensaje extends java.applet.Applet{

Font letra;
String cadena;
int tamano;
public void init(){

String t;
cadena=getParameter("texto");
if(cadena==null)
cadena="1, 2, 3, probando...";
t=getParameter("tam");
if(t==null)
tamano=36;
else
tamano=Integer.parseInt(t);
letra=new Font("TimesRoman",Font.BOLD,tamano);
}
public void paint(Graphics pantalla){

pantalla.setFont(letra);
pantalla.setColor(Color.red);
pantalla.drawString(cadena,5,50);
}
}
Luego de compilar, la ejecución se vería así:
64/73
____________________________________________________________________________________
7.5. El modo gráfico en Java
Java posee diversos paquetes y clases para dibujar en pantalla. El paquete más básico para hacer esto se
llama java.awt. AWT puede traducirse como "herramientas para el manejo abstracto de ventanas", lo cual
implica un conjunto completo de clases para diseñar interfaces gráficas de usuario, tanto para applets como
aplicaciones.
Entre las clases que se encuentran dentro del AWT, encontramos clases para el manejo de color, tipos de letra,
figuras geométricas, controles, etc. Este paquete es extenso y es necesario examinar la documentación
correspondiente para poder utilizarlo en forma efectiva.
7.6. Algunos métodos y clases gráficos
En esta lista se describen algunas clases usadas con frecuencia en AWT:
● Graphics: proporciona el área y los métodos de dibujo
● Font: proporciona el tipo de letra con el que se muestra el texto
● Color: permite establecer los colores de los diferentes elementos gráficos
● Polygon: permite crear polígonos regulares o irregulares
A continuación se enumeran algunos de los métodos gráficos disponibles en AWT, la mayoría de los cuales
forman parte de la clase Graphics:
65/73
____________________________________________________________________________________
● drawLine: dibuja una línea entre 2 coordenadas
● drawRect y fillRect: dibujan un cuadrilátero (cuadrado o rectángulo) vacío o relleno, respectivamente
● drawOval y fillOval: dibujan una circunferencia (círculo u óvalo) vacío o relleno, respectivamente
● drawRoundRect y fillRoundRect: dibujan un cuadrilátero con esquinas redondeadas, ya sea vacío o
relleno
● drawArc y fillArc: dibujan un arco o una sección de una circunferencia rellena, respectivamente
● drawPoly y fillPoly: dibujan un polígono (regular o irregular) vacío o relleno, respectivamente
● setBackground: define el color de fondo
● setColor: define el color usado para dibujar
● setFont: define el tipo de letra para mostrar el texto
Ejemplo: una gráfica de pastel(archivo grafica_keike.java)
import java.applet.*;
import java.awt.*;
public class grafica_keike extends Applet{
final static int datos[]={51,20,19,10};//pendiente de cambiar
final static String etiquetas[]={"Aguila","FAS","Malianza","Otro"};
final static Color
color_datos[]={Color.orange,Color.red,Color.white,Color.green};
int pos_grafica=20;//posición de la gráfica respecto al origen
int diametro_grafica=150;
public void paint(Graphics g){

int angulo_inicial, tamanio_keike;
int sub_total=0;
angulo_inicial=0;
for(int i=0;i<=datos.length;i++){
//dibujar el keike
sub_total+=datos[i];
tamanio_keike=sub_total*360/100-angulo_inicial;
g.setColor(color_datos[i]);
g.fillArc(pos_grafica,pos_grafica,diametro_grafica,diametro_grafica,ang
ulo_inicial,tamanio_keike);
angulo_inicial+=tamanio_keike;
//dibujar la leyenda
g.fillRect(pos_grafica+diametro_grafica+10,pos_grafica+i*20,15,15);
g.setColor(Color.black);
g.drawString(etiquetas[i],pos_grafica+diametro_grafica+10+20,pos_grafic
a+i*20+15);
}
}
}
66/73
____________________________________________________________________________________
Luego de compilar, la ejecución en la página quedaría así:
7.7 Uso de diseñadores
A diferencia de otros lenguajes de programación como Visual Basic, el diseño de la interfaz gráfica en un applet
o aplicación no se basa en un sistema de coordenadas fijo, sino en una estructura general de diseño que le
indica a cada control su posición en la ventana o área visible. Esto es necesario porque Java es un lenguaje
independiente del sistema operativo o plataforma en uso, y no todos los sistemas poseen la misma manera de
representar ventanas o controles.
Esto también significa que la creación de la interfaz gráfica se hace desde el código. Si no se utiliza un entorno
de desarrollo, la creación de interfaces gráficas complejas resulta algo tedioso por ser un proceso de prueba y
error.
Para facilitar un poco el proceso, existen ciertas clases auxiliares conocidas como diseñadores o
administradores de diseño. Dichas clases constituyen una especie de plantillas para colocar controles. Algunas
de ellas son:
● FlowLayout: diseñador de flujo, coloca los controles uno después de otro, de izquierda a derecha y de
arriba a abajo. La alineación generar puede ser a la izquierda, centrada o a la derecha.
● GridLayout: diseñador de cuadrícula, coloca los controles en una matriz de N x N filas y columnas.
● BorderLayout: diseñador de borde, posiciona los controles en forma de marco, un control central grande
rodeado de los demás controles (uno por lado).
● CardLayout: diseñador de naipe, divide los controles entre el área visible y varias "páginas" virtuales,
sólo una página puede estar visible a la vez.
● GridBagLayout: diseñador de cuadrícula mejorado, permite colocar controles que abarcan varias celdas
en ambos sentidos, así como asignar proporciones a filas y columnas.
67/73
____________________________________________________________________________________
Para interfaces avanzadas, es posible combinar diferentes diseñadores, controles normales y controles
contenedores, con lo cual se logra una apariencia más sofisticada que si sólo se usara uno de los diseñadores
7.8. Controles comunes
A continuación se mencionan algunos controles de uso común en una interfaz gráfica:
● Label: etiqueta
● Button: botón
● Checkbox: casilla o botón de radio (según los argumentos de creación)
● Choice: cuadro combinado (combo)
● List: cuadro de lista
● TextField: cuadro de texto de una sola línea
● TextArea: área de texto de líneas múltiples
● ScrollBar: barra de desplazamiento
● Canvas: área de dibujo
● Panel: control contenedor para otros controles
Para crear una interfaz gráfica, normalmente se utiliza este proceso general:
1. Crear un objeto diseñador
2. Asociarlo con el área del applet o ventana
3. Crear los diferentes controles
4. Agregar cada control al diseñador
7.9. Manejo de eventos
Un evento es cualquier acción ejecutada por el usuario o en algunos casos el sistema. En una interfaz gráfica,
los eventos más comunes son los que tienen que ver con el mouse o el teclado.
Java posee diferentes formas de manejar eventos. Algunas de las alternativas son:
● Crear un método llamado action, el cual ejecuta diferentes operaciones en base al tipo y nombre del
control que recibe el evento. Esta opción es relativamente sencilla pero se considera obsoleta.
● Crear una subclase derivada del control que se quiere utilizar y sobrecargar los métodos asociados con
los eventos necesarios.
● Implementar alguna interfaz derivada de EventListener y registrar los eventos que se van a monitorear.
Nota: aquí el término "interfaz" no hace referencia a la interfaz gráfica, sino a una interfaz de clase. Este
concepto se estudiará más adelante.
En esta práctica, el manejo de eventos se hará mediante el método action por razones de simplicidad, aunque
68/73
____________________________________________________________________________________
su uso ya no se recomienda en versiones recientes de Java
Ejemplo: una interfaz para calcular intereses(archivo cal_prestamo.java)
import java.applet.*;
import java.awt.*;
public class cal_prestamo extends Applet{

TextField campo_interes=new TextField("",15); //creación de controles
TextField campo_anios=new TextField("",15); //como cuadros de texto
TextField campo_cantidad=new TextField("",15);
Label cant_pago=new Label("",Label.LEFT);//etiquetas
Button boton=new Button("Calcular");//y botones
//Método para calcular el pago mensual del préstamo

double calc_pago(double interes,double cantidad,int anios){
int num_pagos=anios*12;
double interes_mensual=1.0+interes/1200;
double pn=1.0;
double v0=0.0;//formulas y datos de rigor
//cantidad del préstamo por $1 del pago mensual

for(int i=0;i<num_pagos;i++){
pn*=interes_mensual;
v0+=1.0/pn;
}
return(cantidad/v0);//regresar pago mensual

}
public void init(){//evento para inicializar el applet

setLayout(new GridLayout(5,2,3,2));
add(new Label("Interés Anual %:",Label.RIGHT));
add(campo_interes);
add(new Label("Nmero de Años:",Label.RIGHT));
add(campo_anios);
add(new Label("Cantidad del Préstamo $:", Label.RIGHT));
add(campo_cantidad);
add(new Label("Pago Mensual $:",Label.RIGHT));
add(cant_pago);
add(new Label());
add(boton);//similar al trabajo con html o el modo gráfico de c/c++
}
public boolean action(Event evt,Object arg){//detector de eventos

double interes,cant_prestamo,cant_mensual;
int anios;
if(evt.target==boton){
//obtener las entradas del usuario
interes=Double.valueOf(campo_interes.getText()).doubleValue();//convers
iones
cant_prestamo=Double.valueOf(campo_cantidad.getText()).doubleValue();
69/73
____________________________________________________________________________________
anios=Integer.valueOf(campo_anios.getText()).intValue();
//calcular pago mensual

cant_mensual=calc_pago(interes,cant_prestamo,anios);
//poner el resultado en la etiqueta de pago

cant_pago.setText(String.valueOf(cant_mensual));
return true;//evento procesado
}
return false;
}
}//fin del programa
Al ejecutarlo quedaría asi:
¿Cómo haría usted para que solo muestre 2 decimales?
70/73
____________________________________________________________________________________
Haga usted, un applet que genere el siguiente gráfico de barras (las barras no son estáticas):
71/73
____________________________________________________________________________________
FUENTES DE INFORMACIÓN:
Libros(ambos en biblioteca de UDB):
● JAVA, Como Programar, quinta edición; Deitel & Deitel 2005.
● 1001 Tips para programar en Java, McGraw Hill 2000.
Material didáctico adicional:
● Guias de laboratorio de Lenguaje de Programación III, Universidad Don Bosco, Facultad de Estudios
Tecnológicos; años 2002 2006. Autores: Téc. Carlos Montalvo, Ing. Xtecuan!Ufo, Ing. Carlos Tejada.
● Capacitación de Java; Ing. Rolando Girón, Universidad Don Bosco, Febrero – Abril 2005.
URL's:
● http://www.programacion.com/java/
● http://xtecuan.8m.com
● www.apl.jhu.edu/~ hall
/java/

● http://www.itapizaco.edu.mx/paginas/JavaTut/froufe/parte10/cap101.html
● Otros sitios por ahí.
72/73
____________________________________________________________________________________
INVESTIGACIÓN PARA EL PRIMER PERÍODO
Realice una investigación monográfica respecto a la característica multihilo de Java y como aplicar los hilos con
el lenguaje de programación.
Recuerde que es una “investigación”, no un “trabajo”.
Detalles:
● Fecha de entrega: el día del examen teórico, 11pm a mas tardar.
● Grupos de 5 máximo, todos de la misma sección (sección inscrita, no a la que asiste).
● Se entregará como reporte, en formato .pdf a ctejada@gmail.com.
● Incluya todo lo que una investigación debe incluir.
● Incluya ejemplos.
● Evite Copiar/Pegar e ir a buscar información de donde otros compañeros ya buscaron.
● La investigación se evalúa en el examen teórico.
● No se desvele mucho, haga ejercicio y coma bien.
C.J.T.F./2007
73/73

Guion1 Java2007

Hochgeladen von

Dokumentinformationen

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Guion1 Java2007

Hochgeladen von

Copyright:

Verfügbare Formate

____________________________________________________________________________________

Operador Uso Descripción

Operador Uso Devuelve verdadero si

Operador Uso Devuelve verdadero si

abstract else long synchronized

public class Ejemplo3{//clase para la serie, tope hasta 50

System.out.print("Escriba hasta adónde sacar la serie:");//mensaje y captura valor

arr[0]=0; //inicializar los primeros elementos, ya que siempre serán 0 y 1

//llenar los demás elementos

//programa que genera los valores de la ecuación cuadrática

public class Ejemplo4 {

float a,b,c,contenido_raiz; //recordemos que la fórmula de la cuadrática es

//pedir los datos ahora

//obtener el contenido de la raíz cuadrada

//evaluar el contenido de la raíz cuadrada, recordemos que no hay raíz cuadrada de

Las salidas de este programa serían:

public class java1420 extends JFrame implements ActionListener {//aplicación de herencias

public void actionPerformed( ActionEvent evt ) {

if( res == JOptionPane.YES_OPTION )

public static void main( String args[] ) {

La salida de este programa sería:

definidas. Tanto Nombre_De_Clase, como los nombre_de_atributo y nombre_de_método, han de ser

tipo_devuelto nombre_de_método( lista-formal-de-parámetros ) {

int metodoSuma( int paramX, int paramY ) {

void inicia( int paramX, int paramY ) {

MiPunto( int paraX, int paraY ) {

MiPunto p4 = new MiPunto( 10, 20 );

3.3. Acceso al objeto

MiPunto p6 = new MiPunto( 10, 20 );

void inicia2( int x, int y ) {

class CarroDeportivo extends Carro{

class Persona extends Familia{

void atrPersona(String nuevoDom){

public static void main(String arg[]){

Persona daniel=new Persona();

Pintura(String t,String c){

Pintura p=new Pintura("Acrilico","Verde");

protected void finalize() throws Throwable{

private default protected public

Misma clase Si Si Si Si

Recta(char nombre,int origenX,int origenY,int finX,int finY){

public static void main(String arg[]){

System.out.print("Escriba su nombre: ");

public static void main(String[] args) throws IOException{

Serie personal de Xtecuan Ufo!(solo el sabe para que sirve):

public static long SumPrimos(int n){

//esta es la clase que utilizaremos como abstracta

public Figura(double x,double y){//el contructor de esta clase

public abstract double area ();//método abstracto, vacío, a ser sustituido en

//esta es una clase que hereda de la abtract Figura

public class Circulo extends Figura{//heredamos de la clase Figura

public double area(){//nueva definición del método area

Circulo aro=new Circulo(x,y,radio);//creación del objeto, y uso de su

//enviar una respuesta a pantalla, finalización

public Cuadrado (double x,double y){//creación del nuevo constructor

Cuadrado rect=new Cuadrado(x,y);//nueva llamada al constructor, son menos

//envío del resultado

//implementación de la interfaz, ahora sin mas que la definición del método

public class Circulo implements Figura{//ahora ya no es herencia, es implementación

Circulo aro=new Circulo(x,y,radio);//creación del objeto, y uso de su

//enviar una respuesta a pantalla, finalización

//este es otro ejemplo de interfaz, el cálculo del área para un rectángulo es

Cuadrado rect=new Cuadrado(x,y);